_ZnwmPv21boost_container_new_t: 19| 872k|{ return p; } _ZN5boost9container3pmr15memory_resource8allocateEmm: 45| 872k| { 46| | //Obtain a pointer to enough storage and initialize the lifetime 47| | //of an array object of the given size in the address 48| 872k| return ::operator new(bytes, this->do_allocate(bytes, alignment), boost_container_new_t()); 49| 872k| } _ZN5boost9container3pmr15memory_resource10deallocateEPvmm: 54| 872k| { return this->do_deallocate(p, bytes, alignment); } _ZNK5boost4core17basic_string_viewIcE4dataEv: 542| 2.56M| { 543| 2.56M| return p_; 544| 2.56M| } _ZNK5boost4core17basic_string_viewIcE4sizeEv: 492| 6.07M| { 493| 6.07M| return n_; 494| 6.07M| } _ZN5boost4coreeqENS0_17basic_string_viewIcEES2_: 964| 814k| { 965| 814k| return sv1.size() == sv2.size() && traits_type::compare( sv1.data(), sv2.data(), sv1.size() ) == 0; ------------------ | Branch (965:16): [True: 813k, False: 1.23k] | Branch (965:44): [True: 811k, False: 2.06k] ------------------ 966| 814k| } _ZNK5boost4core17basic_string_viewIcE5beginEv: 450| 813k| { 451| 813k| return p_; 452| 813k| } _ZNK5boost4core17basic_string_viewIcE3endEv: 455| 813k| { 456| 813k| return p_ + n_; 457| 813k| } _ZN5boost4coreneENS0_17basic_string_viewIcEES2_: 969| 811k| { 970| 811k| return !( sv1 == sv2 ); 971| 811k| } _ZN5boost4json12basic_parserINS0_6detail7handlerEED2Ev: 513| 6.62k| ~basic_parser() = default; _ZNK5boost4json12basic_parserINS0_6detail7handlerEE4doneEv: 614| 1.99k| { 615| 1.99k| return done_; 616| 1.99k| } _ZN5boost4json12basic_parserINS0_6detail7handlerEE7handlerEv: 555| 15.2k| { 556| 15.2k| return h_; 557| 15.2k| } _ZN5boost4json12basic_parserINS0_6detail7handlerEEC2IJNS0_11storage_ptrERPhRmEEERKNS0_13parse_optionsEDpOT_: 2656| 6.62k|{ 2657| 6.62k|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE5resetEv: 2665| 13.2k|{ 2666| 13.2k| ec_ = {}; 2667| 13.2k| st_.clear(); 2668| 13.2k| more_ = true; 2669| 13.2k| done_ = false; 2670| 13.2k| clean_ = true; 2671| 13.2k|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE10write_someEbPKcmRNS_6system10error_codeE: 2701| 6.62k|{ 2702| | // see if we exited via exception 2703| | // on the last call to write_some 2704| 6.62k| if(! clean_) ------------------ | Branch (2704:8): [True: 0, False: 6.62k] ------------------ 2705| 0| { 2706| | // prevent UB 2707| 0| if(! ec_) ------------------ | Branch (2707:12): [True: 0, False: 0] ------------------ 2708| 0| { 2709| 0| BOOST_JSON_FAIL(ec_, error::exception); ------------------ | | 20| 0| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; \ | | ------------------ | | | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) | | ------------------ | | 21| 0| (ec).assign(e, &loc); ------------------ 2710| 0| } 2711| 0| } 2712| 6.62k| if(ec_) ------------------ | Branch (2712:8): [True: 0, False: 6.62k] ------------------ 2713| 0| { 2714| | // error is sticky 2715| 0| ec = ec_; 2716| 0| return 0; 2717| 0| } 2718| 6.62k| clean_ = false; 2719| 6.62k| more_ = more; 2720| 6.62k| end_ = data + size; 2721| 6.62k| const char* p; 2722| 6.62k| if(BOOST_JSON_LIKELY(st_.empty())) ------------------ | | 171| 6.62k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 6.62k, False: 0] | | ------------------ ------------------ 2723| 6.62k| { 2724| | // first time 2725| 6.62k| depth_ = opt_.max_depth; 2726| 6.62k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 6.62k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 6.62k] | | ------------------ ------------------ 2727| 6.62k| ! h_.on_document_begin(ec_))) 2728| 0| { 2729| 0| ec = ec_; 2730| 0| return 0; 2731| 0| } 2732| 6.62k| p = parse_document(data, std::true_type()); 2733| 6.62k| } 2734| 0| else 2735| 0| { 2736| 0| p = parse_document(data, std::false_type()); 2737| 0| } 2738| | 2739| 6.62k| if(BOOST_JSON_LIKELY(p != sentinel())) ------------------ | | 171| 6.62k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 2.44k, False: 4.17k] | | ------------------ ------------------ 2740| 2.44k| { 2741| 2.44k| BOOST_ASSERT(! ec_); ------------------ | | 60| 2.44k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2742| 2.44k| if(! done_) ------------------ | Branch (2742:12): [True: 2.44k, False: 0] ------------------ 2743| 2.44k| { 2744| 2.44k| done_ = true; 2745| 2.44k| h_.on_document_end(ec_); 2746| 2.44k| } 2747| 2.44k| } 2748| 4.17k| else 2749| 4.17k| { 2750| 4.17k| if(! ec_) ------------------ | Branch (2750:12): [True: 1.93k, False: 2.24k] ------------------ 2751| 1.93k| { 2752| 1.93k| if(! more_) ------------------ | Branch (2752:16): [True: 1.93k, False: 0] ------------------ 2753| 1.93k| { 2754| 1.93k| BOOST_JSON_FAIL(ec_, error::incomplete); ------------------ | | 20| 1.93k| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; \ | | ------------------ | | | | 170| 1.93k|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) | | ------------------ | | 21| 1.93k| (ec).assign(e, &loc); ------------------ 2755| 1.93k| } 2756| 0| else if(! st_.empty()) ------------------ | Branch (2756:21): [True: 0, False: 0] ------------------ 2757| 0| { 2758| | // consume as much trailing whitespace in 2759| | // the JSON document as possible, but still 2760| | // consider the parse complete 2761| 0| state st; 2762| 0| st_.peek(st); 2763| 0| if( st == state::doc3 && ------------------ | Branch (2763:21): [True: 0, False: 0] ------------------ 2764| 0| ! done_) ------------------ | Branch (2764:21): [True: 0, False: 0] ------------------ 2765| 0| { 2766| 0| done_ = true; 2767| 0| h_.on_document_end(ec_); 2768| 0| } 2769| 0| } 2770| 1.93k| } 2771| 4.17k| p = end_; 2772| 4.17k| } 2773| 6.62k| ec = ec_; 2774| 6.62k| clean_ = true; 2775| 6.62k| return p - data; 2776| 6.62k|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE14parse_documentILb1EEEPKcS7_NSt3__117integral_constantIbXT_EEE: 498| 6.62k|{ 499| 6.62k| detail::const_stream_wrapper cs(p, end_); 500| 6.62k| if(! stack_empty && ! st_.empty()) ------------------ | Branch (500:8): [Folded - Ignored] | Branch (500:25): [True: 0, False: 0] ------------------ 501| 0| { 502| 0| state st; 503| 0| st_.pop(st); 504| 0| switch(st) 505| 0| { 506| 0| default: BOOST_JSON_UNREACHABLE(); ------------------ | | 189| 0|# define BOOST_JSON_UNREACHABLE() __builtin_unreachable() ------------------ | Branch (506:9): [True: 0, False: 0] ------------------ 507| 0| case state::doc1: goto do_doc1; ------------------ | Branch (507:9): [True: 0, False: 0] ------------------ 508| 0| case state::doc2: goto do_doc2; ------------------ | Branch (508:9): [True: 0, False: 0] ------------------ 509| 0| case state::doc3: goto do_doc3; ------------------ | Branch (509:9): [True: 0, False: 0] ------------------ 510| 0| case state::doc4: goto do_doc4; ------------------ | Branch (510:9): [True: 0, False: 0] ------------------ 511| 0| } 512| 0| } 513| 6.62k|do_doc1: 514| 6.62k| cs = detail::count_whitespace(cs.begin(), cs.end()); 515| 6.62k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 6.62k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 25, False: 6.60k] | | ------------------ ------------------ 516| 25| return maybe_suspend(cs.begin(), state::doc1); 517| 6.60k|do_doc2: 518| 6.60k| switch(+opt_.allow_comments | 519| 6.60k| (opt_.allow_trailing_commas << 1) | 520| 6.60k| (opt_.allow_invalid_utf8 << 2)) 521| 6.60k| { 522| | // no extensions 523| 6.60k| default: ------------------ | Branch (523:5): [True: 6.60k, False: 0] ------------------ 524| 6.60k| cs = parse_value(cs.begin(), stack_empty, std::false_type(), std::false_type(), std::false_type()); 525| 6.60k| break; 526| | // comments 527| 0| case 1: ------------------ | Branch (527:5): [True: 0, False: 6.60k] ------------------ 528| 0| cs = parse_value(cs.begin(), stack_empty, std::true_type(), std::false_type(), std::false_type()); 529| 0| break; 530| | // trailing 531| 0| case 2: ------------------ | Branch (531:5): [True: 0, False: 6.60k] ------------------ 532| 0| cs = parse_value(cs.begin(), stack_empty, std::false_type(), std::true_type(), std::false_type()); 533| 0| break; 534| | // comments & trailing 535| 0| case 3: ------------------ | Branch (535:5): [True: 0, False: 6.60k] ------------------ 536| 0| cs = parse_value(cs.begin(), stack_empty, std::true_type(), std::true_type(), std::false_type()); 537| 0| break; 538| | // skip validation 539| 0| case 4: ------------------ | Branch (539:5): [True: 0, False: 6.60k] ------------------ 540| 0| cs = parse_value(cs.begin(), stack_empty, std::false_type(), std::false_type(), std::true_type()); 541| 0| break; 542| | // comments & skip validation 543| 0| case 5: ------------------ | Branch (543:5): [True: 0, False: 6.60k] ------------------ 544| 0| cs = parse_value(cs.begin(), stack_empty, std::true_type(), std::false_type(), std::true_type()); 545| 0| break; 546| | // trailing & skip validation 547| 0| case 6: ------------------ | Branch (547:5): [True: 0, False: 6.60k] ------------------ 548| 0| cs = parse_value(cs.begin(), stack_empty, std::false_type(), std::true_type(), std::true_type()); 549| 0| break; 550| | // comments & trailing & skip validation 551| 0| case 7: ------------------ | Branch (551:5): [True: 0, False: 6.60k] ------------------ 552| 0| cs = parse_value(cs.begin(), stack_empty, std::true_type(), std::true_type(), std::true_type()); 553| 0| break; 554| 6.60k| } 555| 6.60k| if(BOOST_JSON_UNLIKELY(incomplete(cs))) ------------------ | | 179| 6.60k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 4.15k, False: 2.44k] | | ------------------ ------------------ 556| 4.15k| return suspend_or_fail(state::doc2); 557| 2.44k|do_doc3: 558| 2.44k| cs = detail::count_whitespace(cs.begin(), cs.end()); 559| 2.44k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 2.44k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 1.99k, False: 451] | | ------------------ ------------------ 560| 1.99k| { 561| 1.99k| if(more_) ------------------ | Branch (561:12): [True: 0, False: 1.99k] ------------------ 562| 0| return suspend(cs.begin(), state::doc3); 563| 1.99k| } 564| 451| else if(opt_.allow_comments && *cs == '/') ------------------ | Branch (564:13): [True: 0, False: 451] | Branch (564:36): [True: 0, False: 0] ------------------ 565| 0| { 566| 0|do_doc4: 567| 0| cs = parse_comment(cs.begin(), stack_empty, std::true_type()); 568| 0| if(BOOST_JSON_UNLIKELY(incomplete(cs))) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 569| 0| return suspend_or_fail(state::doc4); 570| 0| goto do_doc3; 571| 0| } 572| 2.44k| return cs.begin(); 573| 2.44k|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE13maybe_suspendEPKcNS4_5stateE: 306| 61|{ 307| 61| end_ = p; 308| 61| if(BOOST_JSON_LIKELY(more_)) ------------------ | | 171| 61|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 0, False: 61] | | ------------------ ------------------ 309| 0| { 310| | // suspend 311| 0| reserve(); 312| 0| st_.push_unchecked(st); 313| 0| } 314| 61| return sentinel(); 315| 61|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE11parse_valueILb1ELb0EEEPKcS7_NSt3__117integral_constantIbXT_EEENS9_IbXT0_EEEbb: 588| 2.45M|{ 589| 2.45M| if(stack_empty || st_.empty()) ------------------ | Branch (589:8): [Folded - Ignored] | Branch (589:23): [True: 0, False: 0] ------------------ 590| 2.45M| { 591| 2.45M|loop: 592| 2.45M| switch(*p) 593| 2.45M| { 594| 35.8k| case '0': ------------------ | Branch (594:9): [True: 35.8k, False: 2.42M] ------------------ 595| 35.8k| return parse_number(p, std::true_type(), std::integral_constant()); 596| 12.2k| case '-': ------------------ | Branch (596:9): [True: 12.2k, False: 2.44M] ------------------ 597| 12.2k| return parse_number(p, std::true_type(), std::integral_constant()); 598| 228k| case '1': case '2': case '3': ------------------ | Branch (598:9): [True: 117k, False: 2.33M] | Branch (598:19): [True: 67.1k, False: 2.38M] | Branch (598:29): [True: 43.0k, False: 2.41M] ------------------ 599| 785k| case '4': case '5': case '6': ------------------ | Branch (599:9): [True: 105k, False: 2.35M] | Branch (599:19): [True: 17.7k, False: 2.43M] | Branch (599:29): [True: 434k, False: 2.02M] ------------------ 600| 2.34M| case '7': case '8': case '9': ------------------ | Branch (600:9): [True: 695k, False: 1.76M] | Branch (600:19): [True: 804k, False: 1.65M] | Branch (600:29): [True: 58.9k, False: 2.39M] ------------------ 601| 2.34M| return parse_number(p, std::true_type(), std::integral_constant()); 602| 6.76k| case 't': ------------------ | Branch (602:9): [True: 6.76k, False: 2.44M] ------------------ 603| 6.76k| return parse_true(p, std::true_type()); 604| 324| case 'f': ------------------ | Branch (604:9): [True: 324, False: 2.45M] ------------------ 605| 324| return parse_false(p, std::true_type()); 606| 2.62k| case 'n': ------------------ | Branch (606:9): [True: 2.62k, False: 2.45M] ------------------ 607| 2.62k| return parse_null(p, std::true_type()); 608| 34.9k| case '"': ------------------ | Branch (608:9): [True: 34.9k, False: 2.42M] ------------------ 609| 34.9k| return parse_unescaped(p, std::true_type(), std::false_type(), allow_bad_utf8); 610| 4.61k| case '[': ------------------ | Branch (610:9): [True: 4.61k, False: 2.45M] ------------------ 611| 4.61k| return parse_array(p, std::true_type(), allow_comments, allow_trailing, allow_bad_utf8); 612| 14.3k| case '{': ------------------ | Branch (612:9): [True: 14.3k, False: 2.44M] ------------------ 613| 14.3k| return parse_object(p, std::true_type(), allow_comments, allow_trailing, allow_bad_utf8); 614| 3| case '/': ------------------ | Branch (614:9): [True: 3, False: 2.45M] ------------------ 615| 3| if(! allow_comments) ------------------ | Branch (615:16): [Folded - Ignored] ------------------ 616| 3| { 617| 3| BOOST_STATIC_CONSTEXPR source_location loc 618| 3| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 3|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 619| 3| return fail(p, error::syntax, &loc); 620| 3| } 621| 0| p = parse_comment(p, stack_empty, std::false_type()); 622| | // KRYSTIAN NOTE: incomplete takes const_stream, we either 623| | // can add an overload, change the existing one to take a pointer, 624| | // or just leave it as is 625| 0| if(BOOST_JSON_UNLIKELY(p == sentinel())) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 626| 0| return maybe_suspend(p, state::val2); 627| | // intentional fallthrough 628| 0| case ' ': ------------------ | Branch (628:9): [True: 0, False: 2.45M] ------------------ 629| 0| case '\t': ------------------ | Branch (629:9): [True: 0, False: 2.45M] ------------------ 630| 0| case '\n': ------------------ | Branch (630:9): [True: 0, False: 2.45M] ------------------ 631| 0| case '\r': ------------------ | Branch (631:9): [True: 0, False: 2.45M] ------------------ 632| 0| p = detail::count_whitespace(p, end_); 633| 0| if(BOOST_JSON_UNLIKELY(p == end_)) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 634| 0| return maybe_suspend(p, state::val1); 635| 0| goto loop; 636| 262| default: ------------------ | Branch (636:9): [True: 262, False: 2.45M] ------------------ 637| 262| { 638| 262| BOOST_STATIC_CONSTEXPR source_location loc 639| 262| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 262|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 640| 262| return fail(p, error::syntax, &loc); 641| 0| } 642| 2.45M| } 643| 2.45M| } 644| 0| return resume_value(p, stack_empty, allow_comments, allow_trailing, allow_bad_utf8); 645| 2.45M|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE12parse_numberILb1ELc48EEEPKcS7_NSt3__117integral_constantIbXT_EEENS9_IcXT0_EEE: 1991| 35.8k|{ 1992| | // only one of these will be true if we are not resuming 1993| | // if negative then !zero_first && !nonzero_first 1994| | // if zero_first then !nonzero_first && !negative 1995| | // if nonzero_first then !zero_first && !negative 1996| 35.8k| bool const negative = first == '-'; 1997| 35.8k| bool const zero_first = first == '0'; 1998| 35.8k| bool const nonzero_first = first == '+'; 1999| 35.8k| detail::const_stream_wrapper cs(p, end_); 2000| 35.8k| number num; 2001| 35.8k| const char* begin = cs.begin(); 2002| 35.8k| if(stack_empty || st_.empty()) ------------------ | Branch (2002:8): [Folded - Ignored] | Branch (2002:23): [True: 0, False: 0] ------------------ 2003| 35.8k| { 2004| 35.8k| num.bias = 0; 2005| 35.8k| num.exp = 0; 2006| 35.8k| num.frac = false; 2007| | 2008| | //---------------------------------- 2009| | // 2010| | // '-' 2011| | // leading minus sign 2012| | // 2013| 35.8k| BOOST_ASSERT(cs); ------------------ | | 60| 35.8k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2014| 35.8k| if(negative) ------------------ | Branch (2014:12): [Folded - Ignored] ------------------ 2015| 0| ++cs; 2016| | 2017| 35.8k| num.neg = negative; 2018| 35.8k| num.frac = false; 2019| 35.8k| num.exp = 0; 2020| 35.8k| num.bias = 0; 2021| | 2022| | // fast path 2023| 35.8k| if( cs.remain() >= 16 + 1 + 16 ) // digits . digits ------------------ | Branch (2023:13): [True: 34.2k, False: 1.62k] ------------------ 2024| 34.2k| { 2025| 34.2k| int n1; 2026| | 2027| 34.2k| if( nonzero_first || ------------------ | Branch (2027:17): [Folded - Ignored] ------------------ 2028| 34.2k| (negative && *cs != '0') ) ------------------ | Branch (2028:18): [Folded - Ignored] | Branch (2028:30): [True: 0, False: 0] ------------------ 2029| 0| { 2030| 0| n1 = detail::count_digits( cs.begin() ); 2031| 0| BOOST_ASSERT(n1 >= 0 && n1 <= 16); ------------------ | | 60| 0|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2032| | 2033| 0| if( ! nonzero_first && n1 == 0 ) ------------------ | Branch (2033:21): [Folded - Ignored] | Branch (2033:40): [True: 0, False: 0] ------------------ 2034| 0| { 2035| | // digit required 2036| 0| BOOST_STATIC_CONSTEXPR source_location loc 2037| 0| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2038| 0| return fail(cs.begin(), error::syntax, &loc); 2039| 0| } 2040| | 2041| 0| num.mant = detail::parse_unsigned( 0, cs.begin(), n1 ); 2042| | 2043| 0| cs += n1; 2044| | 2045| | // integer or floating-point with 2046| | // >= 16 leading digits 2047| 0| if( n1 == 16 ) ------------------ | Branch (2047:21): [True: 0, False: 0] ------------------ 2048| 0| { 2049| 0| goto do_num2; 2050| 0| } 2051| 0| } 2052| 34.2k| else 2053| 34.2k| { 2054| | // 0. floating-point or 0e integer 2055| 34.2k| num.mant = 0; 2056| 34.2k| n1 = 0; 2057| 34.2k| ++cs; 2058| 34.2k| } 2059| | 2060| 34.2k| { 2061| 34.2k| const char c = *cs; 2062| 34.2k| if(c != '.') ------------------ | Branch (2062:20): [True: 31.0k, False: 3.16k] ------------------ 2063| 31.0k| { 2064| 31.0k| if((c | 32) == 'e') ------------------ | Branch (2064:24): [True: 1.99k, False: 29.0k] ------------------ 2065| 1.99k| { 2066| 1.99k| ++cs; 2067| 1.99k| goto do_exp1; 2068| 1.99k| } 2069| 29.0k| if(negative) ------------------ | Branch (2069:24): [Folded - Ignored] ------------------ 2070| 0| num.mant = ~num.mant + 1; 2071| 29.0k| goto finish_signed; 2072| 31.0k| } 2073| 34.2k| } 2074| | 2075| | // floating-point number 2076| | 2077| 3.16k| ++cs; 2078| | 2079| 3.16k| int n2 = detail::count_digits( cs.begin() ); 2080| 3.16k| BOOST_ASSERT(n2 >= 0 && n2 <= 16); ------------------ | | 60| 3.16k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2081| | 2082| 3.16k| if( n2 == 0 ) ------------------ | Branch (2082:17): [True: 1, False: 3.16k] ------------------ 2083| 1| { 2084| | // digit required 2085| 1| BOOST_STATIC_CONSTEXPR source_location loc 2086| 1| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 1|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2087| 1| return fail(cs.begin(), error::syntax, &loc); 2088| 1| } 2089| | 2090| | // floating-point mantissa overflow 2091| 3.16k| if( n1 + n2 >= 19 ) ------------------ | Branch (2091:17): [True: 0, False: 3.16k] ------------------ 2092| 0| { 2093| 0| goto do_num7; 2094| 0| } 2095| | 2096| 3.16k| num.mant = detail::parse_unsigned( num.mant, cs.begin(), n2 ); 2097| | 2098| 3.16k| BOOST_ASSERT(num.bias == 0); ------------------ | | 60| 3.16k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2099| | 2100| 3.16k| num.bias -= n2; 2101| | 2102| 3.16k| cs += n2; 2103| | 2104| 3.16k| char ch = *cs; 2105| | 2106| 3.16k| if( (ch | 32) == 'e' ) ------------------ | Branch (2106:17): [True: 276, False: 2.89k] ------------------ 2107| 276| { 2108| 276| ++cs; 2109| 276| goto do_exp1; 2110| 276| } 2111| 2.89k| else if( ch >= '0' && ch <= '9' ) ------------------ | Branch (2111:22): [True: 1.27k, False: 1.61k] | Branch (2111:35): [True: 1.06k, False: 203] ------------------ 2112| 1.06k| { 2113| 1.06k| goto do_num8; 2114| 1.06k| } 2115| | 2116| 1.82k| goto finish_dub; 2117| 3.16k| } 2118| 35.8k| } 2119| 0| else 2120| 0| { 2121| 0| num = num_; 2122| 0| state st; 2123| 0| st_.pop(st); 2124| 0| switch(st) 2125| 0| { 2126| 0| default: BOOST_JSON_UNREACHABLE(); ------------------ | | 189| 0|# define BOOST_JSON_UNREACHABLE() __builtin_unreachable() ------------------ | Branch (2126:9): [True: 0, False: 0] ------------------ 2127| 0| case state::num1: goto do_num1; ------------------ | Branch (2127:9): [True: 0, False: 0] ------------------ 2128| 0| case state::num2: goto do_num2; ------------------ | Branch (2128:9): [True: 0, False: 0] ------------------ 2129| 0| case state::num3: goto do_num3; ------------------ | Branch (2129:9): [True: 0, False: 0] ------------------ 2130| 0| case state::num4: goto do_num4; ------------------ | Branch (2130:9): [True: 0, False: 0] ------------------ 2131| 0| case state::num5: goto do_num5; ------------------ | Branch (2131:9): [True: 0, False: 0] ------------------ 2132| 0| case state::num6: goto do_num6; ------------------ | Branch (2132:9): [True: 0, False: 0] ------------------ 2133| 0| case state::num7: goto do_num7; ------------------ | Branch (2133:9): [True: 0, False: 0] ------------------ 2134| 0| case state::num8: goto do_num8; ------------------ | Branch (2134:9): [True: 0, False: 0] ------------------ 2135| 0| case state::exp1: goto do_exp1; ------------------ | Branch (2135:9): [True: 0, False: 0] ------------------ 2136| 0| case state::exp2: goto do_exp2; ------------------ | Branch (2136:9): [True: 0, False: 0] ------------------ 2137| 0| case state::exp3: goto do_exp3; ------------------ | Branch (2137:9): [True: 0, False: 0] ------------------ 2138| 0| } 2139| 0| } 2140| | 2141| | //---------------------------------- 2142| | // 2143| | // DIGIT 2144| | // first digit 2145| | // 2146| 1.62k|do_num1: 2147| 1.62k| if(zero_first || nonzero_first || ------------------ | Branch (2147:8): [Folded - Ignored] | Branch (2147:22): [Folded - Ignored] ------------------ 2148| 1.62k| BOOST_JSON_LIKELY(cs)) ------------------ | | 171| 0|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 0, False: 0] | | ------------------ ------------------ 2149| 1.62k| { 2150| 1.62k| char const c = *cs; 2151| 1.62k| if(zero_first) ------------------ | Branch (2151:12): [Folded - Ignored] ------------------ 2152| 1.62k| { 2153| 1.62k| ++cs; 2154| 1.62k| num.mant = 0; 2155| 1.62k| goto do_num6; 2156| 1.62k| } 2157| 0| else if(nonzero_first || BOOST_JSON_LIKELY( ------------------ | | 171| 0|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 0, False: 0] | | | Branch (171:52): [True: 0, False: 0] | | | Branch (171:52): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2157:17): [Folded - Ignored] ------------------ 2158| 0| c >= '1' && c <= '9')) 2159| 0| { 2160| 0| ++cs; 2161| 0| num.mant = c - '0'; 2162| 0| } 2163| 0| else if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2164| 0| c == '0')) 2165| 0| { 2166| 0| ++cs; 2167| 0| num.mant = 0; 2168| 0| goto do_num6; 2169| 0| } 2170| 0| else 2171| 0| { 2172| 0| BOOST_STATIC_CONSTEXPR source_location loc 2173| 0| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2174| 0| return fail(cs.begin(), error::syntax, &loc); 2175| 0| } 2176| 1.62k| } 2177| 0| else 2178| 0| { 2179| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2180| 0| ! h_.on_number_part( 2181| 0| {begin, cs.used(begin)}, ec_))) 2182| 0| return fail(cs.begin()); 2183| 0| return maybe_suspend( 2184| 0| cs.begin(), state::num1, num); 2185| 0| } 2186| | 2187| | //---------------------------------- 2188| | // 2189| | // 1*DIGIT 2190| | // significant digits left of decimal 2191| | // 2192| 0|do_num2: 2193| 0| if(negative || (!stack_empty && num.neg)) ------------------ | Branch (2193:8): [Folded - Ignored] | Branch (2193:21): [Folded - Ignored] | Branch (2193:37): [True: 0, False: 0] ------------------ 2194| 0| { 2195| 0| for(;;) 2196| 0| { 2197| 0| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2198| 0| { 2199| 0| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2200| 0| { 2201| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2202| 0| ! h_.on_number_part( 2203| 0| {begin, cs.used(begin)}, ec_))) 2204| 0| return fail(cs.begin()); 2205| 0| return suspend(cs.begin(), state::num2, num); 2206| 0| } 2207| 0| goto finish_int; 2208| 0| } 2209| 0| char const c = *cs; 2210| 0| if(BOOST_JSON_LIKELY( ------------------ | | 171| 0|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 0, False: 0] | | | Branch (171:52): [True: 0, False: 0] | | | Branch (171:52): [True: 0, False: 0] | | ------------------ ------------------ 2211| 0| c >= '0' && c <= '9')) 2212| 0| { 2213| 0| ++cs; 2214| | // 9223372036854775808 INT64_MIN 2215| 0| if( num.mant > 922337203685477580 || ( ------------------ | Branch (2215:21): [True: 0, False: 0] ------------------ 2216| 0| num.mant == 922337203685477580 && c > '8')) ------------------ | Branch (2216:21): [True: 0, False: 0] | Branch (2216:55): [True: 0, False: 0] ------------------ 2217| 0| break; 2218| 0| num.mant = 10 * num.mant + ( c - '0' ); 2219| 0| continue; 2220| 0| } 2221| 0| goto do_num6; // [.eE] 2222| 0| } 2223| 0| } 2224| 0| else 2225| 0| { 2226| 0| for(;;) 2227| 0| { 2228| 0| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2229| 0| { 2230| 0| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2231| 0| { 2232| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2233| 0| ! h_.on_number_part( 2234| 0| {begin, cs.used(begin)}, ec_))) 2235| 0| return fail(cs.begin()); 2236| 0| return suspend(cs.begin(), state::num2, num); 2237| 0| } 2238| 0| goto finish_int; 2239| 0| } 2240| 0| char const c = *cs; 2241| 0| if(BOOST_JSON_LIKELY( ------------------ | | 171| 0|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 0, False: 0] | | | Branch (171:52): [True: 0, False: 0] | | | Branch (171:52): [True: 0, False: 0] | | ------------------ ------------------ 2242| 0| c >= '0' && c <= '9')) 2243| 0| { 2244| 0| ++cs; 2245| | // 18446744073709551615 UINT64_MAX 2246| 0| if( num.mant > 1844674407370955161 || ( ------------------ | Branch (2246:21): [True: 0, False: 0] ------------------ 2247| 0| num.mant == 1844674407370955161 && c > '5')) ------------------ | Branch (2247:21): [True: 0, False: 0] | Branch (2247:56): [True: 0, False: 0] ------------------ 2248| 0| break; 2249| 0| num.mant = 10 * num.mant + ( c - '0' ); 2250| 0| } 2251| 0| else 2252| 0| { 2253| 0| goto do_num6; // [.eE] 2254| 0| } 2255| 0| } 2256| 0| } 2257| 0| ++num.bias; 2258| | 2259| | //---------------------------------- 2260| | // 2261| | // 1*DIGIT 2262| | // non-significant digits left of decimal 2263| | // 2264| 0|do_num3: 2265| 0| for(;;) 2266| 0| { 2267| 0| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2268| 0| { 2269| 0| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2270| 0| { 2271| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2272| 0| ! h_.on_number_part( 2273| 0| {begin, cs.used(begin)}, ec_))) 2274| 0| return fail(cs.begin()); 2275| 0| return suspend(cs.begin(), state::num3, num); 2276| 0| } 2277| 0| goto finish_dub; 2278| 0| } 2279| 0| char const c = *cs; 2280| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | | Branch (179:54): [True: 0, False: 0] | | | Branch (179:54): [True: 0, False: 0] | | ------------------ ------------------ 2281| 0| c >= '0' && c <= '9')) 2282| 0| { 2283| 0| ++cs; 2284| | // VFALCO check overflow 2285| 0| ++num.bias; 2286| 0| } 2287| 0| else if(BOOST_JSON_LIKELY( ------------------ | | 171| 0|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 0, False: 0] | | ------------------ ------------------ 2288| 0| c == '.')) 2289| 0| { 2290| 0| ++cs; 2291| 0| break; 2292| 0| } 2293| 0| else if((c | 32) == 'e') ------------------ | Branch (2293:17): [True: 0, False: 0] ------------------ 2294| 0| { 2295| 0| ++cs; 2296| 0| goto do_exp1; 2297| 0| } 2298| 0| else 2299| 0| { 2300| 0| goto finish_dub; 2301| 0| } 2302| 0| } 2303| | 2304| | //---------------------------------- 2305| | // 2306| | // DIGIT 2307| | // first non-significant digit 2308| | // to the right of decimal 2309| | // 2310| 0|do_num4: 2311| 0| { 2312| 0| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2313| 0| { 2314| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2315| 0| ! h_.on_number_part( 2316| 0| {begin, cs.used(begin)}, ec_))) 2317| 0| return fail(cs.begin()); 2318| 0| return maybe_suspend( 2319| 0| cs.begin(), state::num4, num); 2320| 0| } 2321| 0| char const c = *cs; 2322| 0| if(BOOST_JSON_LIKELY( ------------------ | | 171| 0|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 0, False: 0] | | | Branch (171:52): [True: 0, False: 0] | | | Branch (171:52): [True: 0, False: 0] | | ------------------ ------------------ 2323| | //static_cast(c - '0') < 10)) 2324| 0| c >= '0' && c <= '9')) 2325| 0| { 2326| 0| ++cs; 2327| 0| } 2328| 0| else 2329| 0| { 2330| | // digit required 2331| 0| BOOST_STATIC_CONSTEXPR source_location loc 2332| 0| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2333| 0| return fail(cs.begin(), error::syntax, &loc); 2334| 0| } 2335| 0| } 2336| | 2337| | //---------------------------------- 2338| | // 2339| | // 1*DIGIT 2340| | // non-significant digits 2341| | // to the right of decimal 2342| | // 2343| 544|do_num5: 2344| 544| for(;;) 2345| 1.42k| { 2346| 1.42k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 1.42k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 16, False: 1.40k] | | ------------------ ------------------ 2347| 16| { 2348| 16| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 16|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 16] | | ------------------ ------------------ 2349| 0| { 2350| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2351| 0| ! h_.on_number_part( 2352| 0| {begin, cs.used(begin)}, ec_))) 2353| 0| return fail(cs.begin()); 2354| 0| return suspend(cs.begin(), state::num5, num); 2355| 0| } 2356| 16| goto finish_dub; 2357| 16| } 2358| 1.40k| char const c = *cs; 2359| 1.40k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 2.49k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 877, False: 528] | | | Branch (171:52): [True: 1.08k, False: 317] | | | Branch (171:52): [True: 877, False: 211] | | ------------------ ------------------ 2360| 1.40k| c >= '0' && c <= '9')) 2361| 877| { 2362| 877| ++cs; 2363| 877| } 2364| 528| else if((c | 32) == 'e') ------------------ | Branch (2364:17): [True: 208, False: 320] ------------------ 2365| 208| { 2366| 208| ++cs; 2367| 208| goto do_exp1; 2368| 208| } 2369| 320| else 2370| 320| { 2371| 320| goto finish_dub; 2372| 320| } 2373| 1.40k| } 2374| | 2375| | //---------------------------------- 2376| | // 2377| | // [.eE] 2378| | // 2379| 1.62k|do_num6: 2380| 1.62k| { 2381| 1.62k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 1.62k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 14, False: 1.61k] | | ------------------ ------------------ 2382| 14| { 2383| 14| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 14|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 14] | | ------------------ ------------------ 2384| 0| { 2385| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2386| 0| ! h_.on_number_part( 2387| 0| {begin, cs.used(begin)}, ec_))) 2388| 0| return fail(cs.begin()); 2389| 0| return suspend(cs.begin(), state::num6, num); 2390| 0| } 2391| 14| goto finish_int; 2392| 14| } 2393| 1.61k| char const c = *cs; 2394| 1.61k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 1.61k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 315, False: 1.29k] | | ------------------ ------------------ 2395| 1.61k| c == '.')) 2396| 315| { 2397| 315| ++cs; 2398| 315| } 2399| 1.29k| else if((c | 32) == 'e') ------------------ | Branch (2399:17): [True: 563, False: 732] ------------------ 2400| 563| { 2401| 563| ++cs; 2402| 563| goto do_exp1; 2403| 563| } 2404| 732| else 2405| 732| { 2406| 732| goto finish_int; 2407| 732| } 2408| 1.61k| } 2409| | 2410| | //---------------------------------- 2411| | // 2412| | // DIGIT 2413| | // first significant digit 2414| | // to the right of decimal 2415| | // 2416| 315|do_num7: 2417| 315| { 2418| 315| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 315|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 6, False: 309] | | ------------------ ------------------ 2419| 6| { 2420| 6| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 6|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 6] | | ------------------ ------------------ 2421| 0| { 2422| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2423| 0| ! h_.on_number_part( 2424| 0| {begin, cs.used(begin)}, ec_))) 2425| 0| return fail(cs.begin()); 2426| 0| return suspend(cs.begin(), state::num7, num); 2427| 0| } 2428| | // digit required 2429| 6| BOOST_STATIC_CONSTEXPR source_location loc 2430| 6| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 6|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2431| 6| return fail(cs.begin(), error::syntax, &loc); 2432| 6| } 2433| 309| char const c = *cs; 2434| 309| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 607|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 15, False: 294] | | | Branch (179:54): [True: 11, False: 298] | | | Branch (179:54): [True: 4, False: 294] | | ------------------ ------------------ 2435| 309| c < '0' || c > '9')) 2436| 15| { 2437| | // digit required 2438| 15| BOOST_STATIC_CONSTEXPR source_location loc 2439| 15| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 15|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2440| 15| return fail(cs.begin(), error::syntax, &loc); 2441| 15| } 2442| 309| } 2443| | 2444| | //---------------------------------- 2445| | // 2446| | // 1*DIGIT 2447| | // significant digits 2448| | // to the right of decimal 2449| | // 2450| 1.36k|do_num8: 2451| 1.36k| for(;;) 2452| 3.83k| { 2453| 3.83k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 3.83k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 75, False: 3.76k] | | ------------------ ------------------ 2454| 75| { 2455| 75| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 75|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 75] | | ------------------ ------------------ 2456| 0| { 2457| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2458| 0| ! h_.on_number_part( 2459| 0| {begin, cs.used(begin)}, ec_))) 2460| 0| return fail(cs.begin()); 2461| 0| return suspend(cs.begin(), state::num8, num); 2462| 0| } 2463| 75| goto finish_dub; 2464| 75| } 2465| 3.76k| char const c = *cs; 2466| 3.76k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 7.02k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 3.01k, False: 744] | | | Branch (171:52): [True: 3.25k, False: 502] | | | Branch (171:52): [True: 3.01k, False: 242] | | ------------------ ------------------ 2467| 3.76k| c >= '0' && c <= '9')) 2468| 3.01k| { 2469| 3.01k| ++cs; 2470| 3.01k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 3.01k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 2.47k, False: 544] | | ------------------ ------------------ 2471| 3.01k| num.mant <= 9007199254740991)) // 2^53-1 2472| 2.47k| { 2473| 2.47k| --num.bias; 2474| 2.47k| num.mant = 10 * num.mant + ( c - '0' ); 2475| 2.47k| } 2476| 544| else 2477| 544| { 2478| 544| goto do_num5; 2479| 544| } 2480| 3.01k| } 2481| 744| else if((c | 32) == 'e') ------------------ | Branch (2481:17): [True: 236, False: 508] ------------------ 2482| 236| { 2483| 236| ++cs; 2484| 236| goto do_exp1; 2485| 236| } 2486| 508| else 2487| 508| { 2488| 508| goto finish_dub; 2489| 508| } 2490| 3.76k| } 2491| | 2492| | //---------------------------------- 2493| | // 2494| | // *[+-] 2495| | // 2496| 3.28k|do_exp1: 2497| 3.28k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 3.28k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 20, False: 3.26k] | | ------------------ ------------------ 2498| 20| { 2499| 20| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 20|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 20] | | ------------------ ------------------ 2500| 20| ! h_.on_number_part( 2501| 20| {begin, cs.used(begin)}, ec_))) 2502| 0| return fail(cs.begin()); 2503| 20| return maybe_suspend( 2504| 20| cs.begin(), state::exp1, num); 2505| 20| } 2506| 3.26k| if(*cs == '+') ------------------ | Branch (2506:8): [True: 601, False: 2.65k] ------------------ 2507| 601| { 2508| 601| ++cs; 2509| 601| } 2510| 2.65k| else if(*cs == '-') ------------------ | Branch (2510:13): [True: 807, False: 1.85k] ------------------ 2511| 807| { 2512| 807| ++cs; 2513| 807| num.frac = true; 2514| 807| } 2515| | 2516| | //---------------------------------- 2517| | // 2518| | // DIGIT 2519| | // first digit of the exponent 2520| | // 2521| 3.26k|do_exp2: 2522| 3.26k| { 2523| 3.26k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 3.26k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 14, False: 3.24k] | | ------------------ ------------------ 2524| 14| { 2525| 14| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 14|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 14] | | ------------------ ------------------ 2526| 0| { 2527| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2528| 0| ! h_.on_number_part( 2529| 0| {begin, cs.used(begin)}, ec_))) 2530| 0| return fail(cs.begin()); 2531| 0| return suspend(cs.begin(), state::exp2, num); 2532| 0| } 2533| | // digit required 2534| 14| BOOST_STATIC_CONSTEXPR source_location loc 2535| 14| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 14|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2536| 14| return fail(cs.begin(), error::syntax, &loc); 2537| 14| } 2538| 3.24k| char const c = *cs; 2539| 3.24k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 6.47k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 25, False: 3.22k] | | | Branch (179:54): [True: 20, False: 3.22k] | | | Branch (179:54): [True: 5, False: 3.22k] | | ------------------ ------------------ 2540| 3.24k| c < '0' || c > '9')) 2541| 25| { 2542| | // digit required 2543| 25| BOOST_STATIC_CONSTEXPR source_location loc 2544| 25| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 25|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2545| 25| return fail(cs.begin(), error::syntax, &loc); 2546| 25| } 2547| 3.22k| ++cs; 2548| 3.22k| num.exp = c - '0'; 2549| 3.22k| } 2550| | 2551| | //---------------------------------- 2552| | // 2553| | // 1*DIGIT 2554| | // subsequent digits in the exponent 2555| | // 2556| 3.22k|do_exp3: 2557| 3.22k| for(;;) 2558| 8.48k| { 2559| 8.48k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 8.48k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 303, False: 8.17k] | | ------------------ ------------------ 2560| 303| { 2561| 303| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 303|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 303] | | ------------------ ------------------ 2562| 0| { 2563| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2564| 0| ! h_.on_number_part( 2565| 0| {begin, cs.used(begin)}, ec_))) 2566| 0| return fail(cs.begin()); 2567| 0| return suspend(cs.begin(), state::exp3, num); 2568| 0| } 2569| 303| } 2570| 8.17k| else 2571| 8.17k| { 2572| 8.17k| char const c = *cs; 2573| 8.17k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 13.4k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 5.26k, False: 2.91k] | | | Branch (171:52): [True: 5.27k, False: 2.90k] | | | Branch (171:52): [True: 5.26k, False: 8] | | ------------------ ------------------ 2574| 8.17k| c >= '0' && c <= '9')) 2575| 5.26k| { 2576| 5.26k| if(BOOST_JSON_UNLIKELY ------------------ | | 179| 15.9k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 5, False: 5.26k] | | | Branch (179:54): [True: 207, False: 5.05k] | | | Branch (179:54): [True: 1, False: 206] | | | Branch (179:54): [True: 4, False: 5.26k] | | ------------------ ------------------ 2577| | // 2147483647 INT_MAX 2578| 5.26k| (num.exp > 214748364 || ( 2579| 5.26k| num.exp == 214748364 && c > '7'))) 2580| 5| { 2581| 5| BOOST_STATIC_CONSTEXPR source_location loc 2582| 5| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 5|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2583| 5| return fail(cs.begin(), error::exponent_overflow, &loc); 2584| 5| } 2585| 5.26k| ++cs; 2586| 5.26k| num.exp = 10 * num.exp + ( c - '0' ); 2587| 5.26k| continue; 2588| 5.26k| } 2589| 8.17k| } 2590| 3.21k| BOOST_ASSERT(num.exp >= 0); ------------------ | | 60| 3.21k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2591| 3.21k| if ( num.frac ) ------------------ | Branch (2591:14): [True: 799, False: 2.41k] ------------------ 2592| 799| { 2593| 799| if (BOOST_JSON_UNLIKELY( num.bias < (INT_MIN + num.exp) )) ------------------ | | 179| 799|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 1, False: 798] | | ------------------ ------------------ 2594| 1| { 2595| 1| BOOST_STATIC_CONSTEXPR source_location loc 2596| 1| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 1|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2597| 1| return fail(cs.begin(), error::exponent_overflow, &loc); 2598| 1| } 2599| 799| } 2600| 2.41k| else 2601| 2.41k| { 2602| 2.41k| if (BOOST_JSON_UNLIKELY( num.bias > (INT_MAX - num.exp) )) ------------------ | | 179| 2.41k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 2.41k] | | ------------------ ------------------ 2603| 0| { 2604| 0| BOOST_STATIC_CONSTEXPR source_location loc 2605| 0| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2606| 0| return fail(cs.begin(), error::exponent_overflow, &loc); 2607| 0| } 2608| 2.41k| } 2609| 3.21k| goto finish_dub; 2610| 3.21k| } 2611| | 2612| 746|finish_int: 2613| 746| if(negative || (!stack_empty && num.neg)) ------------------ | Branch (2613:8): [Folded - Ignored] | Branch (2613:21): [Folded - Ignored] | Branch (2613:37): [True: 0, False: 0] ------------------ 2614| 0| { 2615| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2616| 0| ! h_.on_int64(static_cast< 2617| 0| int64_t>(~num.mant + 1), {begin, cs.used(begin)}, ec_))) 2618| 0| return fail(cs.begin()); 2619| 0| return cs.begin(); 2620| 0| } 2621| 746| if(num.mant <= INT64_MAX) ------------------ | Branch (2621:8): [True: 746, False: 0] ------------------ 2622| 746| { 2623| 29.8k|finish_signed: 2624| 29.8k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 29.8k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 29.8k] | | ------------------ ------------------ 2625| 29.8k| ! h_.on_int64(static_cast< 2626| 29.8k| int64_t>(num.mant), {begin, cs.used(begin)}, ec_))) 2627| 0| return fail(cs.begin()); 2628| 29.8k| return cs.begin(); 2629| 29.8k| } 2630| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2631| 0| ! h_.on_uint64(num.mant, {begin, cs.used(begin)}, ec_))) 2632| 0| return fail(cs.begin()); 2633| 0| return cs.begin(); 2634| 5.95k|finish_dub: 2635| 5.95k| double const d = detail::dec_to_float( 2636| 5.95k| num.mant, 2637| 5.95k| num.bias + (num.frac ? ------------------ | Branch (2637:21): [True: 798, False: 5.15k] ------------------ 2638| 5.15k| -num.exp : num.exp), 2639| 5.95k| num.neg); 2640| 5.95k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 5.95k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 5.95k] | | ------------------ ------------------ 2641| 5.95k| ! h_.on_double(d, {begin, cs.used(begin)}, ec_))) 2642| 0| return fail(cs.begin()); 2643| 5.95k| return cs.begin(); 2644| 5.95k|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE13maybe_suspendEPKcNS4_5stateERKNS4_6numberE: 343| 109|{ 344| 109| end_ = p; 345| 109| if(BOOST_JSON_LIKELY(more_)) ------------------ | | 171| 109|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 0, False: 109] | | ------------------ ------------------ 346| 0| { 347| | // suspend 348| 0| num_ = num; 349| 0| reserve(); 350| 0| st_.push_unchecked(st);; 351| 0| } 352| 109| return sentinel(); 353| 109|} _ZN5boost4json6detail12dec_to_floatEmib: 148| 30.3k|{ 149| | // convert to double explicitly to silence warnings 150| 30.3k| double x = static_cast(m); 151| 30.3k| if(neg) ------------------ | Branch (151:8): [True: 8.13k, False: 22.2k] ------------------ 152| 8.13k| x = -x; 153| | 154| 30.3k| if(e < -305) ------------------ | Branch (154:8): [True: 1.65k, False: 28.7k] ------------------ 155| 1.65k| { 156| 1.65k| x *= 1e-305 ; 157| 1.65k| e += 305; 158| 1.65k| } 159| | 160| 30.3k| if(e >= -22 && e < 0) ------------------ | Branch (160:8): [True: 28.0k, False: 2.32k] | Branch (160:20): [True: 12.2k, False: 15.7k] ------------------ 161| 12.2k| return x / pow10(-e); 162| | 163| 18.0k| return x * pow10(e); 164| 30.3k|} _ZN5boost4json6detail5pow10Ei: 52| 30.3k|{ 53| 30.3k| static double const tab[618] = { 54| 30.3k| 1e-308, 1e-307, 1e-306, 1e-305, 1e-304, 1e-303, 1e-302, 1e-301, 55| | 56| 30.3k| 1e-300, 1e-299, 1e-298, 1e-297, 1e-296, 1e-295, 1e-294, 1e-293, 1e-292, 1e-291, 57| 30.3k| 1e-290, 1e-289, 1e-288, 1e-287, 1e-286, 1e-285, 1e-284, 1e-283, 1e-282, 1e-281, 58| 30.3k| 1e-280, 1e-279, 1e-278, 1e-277, 1e-276, 1e-275, 1e-274, 1e-273, 1e-272, 1e-271, 59| 30.3k| 1e-270, 1e-269, 1e-268, 1e-267, 1e-266, 1e-265, 1e-264, 1e-263, 1e-262, 1e-261, 60| 30.3k| 1e-260, 1e-259, 1e-258, 1e-257, 1e-256, 1e-255, 1e-254, 1e-253, 1e-252, 1e-251, 61| 30.3k| 1e-250, 1e-249, 1e-248, 1e-247, 1e-246, 1e-245, 1e-244, 1e-243, 1e-242, 1e-241, 62| 30.3k| 1e-240, 1e-239, 1e-238, 1e-237, 1e-236, 1e-235, 1e-234, 1e-233, 1e-232, 1e-231, 63| 30.3k| 1e-230, 1e-229, 1e-228, 1e-227, 1e-226, 1e-225, 1e-224, 1e-223, 1e-222, 1e-221, 64| 30.3k| 1e-220, 1e-219, 1e-218, 1e-217, 1e-216, 1e-215, 1e-214, 1e-213, 1e-212, 1e-211, 65| 30.3k| 1e-210, 1e-209, 1e-208, 1e-207, 1e-206, 1e-205, 1e-204, 1e-203, 1e-202, 1e-201, 66| | 67| 30.3k| 1e-200, 1e-199, 1e-198, 1e-197, 1e-196, 1e-195, 1e-194, 1e-193, 1e-192, 1e-191, 68| 30.3k| 1e-190, 1e-189, 1e-188, 1e-187, 1e-186, 1e-185, 1e-184, 1e-183, 1e-182, 1e-181, 69| 30.3k| 1e-180, 1e-179, 1e-178, 1e-177, 1e-176, 1e-175, 1e-174, 1e-173, 1e-172, 1e-171, 70| 30.3k| 1e-170, 1e-169, 1e-168, 1e-167, 1e-166, 1e-165, 1e-164, 1e-163, 1e-162, 1e-161, 71| 30.3k| 1e-160, 1e-159, 1e-158, 1e-157, 1e-156, 1e-155, 1e-154, 1e-153, 1e-152, 1e-151, 72| 30.3k| 1e-150, 1e-149, 1e-148, 1e-147, 1e-146, 1e-145, 1e-144, 1e-143, 1e-142, 1e-141, 73| 30.3k| 1e-140, 1e-139, 1e-138, 1e-137, 1e-136, 1e-135, 1e-134, 1e-133, 1e-132, 1e-131, 74| 30.3k| 1e-130, 1e-129, 1e-128, 1e-127, 1e-126, 1e-125, 1e-124, 1e-123, 1e-122, 1e-121, 75| 30.3k| 1e-120, 1e-119, 1e-118, 1e-117, 1e-116, 1e-115, 1e-114, 1e-113, 1e-112, 1e-111, 76| 30.3k| 1e-110, 1e-109, 1e-108, 1e-107, 1e-106, 1e-105, 1e-104, 1e-103, 1e-102, 1e-101, 77| | 78| 30.3k| 1e-100, 1e-099, 1e-098, 1e-097, 1e-096, 1e-095, 1e-094, 1e-093, 1e-092, 1e-091, 79| 30.3k| 1e-090, 1e-089, 1e-088, 1e-087, 1e-086, 1e-085, 1e-084, 1e-083, 1e-082, 1e-081, 80| 30.3k| 1e-080, 1e-079, 1e-078, 1e-077, 1e-076, 1e-075, 1e-074, 1e-073, 1e-072, 1e-071, 81| 30.3k| 1e-070, 1e-069, 1e-068, 1e-067, 1e-066, 1e-065, 1e-064, 1e-063, 1e-062, 1e-061, 82| 30.3k| 1e-060, 1e-059, 1e-058, 1e-057, 1e-056, 1e-055, 1e-054, 1e-053, 1e-052, 1e-051, 83| 30.3k| 1e-050, 1e-049, 1e-048, 1e-047, 1e-046, 1e-045, 1e-044, 1e-043, 1e-042, 1e-041, 84| 30.3k| 1e-040, 1e-039, 1e-038, 1e-037, 1e-036, 1e-035, 1e-034, 1e-033, 1e-032, 1e-031, 85| 30.3k| 1e-030, 1e-029, 1e-028, 1e-027, 1e-026, 1e-025, 1e-024, 1e-023, 1e-022, 1e-021, 86| 30.3k| 1e-020, 1e-019, 1e-018, 1e-017, 1e-016, 1e-015, 1e-014, 1e-013, 1e-012, 1e-011, 87| 30.3k| 1e-010, 1e-009, 1e-008, 1e-007, 1e-006, 1e-005, 1e-004, 1e-003, 1e-002, 1e-001, 88| | 89| 30.3k| 1e+000, 1e+001, 1e+002, 1e+003, 1e+004, 1e+005, 1e+006, 1e+007, 1e+008, 1e+009, 90| 30.3k| 1e+010, 1e+011, 1e+012, 1e+013, 1e+014, 1e+015, 1e+016, 1e+017, 1e+018, 1e+019, 91| 30.3k| 1e+020, 1e+021, 1e+022, 1e+023, 1e+024, 1e+025, 1e+026, 1e+027, 1e+028, 1e+029, 92| 30.3k| 1e+030, 1e+031, 1e+032, 1e+033, 1e+034, 1e+035, 1e+036, 1e+037, 1e+038, 1e+039, 93| 30.3k| 1e+040, 1e+041, 1e+042, 1e+043, 1e+044, 1e+045, 1e+046, 1e+047, 1e+048, 1e+049, 94| 30.3k| 1e+050, 1e+051, 1e+052, 1e+053, 1e+054, 1e+055, 1e+056, 1e+057, 1e+058, 1e+059, 95| 30.3k| 1e+060, 1e+061, 1e+062, 1e+063, 1e+064, 1e+065, 1e+066, 1e+067, 1e+068, 1e+069, 96| 30.3k| 1e+070, 1e+071, 1e+072, 1e+073, 1e+074, 1e+075, 1e+076, 1e+077, 1e+078, 1e+079, 97| 30.3k| 1e+080, 1e+081, 1e+082, 1e+083, 1e+084, 1e+085, 1e+086, 1e+087, 1e+088, 1e+089, 98| 30.3k| 1e+090, 1e+091, 1e+092, 1e+093, 1e+094, 1e+095, 1e+096, 1e+097, 1e+098, 1e+099, 99| | 100| 30.3k| 1e+100, 1e+101, 1e+102, 1e+103, 1e+104, 1e+105, 1e+106, 1e+107, 1e+108, 1e+109, 101| 30.3k| 1e+110, 1e+111, 1e+112, 1e+113, 1e+114, 1e+115, 1e+116, 1e+117, 1e+118, 1e+119, 102| 30.3k| 1e+120, 1e+121, 1e+122, 1e+123, 1e+124, 1e+125, 1e+126, 1e+127, 1e+128, 1e+129, 103| 30.3k| 1e+130, 1e+131, 1e+132, 1e+133, 1e+134, 1e+135, 1e+136, 1e+137, 1e+138, 1e+139, 104| 30.3k| 1e+140, 1e+141, 1e+142, 1e+143, 1e+144, 1e+145, 1e+146, 1e+147, 1e+148, 1e+149, 105| 30.3k| 1e+150, 1e+151, 1e+152, 1e+153, 1e+154, 1e+155, 1e+156, 1e+157, 1e+158, 1e+159, 106| 30.3k| 1e+160, 1e+161, 1e+162, 1e+163, 1e+164, 1e+165, 1e+166, 1e+167, 1e+168, 1e+169, 107| 30.3k| 1e+170, 1e+171, 1e+172, 1e+173, 1e+174, 1e+175, 1e+176, 1e+177, 1e+178, 1e+179, 108| 30.3k| 1e+180, 1e+181, 1e+182, 1e+183, 1e+184, 1e+185, 1e+186, 1e+187, 1e+188, 1e+189, 109| 30.3k| 1e+190, 1e+191, 1e+192, 1e+193, 1e+194, 1e+195, 1e+196, 1e+197, 1e+198, 1e+199, 110| | 111| 30.3k| 1e+200, 1e+201, 1e+202, 1e+203, 1e+204, 1e+205, 1e+206, 1e+207, 1e+208, 1e+209, 112| 30.3k| 1e+210, 1e+211, 1e+212, 1e+213, 1e+214, 1e+215, 1e+216, 1e+217, 1e+218, 1e+219, 113| 30.3k| 1e+220, 1e+221, 1e+222, 1e+223, 1e+224, 1e+225, 1e+226, 1e+227, 1e+228, 1e+229, 114| 30.3k| 1e+230, 1e+231, 1e+232, 1e+233, 1e+234, 1e+235, 1e+236, 1e+237, 1e+238, 1e+239, 115| 30.3k| 1e+240, 1e+241, 1e+242, 1e+243, 1e+244, 1e+245, 1e+246, 1e+247, 1e+248, 1e+249, 116| 30.3k| 1e+250, 1e+251, 1e+252, 1e+253, 1e+254, 1e+255, 1e+256, 1e+257, 1e+258, 1e+259, 117| 30.3k| 1e+260, 1e+261, 1e+262, 1e+263, 1e+264, 1e+265, 1e+266, 1e+267, 1e+268, 1e+269, 118| 30.3k| 1e+270, 1e+271, 1e+272, 1e+273, 1e+274, 1e+275, 1e+276, 1e+277, 1e+278, 1e+279, 119| 30.3k| 1e+280, 1e+281, 1e+282, 1e+283, 1e+284, 1e+285, 1e+286, 1e+287, 1e+288, 1e+289, 120| 30.3k| 1e+290, 1e+291, 1e+292, 1e+293, 1e+294, 1e+295, 1e+296, 1e+297, 1e+298, 1e+299, 121| | 122| 30.3k| 1e+300, 1e+301, 1e+302, 1e+303, 1e+304, 1e+305, 1e+306, 1e+307, 1e+308 }; 123| | 124| 30.3k| if( exp > 308 ) ------------------ | Branch (124:9): [True: 1.99k, False: 28.3k] ------------------ 125| 1.99k| { 126| 1.99k| return std::numeric_limits::infinity(); 127| 1.99k| } 128| 28.3k| else if( exp < -308 ) ------------------ | Branch (128:14): [True: 1.21k, False: 27.1k] ------------------ 129| 1.21k| { 130| | // due to the way pow10 is used by dec_to_float, 131| | // we can afford to return 0.0 here 132| 1.21k| return 0.0; 133| 1.21k| } 134| 27.1k| else 135| 27.1k| { 136| 27.1k| exp += 308; 137| 27.1k| BOOST_ASSERT(exp >= 0 && exp < 618); ------------------ | | 60| 27.1k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 138| 27.1k| return tab[exp]; 139| 27.1k| } 140| 30.3k|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE12parse_numberILb1ELc45EEEPKcS7_NSt3__117integral_constantIbXT_EEENS9_IcXT0_EEE: 1991| 12.2k|{ 1992| | // only one of these will be true if we are not resuming 1993| | // if negative then !zero_first && !nonzero_first 1994| | // if zero_first then !nonzero_first && !negative 1995| | // if nonzero_first then !zero_first && !negative 1996| 12.2k| bool const negative = first == '-'; 1997| 12.2k| bool const zero_first = first == '0'; 1998| 12.2k| bool const nonzero_first = first == '+'; 1999| 12.2k| detail::const_stream_wrapper cs(p, end_); 2000| 12.2k| number num; 2001| 12.2k| const char* begin = cs.begin(); 2002| 12.2k| if(stack_empty || st_.empty()) ------------------ | Branch (2002:8): [Folded - Ignored] | Branch (2002:23): [True: 0, False: 0] ------------------ 2003| 12.2k| { 2004| 12.2k| num.bias = 0; 2005| 12.2k| num.exp = 0; 2006| 12.2k| num.frac = false; 2007| | 2008| | //---------------------------------- 2009| | // 2010| | // '-' 2011| | // leading minus sign 2012| | // 2013| 12.2k| BOOST_ASSERT(cs); ------------------ | | 60| 12.2k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2014| 12.2k| if(negative) ------------------ | Branch (2014:12): [Folded - Ignored] ------------------ 2015| 12.2k| ++cs; 2016| | 2017| 12.2k| num.neg = negative; 2018| 12.2k| num.frac = false; 2019| 12.2k| num.exp = 0; 2020| 12.2k| num.bias = 0; 2021| | 2022| | // fast path 2023| 12.2k| if( cs.remain() >= 16 + 1 + 16 ) // digits . digits ------------------ | Branch (2023:13): [True: 10.9k, False: 1.37k] ------------------ 2024| 10.9k| { 2025| 10.9k| int n1; 2026| | 2027| 10.9k| if( nonzero_first || ------------------ | Branch (2027:17): [Folded - Ignored] ------------------ 2028| 10.9k| (negative && *cs != '0') ) ------------------ | Branch (2028:18): [Folded - Ignored] | Branch (2028:30): [True: 8.70k, False: 2.21k] ------------------ 2029| 8.70k| { 2030| 8.70k| n1 = detail::count_digits( cs.begin() ); 2031| 8.70k| BOOST_ASSERT(n1 >= 0 && n1 <= 16); ------------------ | | 60| 8.70k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2032| | 2033| 8.70k| if( ! nonzero_first && n1 == 0 ) ------------------ | Branch (2033:21): [Folded - Ignored] | Branch (2033:40): [True: 7, False: 8.70k] ------------------ 2034| 7| { 2035| | // digit required 2036| 7| BOOST_STATIC_CONSTEXPR source_location loc 2037| 7| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 7|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2038| 7| return fail(cs.begin(), error::syntax, &loc); 2039| 7| } 2040| | 2041| 8.70k| num.mant = detail::parse_unsigned( 0, cs.begin(), n1 ); 2042| | 2043| 8.70k| cs += n1; 2044| | 2045| | // integer or floating-point with 2046| | // >= 16 leading digits 2047| 8.70k| if( n1 == 16 ) ------------------ | Branch (2047:21): [True: 3.26k, False: 5.43k] ------------------ 2048| 3.26k| { 2049| 3.26k| goto do_num2; 2050| 3.26k| } 2051| 8.70k| } 2052| 2.21k| else 2053| 2.21k| { 2054| | // 0. floating-point or 0e integer 2055| 2.21k| num.mant = 0; 2056| 2.21k| n1 = 0; 2057| 2.21k| ++cs; 2058| 2.21k| } 2059| | 2060| 7.64k| { 2061| 7.64k| const char c = *cs; 2062| 7.64k| if(c != '.') ------------------ | Branch (2062:20): [True: 4.81k, False: 2.83k] ------------------ 2063| 4.81k| { 2064| 4.81k| if((c | 32) == 'e') ------------------ | Branch (2064:24): [True: 1.98k, False: 2.83k] ------------------ 2065| 1.98k| { 2066| 1.98k| ++cs; 2067| 1.98k| goto do_exp1; 2068| 1.98k| } 2069| 2.83k| if(negative) ------------------ | Branch (2069:24): [Folded - Ignored] ------------------ 2070| 2.83k| num.mant = ~num.mant + 1; 2071| 2.83k| goto finish_signed; 2072| 4.81k| } 2073| 7.64k| } 2074| | 2075| | // floating-point number 2076| | 2077| 2.83k| ++cs; 2078| | 2079| 2.83k| int n2 = detail::count_digits( cs.begin() ); 2080| 2.83k| BOOST_ASSERT(n2 >= 0 && n2 <= 16); ------------------ | | 60| 2.83k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2081| | 2082| 2.83k| if( n2 == 0 ) ------------------ | Branch (2082:17): [True: 5, False: 2.82k] ------------------ 2083| 5| { 2084| | // digit required 2085| 5| BOOST_STATIC_CONSTEXPR source_location loc 2086| 5| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 5|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2087| 5| return fail(cs.begin(), error::syntax, &loc); 2088| 5| } 2089| | 2090| | // floating-point mantissa overflow 2091| 2.82k| if( n1 + n2 >= 19 ) ------------------ | Branch (2091:17): [True: 206, False: 2.62k] ------------------ 2092| 206| { 2093| 206| goto do_num7; 2094| 206| } 2095| | 2096| 2.62k| num.mant = detail::parse_unsigned( num.mant, cs.begin(), n2 ); 2097| | 2098| 2.62k| BOOST_ASSERT(num.bias == 0); ------------------ | | 60| 2.62k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2099| | 2100| 2.62k| num.bias -= n2; 2101| | 2102| 2.62k| cs += n2; 2103| | 2104| 2.62k| char ch = *cs; 2105| | 2106| 2.62k| if( (ch | 32) == 'e' ) ------------------ | Branch (2106:17): [True: 210, False: 2.41k] ------------------ 2107| 210| { 2108| 210| ++cs; 2109| 210| goto do_exp1; 2110| 210| } 2111| 2.41k| else if( ch >= '0' && ch <= '9' ) ------------------ | Branch (2111:22): [True: 548, False: 1.86k] | Branch (2111:35): [True: 343, False: 205] ------------------ 2112| 343| { 2113| 343| goto do_num8; 2114| 343| } 2115| | 2116| 2.06k| goto finish_dub; 2117| 2.62k| } 2118| 12.2k| } 2119| 0| else 2120| 0| { 2121| 0| num = num_; 2122| 0| state st; 2123| 0| st_.pop(st); 2124| 0| switch(st) 2125| 0| { 2126| 0| default: BOOST_JSON_UNREACHABLE(); ------------------ | | 189| 0|# define BOOST_JSON_UNREACHABLE() __builtin_unreachable() ------------------ | Branch (2126:9): [True: 0, False: 0] ------------------ 2127| 0| case state::num1: goto do_num1; ------------------ | Branch (2127:9): [True: 0, False: 0] ------------------ 2128| 0| case state::num2: goto do_num2; ------------------ | Branch (2128:9): [True: 0, False: 0] ------------------ 2129| 0| case state::num3: goto do_num3; ------------------ | Branch (2129:9): [True: 0, False: 0] ------------------ 2130| 0| case state::num4: goto do_num4; ------------------ | Branch (2130:9): [True: 0, False: 0] ------------------ 2131| 0| case state::num5: goto do_num5; ------------------ | Branch (2131:9): [True: 0, False: 0] ------------------ 2132| 0| case state::num6: goto do_num6; ------------------ | Branch (2132:9): [True: 0, False: 0] ------------------ 2133| 0| case state::num7: goto do_num7; ------------------ | Branch (2133:9): [True: 0, False: 0] ------------------ 2134| 0| case state::num8: goto do_num8; ------------------ | Branch (2134:9): [True: 0, False: 0] ------------------ 2135| 0| case state::exp1: goto do_exp1; ------------------ | Branch (2135:9): [True: 0, False: 0] ------------------ 2136| 0| case state::exp2: goto do_exp2; ------------------ | Branch (2136:9): [True: 0, False: 0] ------------------ 2137| 0| case state::exp3: goto do_exp3; ------------------ | Branch (2137:9): [True: 0, False: 0] ------------------ 2138| 0| } 2139| 0| } 2140| | 2141| | //---------------------------------- 2142| | // 2143| | // DIGIT 2144| | // first digit 2145| | // 2146| 1.37k|do_num1: 2147| 1.37k| if(zero_first || nonzero_first || ------------------ | Branch (2147:8): [Folded - Ignored] | Branch (2147:22): [Folded - Ignored] ------------------ 2148| 1.37k| BOOST_JSON_LIKELY(cs)) ------------------ | | 171| 1.37k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 1.35k, False: 14] | | ------------------ ------------------ 2149| 1.35k| { 2150| 1.35k| char const c = *cs; 2151| 1.35k| if(zero_first) ------------------ | Branch (2151:12): [Folded - Ignored] ------------------ 2152| 0| { 2153| 0| ++cs; 2154| 0| num.mant = 0; 2155| 0| goto do_num6; 2156| 0| } 2157| 1.35k| else if(nonzero_first || BOOST_JSON_LIKELY( ------------------ | | 171| 2.44k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 1.07k, False: 280] | | | Branch (171:52): [True: 1.08k, False: 268] | | | Branch (171:52): [True: 1.07k, False: 12] | | ------------------ ------------------ | Branch (2157:17): [Folded - Ignored] ------------------ 2158| 1.35k| c >= '1' && c <= '9')) 2159| 1.07k| { 2160| 1.07k| ++cs; 2161| 1.07k| num.mant = c - '0'; 2162| 1.07k| } 2163| 280| else if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 280|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 252, False: 28] | | ------------------ ------------------ 2164| 280| c == '0')) 2165| 252| { 2166| 252| ++cs; 2167| 252| num.mant = 0; 2168| 252| goto do_num6; 2169| 252| } 2170| 28| else 2171| 28| { 2172| 28| BOOST_STATIC_CONSTEXPR source_location loc 2173| 28| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 28|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2174| 28| return fail(cs.begin(), error::syntax, &loc); 2175| 28| } 2176| 1.35k| } 2177| 14| else 2178| 14| { 2179| 14| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 14|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 14] | | ------------------ ------------------ 2180| 14| ! h_.on_number_part( 2181| 14| {begin, cs.used(begin)}, ec_))) 2182| 0| return fail(cs.begin()); 2183| 14| return maybe_suspend( 2184| 14| cs.begin(), state::num1, num); 2185| 14| } 2186| | 2187| | //---------------------------------- 2188| | // 2189| | // 1*DIGIT 2190| | // significant digits left of decimal 2191| | // 2192| 4.34k|do_num2: 2193| 4.34k| if(negative || (!stack_empty && num.neg)) ------------------ | Branch (2193:8): [Folded - Ignored] | Branch (2193:21): [Folded - Ignored] | Branch (2193:37): [True: 0, False: 0] ------------------ 2194| 4.34k| { 2195| 4.34k| for(;;) 2196| 12.9k| { 2197| 12.9k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 12.9k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 147, False: 12.7k] | | ------------------ ------------------ 2198| 147| { 2199| 147| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 147|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 147] | | ------------------ ------------------ 2200| 0| { 2201| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2202| 0| ! h_.on_number_part( 2203| 0| {begin, cs.used(begin)}, ec_))) 2204| 0| return fail(cs.begin()); 2205| 0| return suspend(cs.begin(), state::num2, num); 2206| 0| } 2207| 147| goto finish_int; 2208| 147| } 2209| 12.7k| char const c = *cs; 2210| 12.7k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 23.4k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 10.0k, False: 2.76k] | | | Branch (171:52): [True: 10.6k, False: 2.14k] | | | Branch (171:52): [True: 10.0k, False: 618] | | ------------------ ------------------ 2211| 12.7k| c >= '0' && c <= '9')) 2212| 10.0k| { 2213| 10.0k| ++cs; 2214| | // 9223372036854775808 INT64_MIN 2215| 10.0k| if( num.mant > 922337203685477580 || ( ------------------ | Branch (2215:21): [True: 1.12k, False: 8.89k] ------------------ 2216| 8.89k| num.mant == 922337203685477580 && c > '8')) ------------------ | Branch (2216:21): [True: 513, False: 8.38k] | Branch (2216:55): [True: 309, False: 204] ------------------ 2217| 1.43k| break; 2218| 8.58k| num.mant = 10 * num.mant + ( c - '0' ); 2219| 8.58k| continue; 2220| 10.0k| } 2221| 2.76k| goto do_num6; // [.eE] 2222| 12.7k| } 2223| 4.34k| } 2224| 0| else 2225| 0| { 2226| 0| for(;;) 2227| 0| { 2228| 0| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2229| 0| { 2230| 0| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2231| 0| { 2232| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2233| 0| ! h_.on_number_part( 2234| 0| {begin, cs.used(begin)}, ec_))) 2235| 0| return fail(cs.begin()); 2236| 0| return suspend(cs.begin(), state::num2, num); 2237| 0| } 2238| 0| goto finish_int; 2239| 0| } 2240| 0| char const c = *cs; 2241| 0| if(BOOST_JSON_LIKELY( ------------------ | | 171| 0|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 0, False: 0] | | | Branch (171:52): [True: 0, False: 0] | | | Branch (171:52): [True: 0, False: 0] | | ------------------ ------------------ 2242| 0| c >= '0' && c <= '9')) 2243| 0| { 2244| 0| ++cs; 2245| | // 18446744073709551615 UINT64_MAX 2246| 0| if( num.mant > 1844674407370955161 || ( ------------------ | Branch (2246:21): [True: 0, False: 0] ------------------ 2247| 0| num.mant == 1844674407370955161 && c > '5')) ------------------ | Branch (2247:21): [True: 0, False: 0] | Branch (2247:56): [True: 0, False: 0] ------------------ 2248| 0| break; 2249| 0| num.mant = 10 * num.mant + ( c - '0' ); 2250| 0| } 2251| 0| else 2252| 0| { 2253| 0| goto do_num6; // [.eE] 2254| 0| } 2255| 0| } 2256| 0| } 2257| 1.43k| ++num.bias; 2258| | 2259| | //---------------------------------- 2260| | // 2261| | // 1*DIGIT 2262| | // non-significant digits left of decimal 2263| | // 2264| 1.43k|do_num3: 2265| 1.43k| for(;;) 2266| 1.05M| { 2267| 1.05M| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 1.05M|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 27, False: 1.05M] | | ------------------ ------------------ 2268| 27| { 2269| 27| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 27|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 27] | | ------------------ ------------------ 2270| 0| { 2271| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2272| 0| ! h_.on_number_part( 2273| 0| {begin, cs.used(begin)}, ec_))) 2274| 0| return fail(cs.begin()); 2275| 0| return suspend(cs.begin(), state::num3, num); 2276| 0| } 2277| 27| goto finish_dub; 2278| 27| } 2279| 1.05M| char const c = *cs; 2280| 1.05M| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 2.10M|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 1.05M, False: 1.40k] | | | Branch (179:54): [True: 1.05M, False: 1.18k] | | | Branch (179:54): [True: 1.05M, False: 226] | | ------------------ ------------------ 2281| 1.05M| c >= '0' && c <= '9')) 2282| 1.05M| { 2283| 1.05M| ++cs; 2284| | // VFALCO check overflow 2285| 1.05M| ++num.bias; 2286| 1.05M| } 2287| 1.40k| else if(BOOST_JSON_LIKELY( ------------------ | | 171| 1.40k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 237, False: 1.16k] | | ------------------ ------------------ 2288| 1.40k| c == '.')) 2289| 237| { 2290| 237| ++cs; 2291| 237| break; 2292| 237| } 2293| 1.16k| else if((c | 32) == 'e') ------------------ | Branch (2293:17): [True: 220, False: 949] ------------------ 2294| 220| { 2295| 220| ++cs; 2296| 220| goto do_exp1; 2297| 220| } 2298| 949| else 2299| 949| { 2300| 949| goto finish_dub; 2301| 949| } 2302| 1.05M| } 2303| | 2304| | //---------------------------------- 2305| | // 2306| | // DIGIT 2307| | // first non-significant digit 2308| | // to the right of decimal 2309| | // 2310| 237|do_num4: 2311| 237| { 2312| 237| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 237|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 4, False: 233] | | ------------------ ------------------ 2313| 4| { 2314| 4| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 4|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 4] | | ------------------ ------------------ 2315| 4| ! h_.on_number_part( 2316| 4| {begin, cs.used(begin)}, ec_))) 2317| 0| return fail(cs.begin()); 2318| 4| return maybe_suspend( 2319| 4| cs.begin(), state::num4, num); 2320| 4| } 2321| 233| char const c = *cs; 2322| 233| if(BOOST_JSON_LIKELY( ------------------ | | 171| 459|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 220, False: 13] | | | Branch (171:52): [True: 226, False: 7] | | | Branch (171:52): [True: 220, False: 6] | | ------------------ ------------------ 2323| | //static_cast(c - '0') < 10)) 2324| 233| c >= '0' && c <= '9')) 2325| 220| { 2326| 220| ++cs; 2327| 220| } 2328| 13| else 2329| 13| { 2330| | // digit required 2331| 13| BOOST_STATIC_CONSTEXPR source_location loc 2332| 13| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 13|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2333| 13| return fail(cs.begin(), error::syntax, &loc); 2334| 13| } 2335| 233| } 2336| | 2337| | //---------------------------------- 2338| | // 2339| | // 1*DIGIT 2340| | // non-significant digits 2341| | // to the right of decimal 2342| | // 2343| 1.12k|do_num5: 2344| 1.12k| for(;;) 2345| 2.68k| { 2346| 2.68k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 2.68k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 35, False: 2.64k] | | ------------------ ------------------ 2347| 35| { 2348| 35| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 35|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 35] | | ------------------ ------------------ 2349| 0| { 2350| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2351| 0| ! h_.on_number_part( 2352| 0| {begin, cs.used(begin)}, ec_))) 2353| 0| return fail(cs.begin()); 2354| 0| return suspend(cs.begin(), state::num5, num); 2355| 0| } 2356| 35| goto finish_dub; 2357| 35| } 2358| 2.64k| char const c = *cs; 2359| 2.64k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 4.44k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 1.55k, False: 1.09k] | | | Branch (171:52): [True: 1.79k, False: 852] | | | Branch (171:52): [True: 1.55k, False: 241] | | ------------------ ------------------ 2360| 2.64k| c >= '0' && c <= '9')) 2361| 1.55k| { 2362| 1.55k| ++cs; 2363| 1.55k| } 2364| 1.09k| else if((c | 32) == 'e') ------------------ | Branch (2364:17): [True: 236, False: 857] ------------------ 2365| 236| { 2366| 236| ++cs; 2367| 236| goto do_exp1; 2368| 236| } 2369| 857| else 2370| 857| { 2371| 857| goto finish_dub; 2372| 857| } 2373| 2.64k| } 2374| | 2375| | //---------------------------------- 2376| | // 2377| | // [.eE] 2378| | // 2379| 3.01k|do_num6: 2380| 3.01k| { 2381| 3.01k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 3.01k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 5, False: 3.01k] | | ------------------ ------------------ 2382| 5| { 2383| 5| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 5|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 5] | | ------------------ ------------------ 2384| 0| { 2385| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2386| 0| ! h_.on_number_part( 2387| 0| {begin, cs.used(begin)}, ec_))) 2388| 0| return fail(cs.begin()); 2389| 0| return suspend(cs.begin(), state::num6, num); 2390| 0| } 2391| 5| goto finish_int; 2392| 5| } 2393| 3.01k| char const c = *cs; 2394| 3.01k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 3.01k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 1.33k, False: 1.67k] | | ------------------ ------------------ 2395| 3.01k| c == '.')) 2396| 1.33k| { 2397| 1.33k| ++cs; 2398| 1.33k| } 2399| 1.67k| else if((c | 32) == 'e') ------------------ | Branch (2399:17): [True: 702, False: 974] ------------------ 2400| 702| { 2401| 702| ++cs; 2402| 702| goto do_exp1; 2403| 702| } 2404| 974| else 2405| 974| { 2406| 974| goto finish_int; 2407| 974| } 2408| 3.01k| } 2409| | 2410| | //---------------------------------- 2411| | // 2412| | // DIGIT 2413| | // first significant digit 2414| | // to the right of decimal 2415| | // 2416| 1.54k|do_num7: 2417| 1.54k| { 2418| 1.54k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 1.54k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 6, False: 1.53k] | | ------------------ ------------------ 2419| 6| { 2420| 6| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 6|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 6] | | ------------------ ------------------ 2421| 0| { 2422| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2423| 0| ! h_.on_number_part( 2424| 0| {begin, cs.used(begin)}, ec_))) 2425| 0| return fail(cs.begin()); 2426| 0| return suspend(cs.begin(), state::num7, num); 2427| 0| } 2428| | // digit required 2429| 6| BOOST_STATIC_CONSTEXPR source_location loc 2430| 6| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 6|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2431| 6| return fail(cs.begin(), error::syntax, &loc); 2432| 6| } 2433| 1.53k| char const c = *cs; 2434| 1.53k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 3.06k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 18, False: 1.51k] | | | Branch (179:54): [True: 13, False: 1.52k] | | | Branch (179:54): [True: 5, False: 1.51k] | | ------------------ ------------------ 2435| 1.53k| c < '0' || c > '9')) 2436| 18| { 2437| | // digit required 2438| 18| BOOST_STATIC_CONSTEXPR source_location loc 2439| 18| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 18|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2440| 18| return fail(cs.begin(), error::syntax, &loc); 2441| 18| } 2442| 1.53k| } 2443| | 2444| | //---------------------------------- 2445| | // 2446| | // 1*DIGIT 2447| | // significant digits 2448| | // to the right of decimal 2449| | // 2450| 1.86k|do_num8: 2451| 1.86k| for(;;) 2452| 5.71k| { 2453| 5.71k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 5.71k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 118, False: 5.60k] | | ------------------ ------------------ 2454| 118| { 2455| 118| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 118|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 118] | | ------------------ ------------------ 2456| 0| { 2457| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2458| 0| ! h_.on_number_part( 2459| 0| {begin, cs.used(begin)}, ec_))) 2460| 0| return fail(cs.begin()); 2461| 0| return suspend(cs.begin(), state::num8, num); 2462| 0| } 2463| 118| goto finish_dub; 2464| 118| } 2465| 5.60k| char const c = *cs; 2466| 5.60k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 10.6k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 4.76k, False: 836] | | | Branch (171:52): [True: 5.07k, False: 528] | | | Branch (171:52): [True: 4.76k, False: 308] | | ------------------ ------------------ 2467| 5.60k| c >= '0' && c <= '9')) 2468| 4.76k| { 2469| 4.76k| ++cs; 2470| 4.76k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 4.76k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 3.85k, False: 908] | | ------------------ ------------------ 2471| 4.76k| num.mant <= 9007199254740991)) // 2^53-1 2472| 3.85k| { 2473| 3.85k| --num.bias; 2474| 3.85k| num.mant = 10 * num.mant + ( c - '0' ); 2475| 3.85k| } 2476| 908| else 2477| 908| { 2478| 908| goto do_num5; 2479| 908| } 2480| 4.76k| } 2481| 836| else if((c | 32) == 'e') ------------------ | Branch (2481:17): [True: 298, False: 538] ------------------ 2482| 298| { 2483| 298| ++cs; 2484| 298| goto do_exp1; 2485| 298| } 2486| 538| else 2487| 538| { 2488| 538| goto finish_dub; 2489| 538| } 2490| 5.60k| } 2491| | 2492| | //---------------------------------- 2493| | // 2494| | // *[+-] 2495| | // 2496| 3.64k|do_exp1: 2497| 3.64k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 3.64k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 33, False: 3.61k] | | ------------------ ------------------ 2498| 33| { 2499| 33| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 33|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 33] | | ------------------ ------------------ 2500| 33| ! h_.on_number_part( 2501| 33| {begin, cs.used(begin)}, ec_))) 2502| 0| return fail(cs.begin()); 2503| 33| return maybe_suspend( 2504| 33| cs.begin(), state::exp1, num); 2505| 33| } 2506| 3.61k| if(*cs == '+') ------------------ | Branch (2506:8): [True: 195, False: 3.41k] ------------------ 2507| 195| { 2508| 195| ++cs; 2509| 195| } 2510| 3.41k| else if(*cs == '-') ------------------ | Branch (2510:13): [True: 913, False: 2.50k] ------------------ 2511| 913| { 2512| 913| ++cs; 2513| 913| num.frac = true; 2514| 913| } 2515| | 2516| | //---------------------------------- 2517| | // 2518| | // DIGIT 2519| | // first digit of the exponent 2520| | // 2521| 3.61k|do_exp2: 2522| 3.61k| { 2523| 3.61k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 3.61k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 14, False: 3.60k] | | ------------------ ------------------ 2524| 14| { 2525| 14| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 14|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 14] | | ------------------ ------------------ 2526| 0| { 2527| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2528| 0| ! h_.on_number_part( 2529| 0| {begin, cs.used(begin)}, ec_))) 2530| 0| return fail(cs.begin()); 2531| 0| return suspend(cs.begin(), state::exp2, num); 2532| 0| } 2533| | // digit required 2534| 14| BOOST_STATIC_CONSTEXPR source_location loc 2535| 14| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 14|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2536| 14| return fail(cs.begin(), error::syntax, &loc); 2537| 14| } 2538| 3.60k| char const c = *cs; 2539| 3.60k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 7.17k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 29, False: 3.57k] | | | Branch (179:54): [True: 21, False: 3.57k] | | | Branch (179:54): [True: 8, False: 3.57k] | | ------------------ ------------------ 2540| 3.60k| c < '0' || c > '9')) 2541| 29| { 2542| | // digit required 2543| 29| BOOST_STATIC_CONSTEXPR source_location loc 2544| 29| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 29|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2545| 29| return fail(cs.begin(), error::syntax, &loc); 2546| 29| } 2547| 3.57k| ++cs; 2548| 3.57k| num.exp = c - '0'; 2549| 3.57k| } 2550| | 2551| | //---------------------------------- 2552| | // 2553| | // 1*DIGIT 2554| | // subsequent digits in the exponent 2555| | // 2556| 3.57k|do_exp3: 2557| 3.57k| for(;;) 2558| 8.69k| { 2559| 8.69k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 8.69k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 304, False: 8.38k] | | ------------------ ------------------ 2560| 304| { 2561| 304| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 304|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 304] | | ------------------ ------------------ 2562| 0| { 2563| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2564| 0| ! h_.on_number_part( 2565| 0| {begin, cs.used(begin)}, ec_))) 2566| 0| return fail(cs.begin()); 2567| 0| return suspend(cs.begin(), state::exp3, num); 2568| 0| } 2569| 304| } 2570| 8.38k| else 2571| 8.38k| { 2572| 8.38k| char const c = *cs; 2573| 8.38k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 13.5k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 5.12k, False: 3.25k] | | | Branch (171:52): [True: 5.13k, False: 3.25k] | | | Branch (171:52): [True: 5.12k, False: 9] | | ------------------ ------------------ 2574| 8.38k| c >= '0' && c <= '9')) 2575| 5.12k| { 2576| 5.12k| if(BOOST_JSON_UNLIKELY ------------------ | | 179| 15.5k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 8, False: 5.11k] | | | Branch (179:54): [True: 222, False: 4.90k] | | | Branch (179:54): [True: 4, False: 218] | | | Branch (179:54): [True: 4, False: 5.12k] | | ------------------ ------------------ 2577| | // 2147483647 INT_MAX 2578| 5.12k| (num.exp > 214748364 || ( 2579| 5.12k| num.exp == 214748364 && c > '7'))) 2580| 8| { 2581| 8| BOOST_STATIC_CONSTEXPR source_location loc 2582| 8| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 8|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2583| 8| return fail(cs.begin(), error::exponent_overflow, &loc); 2584| 8| } 2585| 5.11k| ++cs; 2586| 5.11k| num.exp = 10 * num.exp + ( c - '0' ); 2587| 5.11k| continue; 2588| 5.12k| } 2589| 8.38k| } 2590| 3.56k| BOOST_ASSERT(num.exp >= 0); ------------------ | | 60| 3.56k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2591| 3.56k| if ( num.frac ) ------------------ | Branch (2591:14): [True: 907, False: 2.65k] ------------------ 2592| 907| { 2593| 907| if (BOOST_JSON_UNLIKELY( num.bias < (INT_MIN + num.exp) )) ------------------ | | 179| 907|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 1, False: 906] | | ------------------ ------------------ 2594| 1| { 2595| 1| BOOST_STATIC_CONSTEXPR source_location loc 2596| 1| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 1|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2597| 1| return fail(cs.begin(), error::exponent_overflow, &loc); 2598| 1| } 2599| 907| } 2600| 2.65k| else 2601| 2.65k| { 2602| 2.65k| if (BOOST_JSON_UNLIKELY( num.bias > (INT_MAX - num.exp) )) ------------------ | | 179| 2.65k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 20, False: 2.63k] | | ------------------ ------------------ 2603| 20| { 2604| 20| BOOST_STATIC_CONSTEXPR source_location loc 2605| 20| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 20|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2606| 20| return fail(cs.begin(), error::exponent_overflow, &loc); 2607| 20| } 2608| 2.65k| } 2609| 3.54k| goto finish_dub; 2610| 3.56k| } 2611| | 2612| 1.12k|finish_int: 2613| 1.12k| if(negative || (!stack_empty && num.neg)) ------------------ | Branch (2613:8): [Folded - Ignored] | Branch (2613:21): [Folded - Ignored] | Branch (2613:37): [True: 0, False: 0] ------------------ 2614| 1.12k| { 2615| 1.12k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 1.12k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 1.12k] | | ------------------ ------------------ 2616| 1.12k| ! h_.on_int64(static_cast< 2617| 1.12k| int64_t>(~num.mant + 1), {begin, cs.used(begin)}, ec_))) 2618| 0| return fail(cs.begin()); 2619| 1.12k| return cs.begin(); 2620| 1.12k| } 2621| 0| if(num.mant <= INT64_MAX) ------------------ | Branch (2621:8): [True: 0, False: 0] ------------------ 2622| 0| { 2623| 2.83k|finish_signed: 2624| 2.83k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 2.83k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 2.83k] | | ------------------ ------------------ 2625| 2.83k| ! h_.on_int64(static_cast< 2626| 2.83k| int64_t>(num.mant), {begin, cs.used(begin)}, ec_))) 2627| 0| return fail(cs.begin()); 2628| 2.83k| return cs.begin(); 2629| 2.83k| } 2630| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2631| 0| ! h_.on_uint64(num.mant, {begin, cs.used(begin)}, ec_))) 2632| 0| return fail(cs.begin()); 2633| 0| return cs.begin(); 2634| 8.13k|finish_dub: 2635| 8.13k| double const d = detail::dec_to_float( 2636| 8.13k| num.mant, 2637| 8.13k| num.bias + (num.frac ? ------------------ | Branch (2637:21): [True: 906, False: 7.22k] ------------------ 2638| 7.22k| -num.exp : num.exp), 2639| 8.13k| num.neg); 2640| 8.13k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 8.13k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 8.13k] | | ------------------ ------------------ 2641| 8.13k| ! h_.on_double(d, {begin, cs.used(begin)}, ec_))) 2642| 0| return fail(cs.begin()); 2643| 8.13k| return cs.begin(); 2644| 8.13k|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE12parse_numberILb1ELc43EEEPKcS7_NSt3__117integral_constantIbXT_EEENS9_IcXT0_EEE: 1991| 2.34M|{ 1992| | // only one of these will be true if we are not resuming 1993| | // if negative then !zero_first && !nonzero_first 1994| | // if zero_first then !nonzero_first && !negative 1995| | // if nonzero_first then !zero_first && !negative 1996| 2.34M| bool const negative = first == '-'; 1997| 2.34M| bool const zero_first = first == '0'; 1998| 2.34M| bool const nonzero_first = first == '+'; 1999| 2.34M| detail::const_stream_wrapper cs(p, end_); 2000| 2.34M| number num; 2001| 2.34M| const char* begin = cs.begin(); 2002| 2.34M| if(stack_empty || st_.empty()) ------------------ | Branch (2002:8): [Folded - Ignored] | Branch (2002:23): [True: 0, False: 0] ------------------ 2003| 2.34M| { 2004| 2.34M| num.bias = 0; 2005| 2.34M| num.exp = 0; 2006| 2.34M| num.frac = false; 2007| | 2008| | //---------------------------------- 2009| | // 2010| | // '-' 2011| | // leading minus sign 2012| | // 2013| 2.34M| BOOST_ASSERT(cs); ------------------ | | 60| 2.34M|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2014| 2.34M| if(negative) ------------------ | Branch (2014:12): [Folded - Ignored] ------------------ 2015| 0| ++cs; 2016| | 2017| 2.34M| num.neg = negative; 2018| 2.34M| num.frac = false; 2019| 2.34M| num.exp = 0; 2020| 2.34M| num.bias = 0; 2021| | 2022| | // fast path 2023| 2.34M| if( cs.remain() >= 16 + 1 + 16 ) // digits . digits ------------------ | Branch (2023:13): [True: 2.33M, False: 4.99k] ------------------ 2024| 2.33M| { 2025| 2.33M| int n1; 2026| | 2027| 2.33M| if( nonzero_first || ------------------ | Branch (2027:17): [Folded - Ignored] ------------------ 2028| 2.33M| (negative && *cs != '0') ) ------------------ | Branch (2028:18): [Folded - Ignored] | Branch (2028:30): [True: 0, False: 0] ------------------ 2029| 2.33M| { 2030| 2.33M| n1 = detail::count_digits( cs.begin() ); 2031| 2.33M| BOOST_ASSERT(n1 >= 0 && n1 <= 16); ------------------ | | 60| 2.33M|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2032| | 2033| 2.33M| if( ! nonzero_first && n1 == 0 ) ------------------ | Branch (2033:21): [Folded - Ignored] | Branch (2033:40): [True: 0, False: 0] ------------------ 2034| 0| { 2035| | // digit required 2036| 0| BOOST_STATIC_CONSTEXPR source_location loc 2037| 0| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2038| 0| return fail(cs.begin(), error::syntax, &loc); 2039| 0| } 2040| | 2041| 2.33M| num.mant = detail::parse_unsigned( 0, cs.begin(), n1 ); 2042| | 2043| 2.33M| cs += n1; 2044| | 2045| | // integer or floating-point with 2046| | // >= 16 leading digits 2047| 2.33M| if( n1 == 16 ) ------------------ | Branch (2047:21): [True: 6.19k, False: 2.33M] ------------------ 2048| 6.19k| { 2049| 6.19k| goto do_num2; 2050| 6.19k| } 2051| 2.33M| } 2052| 0| else 2053| 0| { 2054| | // 0. floating-point or 0e integer 2055| 0| num.mant = 0; 2056| 0| n1 = 0; 2057| 0| ++cs; 2058| 0| } 2059| | 2060| 2.33M| { 2061| 2.33M| const char c = *cs; 2062| 2.33M| if(c != '.') ------------------ | Branch (2062:20): [True: 2.32M, False: 6.02k] ------------------ 2063| 2.32M| { 2064| 2.32M| if((c | 32) == 'e') ------------------ | Branch (2064:24): [True: 7.09k, False: 2.31M] ------------------ 2065| 7.09k| { 2066| 7.09k| ++cs; 2067| 7.09k| goto do_exp1; 2068| 7.09k| } 2069| 2.31M| if(negative) ------------------ | Branch (2069:24): [Folded - Ignored] ------------------ 2070| 0| num.mant = ~num.mant + 1; 2071| 2.31M| goto finish_signed; 2072| 2.32M| } 2073| 2.33M| } 2074| | 2075| | // floating-point number 2076| | 2077| 6.02k| ++cs; 2078| | 2079| 6.02k| int n2 = detail::count_digits( cs.begin() ); 2080| 6.02k| BOOST_ASSERT(n2 >= 0 && n2 <= 16); ------------------ | | 60| 6.02k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2081| | 2082| 6.02k| if( n2 == 0 ) ------------------ | Branch (2082:17): [True: 3, False: 6.02k] ------------------ 2083| 3| { 2084| | // digit required 2085| 3| BOOST_STATIC_CONSTEXPR source_location loc 2086| 3| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 3|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2087| 3| return fail(cs.begin(), error::syntax, &loc); 2088| 3| } 2089| | 2090| | // floating-point mantissa overflow 2091| 6.02k| if( n1 + n2 >= 19 ) ------------------ | Branch (2091:17): [True: 388, False: 5.63k] ------------------ 2092| 388| { 2093| 388| goto do_num7; 2094| 388| } 2095| | 2096| 5.63k| num.mant = detail::parse_unsigned( num.mant, cs.begin(), n2 ); 2097| | 2098| 5.63k| BOOST_ASSERT(num.bias == 0); ------------------ | | 60| 5.63k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2099| | 2100| 5.63k| num.bias -= n2; 2101| | 2102| 5.63k| cs += n2; 2103| | 2104| 5.63k| char ch = *cs; 2105| | 2106| 5.63k| if( (ch | 32) == 'e' ) ------------------ | Branch (2106:17): [True: 1.49k, False: 4.13k] ------------------ 2107| 1.49k| { 2108| 1.49k| ++cs; 2109| 1.49k| goto do_exp1; 2110| 1.49k| } 2111| 4.13k| else if( ch >= '0' && ch <= '9' ) ------------------ | Branch (2111:22): [True: 1.11k, False: 3.02k] | Branch (2111:35): [True: 606, False: 508] ------------------ 2112| 606| { 2113| 606| goto do_num8; 2114| 606| } 2115| | 2116| 3.52k| goto finish_dub; 2117| 5.63k| } 2118| 2.34M| } 2119| 0| else 2120| 0| { 2121| 0| num = num_; 2122| 0| state st; 2123| 0| st_.pop(st); 2124| 0| switch(st) 2125| 0| { 2126| 0| default: BOOST_JSON_UNREACHABLE(); ------------------ | | 189| 0|# define BOOST_JSON_UNREACHABLE() __builtin_unreachable() ------------------ | Branch (2126:9): [True: 0, False: 0] ------------------ 2127| 0| case state::num1: goto do_num1; ------------------ | Branch (2127:9): [True: 0, False: 0] ------------------ 2128| 0| case state::num2: goto do_num2; ------------------ | Branch (2128:9): [True: 0, False: 0] ------------------ 2129| 0| case state::num3: goto do_num3; ------------------ | Branch (2129:9): [True: 0, False: 0] ------------------ 2130| 0| case state::num4: goto do_num4; ------------------ | Branch (2130:9): [True: 0, False: 0] ------------------ 2131| 0| case state::num5: goto do_num5; ------------------ | Branch (2131:9): [True: 0, False: 0] ------------------ 2132| 0| case state::num6: goto do_num6; ------------------ | Branch (2132:9): [True: 0, False: 0] ------------------ 2133| 0| case state::num7: goto do_num7; ------------------ | Branch (2133:9): [True: 0, False: 0] ------------------ 2134| 0| case state::num8: goto do_num8; ------------------ | Branch (2134:9): [True: 0, False: 0] ------------------ 2135| 0| case state::exp1: goto do_exp1; ------------------ | Branch (2135:9): [True: 0, False: 0] ------------------ 2136| 0| case state::exp2: goto do_exp2; ------------------ | Branch (2136:9): [True: 0, False: 0] ------------------ 2137| 0| case state::exp3: goto do_exp3; ------------------ | Branch (2137:9): [True: 0, False: 0] ------------------ 2138| 0| } 2139| 0| } 2140| | 2141| | //---------------------------------- 2142| | // 2143| | // DIGIT 2144| | // first digit 2145| | // 2146| 4.99k|do_num1: 2147| 4.99k| if(zero_first || nonzero_first || ------------------ | Branch (2147:8): [Folded - Ignored] | Branch (2147:22): [Folded - Ignored] ------------------ 2148| 4.99k| BOOST_JSON_LIKELY(cs)) ------------------ | | 171| 0|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 0, False: 0] | | ------------------ ------------------ 2149| 4.99k| { 2150| 4.99k| char const c = *cs; 2151| 4.99k| if(zero_first) ------------------ | Branch (2151:12): [Folded - Ignored] ------------------ 2152| 0| { 2153| 0| ++cs; 2154| 0| num.mant = 0; 2155| 0| goto do_num6; 2156| 0| } 2157| 4.99k| else if(nonzero_first || BOOST_JSON_LIKELY( ------------------ | | 171| 0|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 0, False: 0] | | | Branch (171:52): [True: 0, False: 0] | | | Branch (171:52): [True: 0, False: 0] | | ------------------ ------------------ | Branch (2157:17): [Folded - Ignored] ------------------ 2158| 4.99k| c >= '1' && c <= '9')) 2159| 4.99k| { 2160| 4.99k| ++cs; 2161| 4.99k| num.mant = c - '0'; 2162| 4.99k| } 2163| 0| else if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2164| 0| c == '0')) 2165| 0| { 2166| 0| ++cs; 2167| 0| num.mant = 0; 2168| 0| goto do_num6; 2169| 0| } 2170| 0| else 2171| 0| { 2172| 0| BOOST_STATIC_CONSTEXPR source_location loc 2173| 0| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2174| 0| return fail(cs.begin(), error::syntax, &loc); 2175| 0| } 2176| 4.99k| } 2177| 0| else 2178| 0| { 2179| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2180| 0| ! h_.on_number_part( 2181| 0| {begin, cs.used(begin)}, ec_))) 2182| 0| return fail(cs.begin()); 2183| 0| return maybe_suspend( 2184| 0| cs.begin(), state::num1, num); 2185| 0| } 2186| | 2187| | //---------------------------------- 2188| | // 2189| | // 1*DIGIT 2190| | // significant digits left of decimal 2191| | // 2192| 11.1k|do_num2: 2193| 11.1k| if(negative || (!stack_empty && num.neg)) ------------------ | Branch (2193:8): [Folded - Ignored] | Branch (2193:21): [Folded - Ignored] | Branch (2193:37): [True: 0, False: 0] ------------------ 2194| 0| { 2195| 0| for(;;) 2196| 0| { 2197| 0| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2198| 0| { 2199| 0| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2200| 0| { 2201| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2202| 0| ! h_.on_number_part( 2203| 0| {begin, cs.used(begin)}, ec_))) 2204| 0| return fail(cs.begin()); 2205| 0| return suspend(cs.begin(), state::num2, num); 2206| 0| } 2207| 0| goto finish_int; 2208| 0| } 2209| 0| char const c = *cs; 2210| 0| if(BOOST_JSON_LIKELY( ------------------ | | 171| 0|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 0, False: 0] | | | Branch (171:52): [True: 0, False: 0] | | | Branch (171:52): [True: 0, False: 0] | | ------------------ ------------------ 2211| 0| c >= '0' && c <= '9')) 2212| 0| { 2213| 0| ++cs; 2214| | // 9223372036854775808 INT64_MIN 2215| 0| if( num.mant > 922337203685477580 || ( ------------------ | Branch (2215:21): [True: 0, False: 0] ------------------ 2216| 0| num.mant == 922337203685477580 && c > '8')) ------------------ | Branch (2216:21): [True: 0, False: 0] | Branch (2216:55): [True: 0, False: 0] ------------------ 2217| 0| break; 2218| 0| num.mant = 10 * num.mant + ( c - '0' ); 2219| 0| continue; 2220| 0| } 2221| 0| goto do_num6; // [.eE] 2222| 0| } 2223| 0| } 2224| 11.1k| else 2225| 11.1k| { 2226| 11.1k| for(;;) 2227| 31.2k| { 2228| 31.2k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 31.2k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 306, False: 30.9k] | | ------------------ ------------------ 2229| 306| { 2230| 306| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 306|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 306] | | ------------------ ------------------ 2231| 0| { 2232| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2233| 0| ! h_.on_number_part( 2234| 0| {begin, cs.used(begin)}, ec_))) 2235| 0| return fail(cs.begin()); 2236| 0| return suspend(cs.begin(), state::num2, num); 2237| 0| } 2238| 306| goto finish_int; 2239| 306| } 2240| 30.9k| char const c = *cs; 2241| 30.9k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 53.6k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 21.2k, False: 9.67k] | | | Branch (171:52): [True: 22.6k, False: 8.26k] | | | Branch (171:52): [True: 21.2k, False: 1.40k] | | ------------------ ------------------ 2242| 30.9k| c >= '0' && c <= '9')) 2243| 21.2k| { 2244| 21.2k| ++cs; 2245| | // 18446744073709551615 UINT64_MAX 2246| 21.2k| if( num.mant > 1844674407370955161 || ( ------------------ | Branch (2246:21): [True: 977, False: 20.3k] ------------------ 2247| 20.3k| num.mant == 1844674407370955161 && c > '5')) ------------------ | Branch (2247:21): [True: 436, False: 19.8k] | Branch (2247:56): [True: 233, False: 203] ------------------ 2248| 1.21k| break; 2249| 20.0k| num.mant = 10 * num.mant + ( c - '0' ); 2250| 20.0k| } 2251| 9.67k| else 2252| 9.67k| { 2253| 9.67k| goto do_num6; // [.eE] 2254| 9.67k| } 2255| 30.9k| } 2256| 11.1k| } 2257| 1.21k| ++num.bias; 2258| | 2259| | //---------------------------------- 2260| | // 2261| | // 1*DIGIT 2262| | // non-significant digits left of decimal 2263| | // 2264| 1.21k|do_num3: 2265| 1.21k| for(;;) 2266| 992k| { 2267| 992k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 992k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 27, False: 992k] | | ------------------ ------------------ 2268| 27| { 2269| 27| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 27|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 27] | | ------------------ ------------------ 2270| 0| { 2271| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2272| 0| ! h_.on_number_part( 2273| 0| {begin, cs.used(begin)}, ec_))) 2274| 0| return fail(cs.begin()); 2275| 0| return suspend(cs.begin(), state::num3, num); 2276| 0| } 2277| 27| goto finish_dub; 2278| 27| } 2279| 992k| char const c = *cs; 2280| 992k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 1.98M|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 991k, False: 1.18k] | | | Branch (179:54): [True: 991k, False: 938] | | | Branch (179:54): [True: 991k, False: 245] | | ------------------ ------------------ 2281| 992k| c >= '0' && c <= '9')) 2282| 991k| { 2283| 991k| ++cs; 2284| | // VFALCO check overflow 2285| 991k| ++num.bias; 2286| 991k| } 2287| 1.18k| else if(BOOST_JSON_LIKELY( ------------------ | | 171| 1.18k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 251, False: 932] | | ------------------ ------------------ 2288| 1.18k| c == '.')) 2289| 251| { 2290| 251| ++cs; 2291| 251| break; 2292| 251| } 2293| 932| else if((c | 32) == 'e') ------------------ | Branch (2293:17): [True: 241, False: 691] ------------------ 2294| 241| { 2295| 241| ++cs; 2296| 241| goto do_exp1; 2297| 241| } 2298| 691| else 2299| 691| { 2300| 691| goto finish_dub; 2301| 691| } 2302| 992k| } 2303| | 2304| | //---------------------------------- 2305| | // 2306| | // DIGIT 2307| | // first non-significant digit 2308| | // to the right of decimal 2309| | // 2310| 251|do_num4: 2311| 251| { 2312| 251| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 251|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 4, False: 247] | | ------------------ ------------------ 2313| 4| { 2314| 4| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 4|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 4] | | ------------------ ------------------ 2315| 4| ! h_.on_number_part( 2316| 4| {begin, cs.used(begin)}, ec_))) 2317| 0| return fail(cs.begin()); 2318| 4| return maybe_suspend( 2319| 4| cs.begin(), state::num4, num); 2320| 4| } 2321| 247| char const c = *cs; 2322| 247| if(BOOST_JSON_LIKELY( ------------------ | | 171| 483|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 230, False: 17] | | | Branch (171:52): [True: 236, False: 11] | | | Branch (171:52): [True: 230, False: 6] | | ------------------ ------------------ 2323| | //static_cast(c - '0') < 10)) 2324| 247| c >= '0' && c <= '9')) 2325| 230| { 2326| 230| ++cs; 2327| 230| } 2328| 17| else 2329| 17| { 2330| | // digit required 2331| 17| BOOST_STATIC_CONSTEXPR source_location loc 2332| 17| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 17|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2333| 17| return fail(cs.begin(), error::syntax, &loc); 2334| 17| } 2335| 247| } 2336| | 2337| | //---------------------------------- 2338| | // 2339| | // 1*DIGIT 2340| | // non-significant digits 2341| | // to the right of decimal 2342| | // 2343| 1.69k|do_num5: 2344| 1.69k| for(;;) 2345| 4.71k| { 2346| 4.71k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 4.71k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 47, False: 4.66k] | | ------------------ ------------------ 2347| 47| { 2348| 47| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 47|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 47] | | ------------------ ------------------ 2349| 0| { 2350| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2351| 0| ! h_.on_number_part( 2352| 0| {begin, cs.used(begin)}, ec_))) 2353| 0| return fail(cs.begin()); 2354| 0| return suspend(cs.begin(), state::num5, num); 2355| 0| } 2356| 47| goto finish_dub; 2357| 47| } 2358| 4.66k| char const c = *cs; 2359| 4.66k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 8.13k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 3.01k, False: 1.65k] | | | Branch (171:52): [True: 3.46k, False: 1.19k] | | | Branch (171:52): [True: 3.01k, False: 454] | | ------------------ ------------------ 2360| 4.66k| c >= '0' && c <= '9')) 2361| 3.01k| { 2362| 3.01k| ++cs; 2363| 3.01k| } 2364| 1.65k| else if((c | 32) == 'e') ------------------ | Branch (2364:17): [True: 445, False: 1.20k] ------------------ 2365| 445| { 2366| 445| ++cs; 2367| 445| goto do_exp1; 2368| 445| } 2369| 1.20k| else 2370| 1.20k| { 2371| 1.20k| goto finish_dub; 2372| 1.20k| } 2373| 4.66k| } 2374| | 2375| | //---------------------------------- 2376| | // 2377| | // [.eE] 2378| | // 2379| 9.67k|do_num6: 2380| 9.67k| { 2381| 9.67k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 9.67k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 9.67k] | | ------------------ ------------------ 2382| 0| { 2383| 0| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2384| 0| { 2385| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2386| 0| ! h_.on_number_part( 2387| 0| {begin, cs.used(begin)}, ec_))) 2388| 0| return fail(cs.begin()); 2389| 0| return suspend(cs.begin(), state::num6, num); 2390| 0| } 2391| 0| goto finish_int; 2392| 0| } 2393| 9.67k| char const c = *cs; 2394| 9.67k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 9.67k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 1.15k, False: 8.51k] | | ------------------ ------------------ 2395| 9.67k| c == '.')) 2396| 1.15k| { 2397| 1.15k| ++cs; 2398| 1.15k| } 2399| 8.51k| else if((c | 32) == 'e') ------------------ | Branch (2399:17): [True: 921, False: 7.59k] ------------------ 2400| 921| { 2401| 921| ++cs; 2402| 921| goto do_exp1; 2403| 921| } 2404| 7.59k| else 2405| 7.59k| { 2406| 7.59k| goto finish_int; 2407| 7.59k| } 2408| 9.67k| } 2409| | 2410| | //---------------------------------- 2411| | // 2412| | // DIGIT 2413| | // first significant digit 2414| | // to the right of decimal 2415| | // 2416| 1.54k|do_num7: 2417| 1.54k| { 2418| 1.54k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 1.54k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 7, False: 1.53k] | | ------------------ ------------------ 2419| 7| { 2420| 7| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 7|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 7] | | ------------------ ------------------ 2421| 0| { 2422| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2423| 0| ! h_.on_number_part( 2424| 0| {begin, cs.used(begin)}, ec_))) 2425| 0| return fail(cs.begin()); 2426| 0| return suspend(cs.begin(), state::num7, num); 2427| 0| } 2428| | // digit required 2429| 7| BOOST_STATIC_CONSTEXPR source_location loc 2430| 7| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 7|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2431| 7| return fail(cs.begin(), error::syntax, &loc); 2432| 7| } 2433| 1.53k| char const c = *cs; 2434| 1.53k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 3.06k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 22, False: 1.51k] | | | Branch (179:54): [True: 14, False: 1.52k] | | | Branch (179:54): [True: 8, False: 1.51k] | | ------------------ ------------------ 2435| 1.53k| c < '0' || c > '9')) 2436| 22| { 2437| | // digit required 2438| 22| BOOST_STATIC_CONSTEXPR source_location loc 2439| 22| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 22|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2440| 22| return fail(cs.begin(), error::syntax, &loc); 2441| 22| } 2442| 1.53k| } 2443| | 2444| | //---------------------------------- 2445| | // 2446| | // 1*DIGIT 2447| | // significant digits 2448| | // to the right of decimal 2449| | // 2450| 2.12k|do_num8: 2451| 2.12k| for(;;) 2452| 8.23k| { 2453| 8.23k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 8.23k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 112, False: 8.12k] | | ------------------ ------------------ 2454| 112| { 2455| 112| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 112|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 112] | | ------------------ ------------------ 2456| 0| { 2457| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2458| 0| ! h_.on_number_part( 2459| 0| {begin, cs.used(begin)}, ec_))) 2460| 0| return fail(cs.begin()); 2461| 0| return suspend(cs.begin(), state::num8, num); 2462| 0| } 2463| 112| goto finish_dub; 2464| 112| } 2465| 8.12k| char const c = *cs; 2466| 8.12k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 15.9k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 7.57k, False: 542] | | | Branch (171:52): [True: 7.82k, False: 299] | | | Branch (171:52): [True: 7.57k, False: 243] | | ------------------ ------------------ 2467| 8.12k| c >= '0' && c <= '9')) 2468| 7.57k| { 2469| 7.57k| ++cs; 2470| 7.57k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 7.57k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 6.11k, False: 1.46k] | | ------------------ ------------------ 2471| 7.57k| num.mant <= 9007199254740991)) // 2^53-1 2472| 6.11k| { 2473| 6.11k| --num.bias; 2474| 6.11k| num.mant = 10 * num.mant + ( c - '0' ); 2475| 6.11k| } 2476| 1.46k| else 2477| 1.46k| { 2478| 1.46k| goto do_num5; 2479| 1.46k| } 2480| 7.57k| } 2481| 542| else if((c | 32) == 'e') ------------------ | Branch (2481:17): [True: 235, False: 307] ------------------ 2482| 235| { 2483| 235| ++cs; 2484| 235| goto do_exp1; 2485| 235| } 2486| 307| else 2487| 307| { 2488| 307| goto finish_dub; 2489| 307| } 2490| 8.12k| } 2491| | 2492| | //---------------------------------- 2493| | // 2494| | // *[+-] 2495| | // 2496| 10.4k|do_exp1: 2497| 10.4k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 10.4k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 34, False: 10.3k] | | ------------------ ------------------ 2498| 34| { 2499| 34| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 34|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 34] | | ------------------ ------------------ 2500| 34| ! h_.on_number_part( 2501| 34| {begin, cs.used(begin)}, ec_))) 2502| 0| return fail(cs.begin()); 2503| 34| return maybe_suspend( 2504| 34| cs.begin(), state::exp1, num); 2505| 34| } 2506| 10.3k| if(*cs == '+') ------------------ | Branch (2506:8): [True: 239, False: 10.1k] ------------------ 2507| 239| { 2508| 239| ++cs; 2509| 239| } 2510| 10.1k| else if(*cs == '-') ------------------ | Branch (2510:13): [True: 1.37k, False: 8.77k] ------------------ 2511| 1.37k| { 2512| 1.37k| ++cs; 2513| 1.37k| num.frac = true; 2514| 1.37k| } 2515| | 2516| | //---------------------------------- 2517| | // 2518| | // DIGIT 2519| | // first digit of the exponent 2520| | // 2521| 10.3k|do_exp2: 2522| 10.3k| { 2523| 10.3k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 10.3k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 14, False: 10.3k] | | ------------------ ------------------ 2524| 14| { 2525| 14| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 14|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 14] | | ------------------ ------------------ 2526| 0| { 2527| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2528| 0| ! h_.on_number_part( 2529| 0| {begin, cs.used(begin)}, ec_))) 2530| 0| return fail(cs.begin()); 2531| 0| return suspend(cs.begin(), state::exp2, num); 2532| 0| } 2533| | // digit required 2534| 14| BOOST_STATIC_CONSTEXPR source_location loc 2535| 14| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 14|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2536| 14| return fail(cs.begin(), error::syntax, &loc); 2537| 14| } 2538| 10.3k| char const c = *cs; 2539| 10.3k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 20.7k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 28, False: 10.3k] | | | Branch (179:54): [True: 21, False: 10.3k] | | | Branch (179:54): [True: 7, False: 10.3k] | | ------------------ ------------------ 2540| 10.3k| c < '0' || c > '9')) 2541| 28| { 2542| | // digit required 2543| 28| BOOST_STATIC_CONSTEXPR source_location loc 2544| 28| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 28|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2545| 28| return fail(cs.begin(), error::syntax, &loc); 2546| 28| } 2547| 10.3k| ++cs; 2548| 10.3k| num.exp = c - '0'; 2549| 10.3k| } 2550| | 2551| | //---------------------------------- 2552| | // 2553| | // 1*DIGIT 2554| | // subsequent digits in the exponent 2555| | // 2556| 10.3k|do_exp3: 2557| 10.3k| for(;;) 2558| 18.8k| { 2559| 18.8k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 18.8k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 324, False: 18.5k] | | ------------------ ------------------ 2560| 324| { 2561| 324| if(BOOST_JSON_UNLIKELY(more_)) ------------------ | | 179| 324|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 324] | | ------------------ ------------------ 2562| 0| { 2563| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2564| 0| ! h_.on_number_part( 2565| 0| {begin, cs.used(begin)}, ec_))) 2566| 0| return fail(cs.begin()); 2567| 0| return suspend(cs.begin(), state::exp3, num); 2568| 0| } 2569| 324| } 2570| 18.5k| else 2571| 18.5k| { 2572| 18.5k| char const c = *cs; 2573| 18.5k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 27.1k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 8.54k, False: 10.0k] | | | Branch (171:52): [True: 8.55k, False: 10.0k] | | | Branch (171:52): [True: 8.54k, False: 9] | | ------------------ ------------------ 2574| 18.5k| c >= '0' && c <= '9')) 2575| 8.54k| { 2576| 8.54k| if(BOOST_JSON_UNLIKELY ------------------ | | 179| 25.8k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 5, False: 8.54k] | | | Branch (179:54): [True: 209, False: 8.33k] | | | Branch (179:54): [True: 1, False: 208] | | | Branch (179:54): [True: 4, False: 8.54k] | | ------------------ ------------------ 2577| | // 2147483647 INT_MAX 2578| 8.54k| (num.exp > 214748364 || ( 2579| 8.54k| num.exp == 214748364 && c > '7'))) 2580| 5| { 2581| 5| BOOST_STATIC_CONSTEXPR source_location loc 2582| 5| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 5|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2583| 5| return fail(cs.begin(), error::exponent_overflow, &loc); 2584| 5| } 2585| 8.54k| ++cs; 2586| 8.54k| num.exp = 10 * num.exp + ( c - '0' ); 2587| 8.54k| continue; 2588| 8.54k| } 2589| 18.5k| } 2590| 10.3k| BOOST_ASSERT(num.exp >= 0); ------------------ | | 60| 10.3k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2591| 10.3k| if ( num.frac ) ------------------ | Branch (2591:14): [True: 1.37k, False: 8.97k] ------------------ 2592| 1.37k| { 2593| 1.37k| if (BOOST_JSON_UNLIKELY( num.bias < (INT_MIN + num.exp) )) ------------------ | | 179| 1.37k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 1, False: 1.37k] | | ------------------ ------------------ 2594| 1| { 2595| 1| BOOST_STATIC_CONSTEXPR source_location loc 2596| 1| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 1|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2597| 1| return fail(cs.begin(), error::exponent_overflow, &loc); 2598| 1| } 2599| 1.37k| } 2600| 8.97k| else 2601| 8.97k| { 2602| 8.97k| if (BOOST_JSON_UNLIKELY( num.bias > (INT_MAX - num.exp) )) ------------------ | | 179| 8.97k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 5, False: 8.97k] | | ------------------ ------------------ 2603| 5| { 2604| 5| BOOST_STATIC_CONSTEXPR source_location loc 2605| 5| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 5|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 2606| 5| return fail(cs.begin(), error::exponent_overflow, &loc); 2607| 5| } 2608| 8.97k| } 2609| 10.3k| goto finish_dub; 2610| 10.3k| } 2611| | 2612| 7.90k|finish_int: 2613| 7.90k| if(negative || (!stack_empty && num.neg)) ------------------ | Branch (2613:8): [Folded - Ignored] | Branch (2613:21): [Folded - Ignored] | Branch (2613:37): [True: 0, False: 0] ------------------ 2614| 0| { 2615| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 2616| 0| ! h_.on_int64(static_cast< 2617| 0| int64_t>(~num.mant + 1), {begin, cs.used(begin)}, ec_))) 2618| 0| return fail(cs.begin()); 2619| 0| return cs.begin(); 2620| 0| } 2621| 7.90k| if(num.mant <= INT64_MAX) ------------------ | Branch (2621:8): [True: 5.03k, False: 2.86k] ------------------ 2622| 5.03k| { 2623| 2.32M|finish_signed: 2624| 2.32M| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 2.32M|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 2.32M] | | ------------------ ------------------ 2625| 2.32M| ! h_.on_int64(static_cast< 2626| 2.32M| int64_t>(num.mant), {begin, cs.used(begin)}, ec_))) 2627| 0| return fail(cs.begin()); 2628| 2.32M| return cs.begin(); 2629| 2.32M| } 2630| 2.86k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 2.86k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 2.86k] | | ------------------ ------------------ 2631| 2.86k| ! h_.on_uint64(num.mant, {begin, cs.used(begin)}, ec_))) 2632| 0| return fail(cs.begin()); 2633| 2.86k| return cs.begin(); 2634| 16.2k|finish_dub: 2635| 16.2k| double const d = detail::dec_to_float( 2636| 16.2k| num.mant, 2637| 16.2k| num.bias + (num.frac ? ------------------ | Branch (2637:21): [True: 1.37k, False: 14.8k] ------------------ 2638| 14.8k| -num.exp : num.exp), 2639| 16.2k| num.neg); 2640| 16.2k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 16.2k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 16.2k] | | ------------------ ------------------ 2641| 16.2k| ! h_.on_double(d, {begin, cs.used(begin)}, ec_))) 2642| 0| return fail(cs.begin()); 2643| 16.2k| return cs.begin(); 2644| 16.2k|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE10parse_trueILb1EEEPKcS7_NSt3__117integral_constantIbXT_EEE: 816| 6.76k|{ 817| 6.76k| detail::const_stream_wrapper cs(p, end_); 818| 6.76k| if(stack_empty || st_.empty()) ------------------ | Branch (818:8): [Folded - Ignored] | Branch (818:23): [True: 0, False: 0] ------------------ 819| 6.76k| { 820| 6.76k| if(BOOST_JSON_LIKELY(cs.remain() >= 4)) ------------------ | | 171| 6.76k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 6.72k, False: 37] | | ------------------ ------------------ 821| 6.72k| { 822| 6.72k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 6.72k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 20, False: 6.70k] | | ------------------ ------------------ 823| 6.72k| std::memcmp(cs.begin(), "true", 4) != 0)) 824| 20| { 825| 20| BOOST_STATIC_CONSTEXPR source_location loc 826| 20| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 20|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 827| 20| return fail(cs.begin(), error::syntax, &loc); 828| 20| } 829| 6.70k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 6.70k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 6.70k] | | ------------------ ------------------ 830| 6.70k| ! h_.on_bool(true, ec_))) 831| 0| return fail(cs.begin()); 832| 6.70k| cs += 4; 833| 6.70k| return cs.begin(); 834| 6.70k| } 835| 6.76k| } 836| 0| else 837| 0| { 838| 0| state st; 839| 0| st_.pop(st); 840| 0| switch(st) 841| 0| { 842| 0| default: BOOST_JSON_UNREACHABLE(); ------------------ | | 189| 0|# define BOOST_JSON_UNREACHABLE() __builtin_unreachable() ------------------ | Branch (842:9): [True: 0, False: 0] ------------------ 843| 0| case state::tru1: goto do_tru1; ------------------ | Branch (843:9): [True: 0, False: 0] ------------------ 844| 0| case state::tru2: goto do_tru2; ------------------ | Branch (844:9): [True: 0, False: 0] ------------------ 845| 0| case state::tru3: goto do_tru3; ------------------ | Branch (845:9): [True: 0, False: 0] ------------------ 846| 0| } 847| 0| } 848| 37| ++cs; 849| 37|do_tru1: 850| 37| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 37|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 10, False: 27] | | ------------------ ------------------ 851| 10| return maybe_suspend(cs.begin(), state::tru1); 852| 27| if(BOOST_JSON_UNLIKELY(*cs != 'r')) ------------------ | | 179| 27|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 14, False: 13] | | ------------------ ------------------ 853| 14| { 854| 14| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; ------------------ | | 170| 14|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 855| 14| return fail(cs.begin(), error::syntax, &loc); 856| 14| } 857| 13| ++cs; 858| 13|do_tru2: 859| 13| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 13|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 1, False: 12] | | ------------------ ------------------ 860| 1| return maybe_suspend(cs.begin(), state::tru2); 861| 12| if(BOOST_JSON_UNLIKELY(*cs != 'u')) ------------------ | | 179| 12|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 11, False: 1] | | ------------------ ------------------ 862| 11| { 863| 11| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; ------------------ | | 170| 11|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 864| 11| return fail(cs.begin(), error::syntax, &loc); 865| 11| } 866| 1| ++cs; 867| 1|do_tru3: 868| 1| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 1|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 1, False: 0] | | ------------------ ------------------ 869| 1| return maybe_suspend(cs.begin(), state::tru3); 870| 0| if(BOOST_JSON_UNLIKELY(*cs != 'e')) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 871| 0| { 872| 0| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 873| 0| return fail(cs.begin(), error::syntax, &loc); 874| 0| } 875| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 876| 0| ! h_.on_bool(true, ec_))) 877| 0| return fail(cs.begin()); 878| 0| ++cs; 879| 0| return cs.begin(); 880| 0|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE11parse_falseILb1EEEPKcS7_NSt3__117integral_constantIbXT_EEE: 888| 324|{ 889| 324| detail::const_stream_wrapper cs(p, end_); 890| 324| if(stack_empty || st_.empty()) ------------------ | Branch (890:8): [Folded - Ignored] | Branch (890:23): [True: 0, False: 0] ------------------ 891| 324| { 892| 324| if(BOOST_JSON_LIKELY(cs.remain() >= 5)) ------------------ | | 171| 324|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 295, False: 29] | | ------------------ ------------------ 893| 295| { 894| 295| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 295|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 22, False: 273] | | ------------------ ------------------ 895| 295| std::memcmp(cs.begin() + 1, "alse", 4) != 0)) 896| 22| { 897| 22| BOOST_STATIC_CONSTEXPR source_location loc 898| 22| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 22|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 899| 22| return fail(cs.begin(), error::syntax, &loc); 900| 22| } 901| 273| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 273|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 273] | | ------------------ ------------------ 902| 273| ! h_.on_bool(false, ec_))) 903| 0| return fail(cs.begin()); 904| 273| cs += 5; 905| 273| return cs.begin(); 906| 273| } 907| 324| } 908| 0| else 909| 0| { 910| 0| state st; 911| 0| st_.pop(st); 912| 0| switch(st) 913| 0| { 914| 0| default: BOOST_JSON_UNREACHABLE(); ------------------ | | 189| 0|# define BOOST_JSON_UNREACHABLE() __builtin_unreachable() ------------------ | Branch (914:9): [True: 0, False: 0] ------------------ 915| 0| case state::fal1: goto do_fal1; ------------------ | Branch (915:9): [True: 0, False: 0] ------------------ 916| 0| case state::fal2: goto do_fal2; ------------------ | Branch (916:9): [True: 0, False: 0] ------------------ 917| 0| case state::fal3: goto do_fal3; ------------------ | Branch (917:9): [True: 0, False: 0] ------------------ 918| 0| case state::fal4: goto do_fal4; ------------------ | Branch (918:9): [True: 0, False: 0] ------------------ 919| 0| } 920| 0| } 921| 29| ++cs; 922| 29|do_fal1: 923| 29| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 29|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 9, False: 20] | | ------------------ ------------------ 924| 9| return maybe_suspend(cs.begin(), state::fal1); 925| 20| if(BOOST_JSON_UNLIKELY(*cs != 'a')) ------------------ | | 179| 20|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 4, False: 16] | | ------------------ ------------------ 926| 4| { 927| 4| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; ------------------ | | 170| 4|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 928| 4| return fail(cs.begin(), error::syntax, &loc); 929| 4| } 930| 16| ++cs; 931| 16|do_fal2: 932| 16| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 16|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 1, False: 15] | | ------------------ ------------------ 933| 1| return maybe_suspend(cs.begin(), state::fal2); 934| 15| if(BOOST_JSON_UNLIKELY(*cs != 'l')) ------------------ | | 179| 15|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 2, False: 13] | | ------------------ ------------------ 935| 2| { 936| 2| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; ------------------ | | 170| 2|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 937| 2| return fail(cs.begin(), error::syntax, &loc); 938| 2| } 939| 13| ++cs; 940| 13|do_fal3: 941| 13| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 13|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 1, False: 12] | | ------------------ ------------------ 942| 1| return maybe_suspend(cs.begin(), state::fal3); 943| 12| if(BOOST_JSON_UNLIKELY(*cs != 's')) ------------------ | | 179| 12|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 11, False: 1] | | ------------------ ------------------ 944| 11| { 945| 11| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; ------------------ | | 170| 11|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 946| 11| return fail(cs.begin(), error::syntax, &loc); 947| 11| } 948| 1| ++cs; 949| 1|do_fal4: 950| 1| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 1|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 1, False: 0] | | ------------------ ------------------ 951| 1| return maybe_suspend(cs.begin(), state::fal4); 952| 0| if(BOOST_JSON_UNLIKELY(*cs != 'e')) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 953| 0| { 954| 0| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 955| 0| return fail(cs.begin(), error::syntax, &loc); 956| 0| } 957| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 958| 0| ! h_.on_bool(false, ec_))) 959| 0| return fail(cs.begin()); 960| 0| ++cs; 961| 0| return cs.begin(); 962| 0|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE10parse_nullILb1EEEPKcS7_NSt3__117integral_constantIbXT_EEE: 744| 2.62k|{ 745| 2.62k| detail::const_stream_wrapper cs(p, end_); 746| 2.62k| if(stack_empty || st_.empty()) ------------------ | Branch (746:8): [Folded - Ignored] | Branch (746:23): [True: 0, False: 0] ------------------ 747| 2.62k| { 748| 2.62k| if(BOOST_JSON_LIKELY(cs.remain() >= 4)) ------------------ | | 171| 2.62k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 2.58k, False: 37] | | ------------------ ------------------ 749| 2.58k| { 750| 2.58k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 2.58k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 24, False: 2.56k] | | ------------------ ------------------ 751| 2.58k| std::memcmp(cs.begin(), "null", 4) != 0)) 752| 24| { 753| 24| BOOST_STATIC_CONSTEXPR source_location loc 754| 24| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 24|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 755| 24| return fail(cs.begin(), error::syntax, &loc); 756| 24| } 757| 2.56k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 2.56k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 2.56k] | | ------------------ ------------------ 758| 2.56k| ! h_.on_null(ec_))) 759| 0| return fail(cs.begin()); 760| 2.56k| cs += 4; 761| 2.56k| return cs.begin(); 762| 2.56k| } 763| 2.62k| } 764| 0| else 765| 0| { 766| 0| state st; 767| 0| st_.pop(st); 768| 0| switch(st) 769| 0| { 770| 0| default: BOOST_JSON_UNREACHABLE(); ------------------ | | 189| 0|# define BOOST_JSON_UNREACHABLE() __builtin_unreachable() ------------------ | Branch (770:9): [True: 0, False: 0] ------------------ 771| 0| case state::nul1: goto do_nul1; ------------------ | Branch (771:9): [True: 0, False: 0] ------------------ 772| 0| case state::nul2: goto do_nul2; ------------------ | Branch (772:9): [True: 0, False: 0] ------------------ 773| 0| case state::nul3: goto do_nul3; ------------------ | Branch (773:9): [True: 0, False: 0] ------------------ 774| 0| } 775| 0| } 776| 37| ++cs; 777| 37|do_nul1: 778| 37| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 37|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 10, False: 27] | | ------------------ ------------------ 779| 10| return maybe_suspend(cs.begin(), state::nul1); 780| 27| if(BOOST_JSON_UNLIKELY(*cs != 'u')) ------------------ | | 179| 27|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 11, False: 16] | | ------------------ ------------------ 781| 11| { 782| 11| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; ------------------ | | 170| 11|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 783| 11| return fail(cs.begin(), error::syntax, &loc); 784| 11| } 785| 16| ++cs; 786| 16|do_nul2: 787| 16| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 16|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 1, False: 15] | | ------------------ ------------------ 788| 1| return maybe_suspend(cs.begin(), state::nul2); 789| 15| if(BOOST_JSON_UNLIKELY(*cs != 'l')) ------------------ | | 179| 15|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 14, False: 1] | | ------------------ ------------------ 790| 14| { 791| 14| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; ------------------ | | 170| 14|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 792| 14| return fail(cs.begin(), error::syntax, &loc); 793| 14| } 794| 1| ++cs; 795| 1|do_nul3: 796| 1| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 1|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 1, False: 0] | | ------------------ ------------------ 797| 1| return maybe_suspend(cs.begin(), state::nul3); 798| 0| if(BOOST_JSON_UNLIKELY(*cs != 'l')) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 799| 0| { 800| 0| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 801| 0| return fail(cs.begin(), error::syntax, &loc); 802| 0| } 803| 0| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 804| 0| ! h_.on_null(ec_))) 805| 0| return fail(cs.begin()); 806| 0| ++cs; 807| 0| return cs.begin(); 808| 0|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE15parse_unescapedILb1ELb0EEEPKcS7_NSt3__117integral_constantIbXT_EEENS9_IbXT0_EEEb: 1013| 34.9k|{ 1014| 34.9k| detail::const_stream_wrapper cs(p, end_); 1015| 34.9k| std::size_t total; 1016| 34.9k| if(stack_empty || st_.empty()) ------------------ | Branch (1016:8): [Folded - Ignored] | Branch (1016:23): [True: 0, False: 0] ------------------ 1017| 34.9k| { 1018| 34.9k| BOOST_ASSERT(*cs == '\x22'); // '"' ------------------ | | 60| 34.9k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 1019| 34.9k| ++cs; 1020| 34.9k| total = 0; 1021| 34.9k| } 1022| 0| else 1023| 0| { 1024| 0| state st; 1025| 0| st_.pop(st); 1026| 0| st_.pop(total); 1027| 0| } 1028| 34.9k| char const* start = cs.begin(); 1029| 34.9k| cs = allow_bad_utf8? ------------------ | Branch (1029:10): [True: 0, False: 34.9k] ------------------ 1030| 0| detail::count_valid(cs.begin(), cs.end()): 1031| 34.9k| detail::count_valid(cs.begin(), cs.end()); 1032| 34.9k| std::size_t size = cs.used(start); 1033| 34.9k| if(is_key) ------------------ | Branch (1033:8): [Folded - Ignored] ------------------ 1034| 0| { 1035| 0| BOOST_ASSERT(total <= Handler::max_key_size); ------------------ | | 60| 0|# define BOOST_ASSERT(expr) assert(expr) ------------------ 1036| 0| if(BOOST_JSON_UNLIKELY(size > ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 1037| 0| Handler::max_key_size - total)) 1038| 0| { 1039| 0| BOOST_STATIC_CONSTEXPR source_location loc 1040| 0| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1041| 0| return fail(cs.begin(), error::key_too_large, &loc); 1042| 0| } 1043| 0| } 1044| 34.9k| else 1045| 34.9k| { 1046| 34.9k| BOOST_ASSERT(total <= Handler::max_string_size); ------------------ | | 60| 34.9k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 1047| 34.9k| if(BOOST_JSON_UNLIKELY(size > ------------------ | | 179| 34.9k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 34.9k] | | ------------------ ------------------ 1048| 34.9k| Handler::max_string_size - total)) 1049| 0| { 1050| 0| BOOST_STATIC_CONSTEXPR source_location loc 1051| 0| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1052| 0| return fail(cs.begin(), error::string_too_large, &loc); 1053| 0| } 1054| 34.9k| } 1055| 34.9k| total += size; 1056| 34.9k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 34.9k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 136, False: 34.8k] | | ------------------ ------------------ 1057| 136| { 1058| | // call handler if the string isn't empty 1059| 136| if(BOOST_JSON_LIKELY(size)) ------------------ | | 171| 136|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 125, False: 11] | | ------------------ ------------------ 1060| 125| { 1061| 125| { 1062| 125| bool r = is_key? ------------------ | Branch (1062:26): [Folded - Ignored] ------------------ 1063| 0| h_.on_key_part( {start, size}, total, ec_ ): 1064| 125| h_.on_string_part( {start, size}, total, ec_ ); 1065| | 1066| 125| if(BOOST_JSON_UNLIKELY(!r)) ------------------ | | 179| 125|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 125] | | ------------------ ------------------ 1067| 0| { 1068| 0| return fail(cs.begin()); 1069| 0| } 1070| 125| } 1071| 125| } 1072| 136| return maybe_suspend(cs.begin(), state::str1, total); 1073| 136| } 1074| | // at this point all valid characters have been skipped, so any remaining 1075| | // if there are any more characters, they are either escaped, or incomplete 1076| | // utf8, or invalid utf8 1077| 34.8k| if(BOOST_JSON_UNLIKELY(*cs != '\x22')) // '"' ------------------ | | 179| 34.8k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 14.4k, False: 20.3k] | | ------------------ ------------------ 1078| 14.4k| { 1079| | // sequence is invalid or incomplete 1080| 14.4k| if((*cs & 0x80) && !allow_bad_utf8) ------------------ | Branch (1080:12): [True: 147, False: 14.3k] | Branch (1080:28): [True: 147, False: 0] ------------------ 1081| 147| { 1082| 147| seq_.save(cs.begin(), cs.remain()); 1083| 147| if(BOOST_JSON_UNLIKELY(seq_.complete())) ------------------ | | 179| 147|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 119, False: 28] | | ------------------ ------------------ 1084| 119| { 1085| 119| BOOST_STATIC_CONSTEXPR source_location loc 1086| 119| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 119|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1087| 119| return fail(cs.begin(), error::syntax, &loc); 1088| 119| } 1089| 28| if(BOOST_JSON_LIKELY(size)) ------------------ | | 171| 28|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 21, False: 7] | | ------------------ ------------------ 1090| 21| { 1091| 21| { 1092| 21| bool r = is_key? ------------------ | Branch (1092:30): [Folded - Ignored] ------------------ 1093| 0| h_.on_key_part( {start, size}, total, ec_ ): 1094| 21| h_.on_string_part( {start, size}, total, ec_ ); 1095| | 1096| 21| if(BOOST_JSON_UNLIKELY(!r)) ------------------ | | 179| 21|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 21] | | ------------------ ------------------ 1097| 0| { 1098| 0| return fail(cs.begin()); 1099| 0| } 1100| 21| } 1101| 21| } 1102| 28| return maybe_suspend(cs.end(), state::str8, total); 1103| 28| } 1104| 14.3k| else if(BOOST_JSON_LIKELY(*cs == '\\')) ------------------ | | 171| 14.3k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 14.2k, False: 14] | | ------------------ ------------------ 1105| 14.2k| { 1106| | // flush unescaped run from input 1107| 14.2k| if(BOOST_JSON_LIKELY(size)) ------------------ | | 171| 14.2k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 11.0k, False: 3.28k] | | ------------------ ------------------ 1108| 11.0k| { 1109| 11.0k| { 1110| 11.0k| bool r = is_key? ------------------ | Branch (1110:30): [Folded - Ignored] ------------------ 1111| 0| h_.on_key_part( {start, size}, total, ec_ ): 1112| 11.0k| h_.on_string_part( {start, size}, total, ec_ ); 1113| | 1114| 11.0k| if(BOOST_JSON_UNLIKELY(!r)) ------------------ | | 179| 11.0k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 11.0k] | | ------------------ ------------------ 1115| 0| { 1116| 0| return fail(cs.begin()); 1117| 0| } 1118| 11.0k| } 1119| 11.0k| } 1120| 14.2k| return parse_escaped(cs.begin(), total, stack_empty, is_key, allow_bad_utf8); 1121| 14.2k| } 1122| | // illegal control 1123| 14| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; ------------------ | | 170| 14|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1124| 14| return fail(cs.begin(), error::syntax, &loc); 1125| 14.4k| } 1126| | 1127| 20.3k| { 1128| 20.3k| bool r = is_key? ------------------ | Branch (1128:18): [Folded - Ignored] ------------------ 1129| 0| h_.on_key( {start, size}, total, ec_ ): 1130| 20.3k| h_.on_string( {start, size}, total, ec_ ); 1131| | 1132| 20.3k| if(BOOST_JSON_UNLIKELY(!r)) ------------------ | | 179| 20.3k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 20.3k] | | ------------------ ------------------ 1133| 0| { 1134| 0| return fail(cs.begin()); 1135| 0| } 1136| 20.3k| } 1137| | 1138| 20.3k| ++cs; 1139| 20.3k| return cs.begin(); 1140| 20.3k|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE13maybe_suspendEPKcNS4_5stateEm: 324| 1.76k|{ 325| 1.76k| end_ = p; 326| 1.76k| if(BOOST_JSON_LIKELY(more_)) ------------------ | | 171| 1.76k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 0, False: 1.76k] | | ------------------ ------------------ 327| 0| { 328| | // suspend 329| 0| reserve(); 330| 0| st_.push_unchecked(n); 331| 0| st_.push_unchecked(st); 332| 0| } 333| 1.76k| return sentinel(); 334| 1.76k|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE13parse_escapedILb1EEEPKcS7_mNSt3__117integral_constantIbXT_EEEbb: 1155| 15.5k|{ 1156| | //--------------------------------------------------------------- 1157| | // 1158| | // To handle escapes, a local temporary buffer accumulates 1159| | // the unescaped result. The algorithm attempts to fill the 1160| | // buffer to capacity before invoking the handler. 1161| | // In some cases the temporary buffer needs to be flushed 1162| | // before it is full: 1163| | // * When the closing double quote is seen 1164| | // * When there in no more input (and more is expected later) 1165| | // A goal of the algorithm is to call the handler as few times 1166| | // as possible. Thus, when the first escape is encountered, 1167| | // the algorithm attempts to fill the temporary buffer first. 1168| | // 1169| 15.5k| auto const ev_too_large = is_key? ------------------ | Branch (1169:31): [True: 1.30k, False: 14.2k] ------------------ 1170| 14.2k| error::key_too_large : error::string_too_large; 1171| 15.5k| auto const max_size = is_key? ------------------ | Branch (1171:27): [True: 1.30k, False: 14.2k] ------------------ 1172| 14.2k| Handler::max_key_size : Handler::max_string_size; 1173| 15.5k| detail::clipped_const_stream cs(p, end_); 1174| 15.5k| detail::buffer temp; 1175| 15.5k| int digit; 1176| 15.5k| char c; 1177| 15.5k| cs.clip(temp.max_size()); 1178| 15.5k| if(! stack_empty && ! st_.empty()) ------------------ | Branch (1178:8): [Folded - Ignored] | Branch (1178:25): [True: 0, False: 0] ------------------ 1179| 0| { 1180| 0| state st; 1181| 0| st_.pop(st); 1182| 0| st_.pop(total); 1183| 0| switch(st) 1184| 0| { 1185| 0| default: BOOST_JSON_UNREACHABLE(); ------------------ | | 189| 0|# define BOOST_JSON_UNREACHABLE() __builtin_unreachable() ------------------ | Branch (1185:9): [True: 0, False: 0] ------------------ 1186| 0| case state::str2: goto do_str2; ------------------ | Branch (1186:9): [True: 0, False: 0] ------------------ 1187| 0| case state::str3: goto do_str3; ------------------ | Branch (1187:9): [True: 0, False: 0] ------------------ 1188| 0| case state::str4: goto do_str4; ------------------ | Branch (1188:9): [True: 0, False: 0] ------------------ 1189| 0| case state::str5: goto do_str5; ------------------ | Branch (1189:9): [True: 0, False: 0] ------------------ 1190| 0| case state::str6: goto do_str6; ------------------ | Branch (1190:9): [True: 0, False: 0] ------------------ 1191| 0| case state::str7: goto do_str7; ------------------ | Branch (1191:9): [True: 0, False: 0] ------------------ 1192| 0| case state::str8: goto do_str8; ------------------ | Branch (1192:9): [True: 0, False: 0] ------------------ 1193| 0| case state::sur1: goto do_sur1; ------------------ | Branch (1193:9): [True: 0, False: 0] ------------------ 1194| 0| case state::sur2: goto do_sur2; ------------------ | Branch (1194:9): [True: 0, False: 0] ------------------ 1195| 0| case state::sur3: goto do_sur3; ------------------ | Branch (1195:9): [True: 0, False: 0] ------------------ 1196| 0| case state::sur4: goto do_sur4; ------------------ | Branch (1196:9): [True: 0, False: 0] ------------------ 1197| 0| case state::sur5: goto do_sur5; ------------------ | Branch (1197:9): [True: 0, False: 0] ------------------ 1198| 0| case state::sur6: goto do_sur6; ------------------ | Branch (1198:9): [True: 0, False: 0] ------------------ 1199| 0| } 1200| 0| } 1201| | // Unescaped JSON is never larger than its escaped version. 1202| | // To efficiently process only what will fit in the temporary buffer, 1203| | // the size of the input stream is temporarily "clipped" to the size 1204| | // of the temporary buffer. 1205| | // handle escaped character 1206| 15.5k| BOOST_ASSERT(*cs == '\\'); ------------------ | | 60| 15.5k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 1207| 15.5k| ++cs; 1208| 2.92M|do_str3: 1209| 2.92M| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 2.92M|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 933, False: 2.92M] | | ------------------ ------------------ 1210| 933| { 1211| 933| if(BOOST_JSON_LIKELY(! temp.empty())) ------------------ | | 171| 933|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 891, False: 42] | | ------------------ ------------------ 1212| 891| { 1213| 891| BOOST_ASSERT(total <= max_size); ------------------ | | 60| 891|# define BOOST_ASSERT(expr) assert(expr) ------------------ 1214| 891| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 891|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 891] | | ------------------ ------------------ 1215| 891| temp.size() > max_size - total)) 1216| 0| { 1217| 0| BOOST_STATIC_CONSTEXPR source_location loc 1218| 0| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1219| 0| return fail(cs.begin(), ev_too_large, &loc); 1220| 0| } 1221| 891| total += temp.size(); 1222| 891| { 1223| 891| bool r = is_key ------------------ | Branch (1223:26): [True: 131, False: 760] ------------------ 1224| 891| ? h_.on_key_part(temp.get(), total, ec_) 1225| 891| : h_.on_string_part(temp.get(), total, ec_); 1226| | 1227| 891| if(BOOST_JSON_UNLIKELY(!r)) ------------------ | | 179| 891|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 891] | | ------------------ ------------------ 1228| 0| { 1229| 0| return fail(cs.begin()); 1230| 0| } 1231| 891| } 1232| 891| temp.clear(); 1233| 891| } 1234| 933| cs.clip(temp.max_size()); 1235| 933| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 933|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 88, False: 845] | | ------------------ ------------------ 1236| 88| return maybe_suspend(cs.begin(), state::str3, total); 1237| 933| } 1238| 2.92M| switch(*cs) 1239| 2.92M| { 1240| 23| default: ------------------ | Branch (1240:5): [True: 23, False: 2.92M] ------------------ 1241| 23| { 1242| 23| BOOST_STATIC_CONSTEXPR source_location loc 1243| 23| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 23|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1244| 23| return fail(cs.begin(), error::syntax, &loc); 1245| 0| } 1246| 2.74k| case '\x22': // '"' ------------------ | Branch (1246:5): [True: 2.74k, False: 2.92M] ------------------ 1247| 2.74k| temp.push_back('\x22'); 1248| 2.74k| ++cs; 1249| 2.74k| break; 1250| 1.85M| case '\\': ------------------ | Branch (1250:5): [True: 1.85M, False: 1.07M] ------------------ 1251| 1.85M| temp.push_back('\\'); 1252| 1.85M| ++cs; 1253| 1.85M| break; 1254| 346| case '/': ------------------ | Branch (1254:5): [True: 346, False: 2.92M] ------------------ 1255| 346| temp.push_back('/'); 1256| 346| ++cs; 1257| 346| break; 1258| 3.47k| case 'b': ------------------ | Branch (1258:5): [True: 3.47k, False: 2.92M] ------------------ 1259| 3.47k| temp.push_back('\x08'); 1260| 3.47k| ++cs; 1261| 3.47k| break; 1262| 18.7k| case 'f': ------------------ | Branch (1262:5): [True: 18.7k, False: 2.90M] ------------------ 1263| 18.7k| temp.push_back('\x0c'); 1264| 18.7k| ++cs; 1265| 18.7k| break; 1266| 14.1k| case 'n': ------------------ | Branch (1266:5): [True: 14.1k, False: 2.91M] ------------------ 1267| 14.1k| temp.push_back('\x0a'); 1268| 14.1k| ++cs; 1269| 14.1k| break; 1270| 1.15k| case 'r': ------------------ | Branch (1270:5): [True: 1.15k, False: 2.92M] ------------------ 1271| 1.15k| temp.push_back('\x0d'); 1272| 1.15k| ++cs; 1273| 1.15k| break; 1274| 7.95k| case 't': ------------------ | Branch (1274:5): [True: 7.95k, False: 2.92M] ------------------ 1275| 7.95k| temp.push_back('\x09'); 1276| 7.95k| ++cs; 1277| 7.95k| break; 1278| 1.02M| case 'u': ------------------ | Branch (1278:5): [True: 1.02M, False: 1.90M] ------------------ 1279| | // utf16 escape 1280| | // 1281| | // fast path only when the buffer 1282| | // is large enough for 2 surrogates 1283| 1.02M| if(BOOST_JSON_LIKELY(cs.remain() > 10)) ------------------ | | 171| 1.02M|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 1.02M, False: 2.77k] | | ------------------ ------------------ 1284| 1.02M| { 1285| | // KRYSTIAN TODO: this could be done 1286| | // with fewer instructions 1287| 1.02M| digit = detail::load_little_endian<4>( 1288| 1.02M| cs.begin() + 1); 1289| 1.02M| int d4 = detail::hex_digit(static_cast< 1290| 1.02M| unsigned char>(digit >> 24)); 1291| 1.02M| int d3 = detail::hex_digit(static_cast< 1292| 1.02M| unsigned char>(digit >> 16)); 1293| 1.02M| int d2 = detail::hex_digit(static_cast< 1294| 1.02M| unsigned char>(digit >> 8)); 1295| 1.02M| int d1 = detail::hex_digit(static_cast< 1296| 1.02M| unsigned char>(digit)); 1297| 1.02M| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 1.02M|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 72, False: 1.02M] | | ------------------ ------------------ 1298| 1.02M| (d1 | d2 | d3 | d4) == -1)) 1299| 72| { 1300| 72| if(d1 != -1) ------------------ | Branch (1300:20): [True: 38, False: 34] ------------------ 1301| 38| ++cs; 1302| 72| if(d2 != -1) ------------------ | Branch (1302:20): [True: 24, False: 48] ------------------ 1303| 24| ++cs; 1304| 72| if(d3 != -1) ------------------ | Branch (1304:20): [True: 33, False: 39] ------------------ 1305| 33| ++cs; 1306| 72| BOOST_STATIC_CONSTEXPR source_location loc 1307| 72| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 72|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1308| 72| return fail(cs.begin(), error::expected_hex_digit, &loc); 1309| 72| } 1310| | // 32 bit unicode scalar value 1311| 1.02M| unsigned const u1 = 1312| 1.02M| (d1 << 12) + (d2 << 8) + 1313| 1.02M| (d3 << 4) + d4; 1314| | // valid unicode scalar values are 1315| | // [0, D7FF] and [E000, 10FFFF] 1316| | // values within this range are valid utf-8 1317| | // code points and invalid leading surrogates. 1318| 1.02M| if(BOOST_JSON_LIKELY( ------------------ | | 171| 1.27M|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 922k, False: 100k] | | | Branch (171:52): [True: 768k, False: 254k] | | | Branch (171:52): [True: 153k, False: 100k] | | ------------------ ------------------ 1319| 1.02M| u1 < 0xd800 || u1 > 0xdfff)) 1320| 922k| { 1321| 922k| cs += 5; 1322| 922k| temp.append_utf8(u1); 1323| 922k| break; 1324| 922k| } 1325| 100k| if(BOOST_JSON_UNLIKELY(u1 > 0xdbff)) ------------------ | | 179| 100k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 14, False: 100k] | | ------------------ ------------------ 1326| 14| { 1327| 14| BOOST_STATIC_CONSTEXPR source_location loc 1328| 14| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 14|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1329| 14| return fail(cs.begin(), error::illegal_leading_surrogate, 1330| 14| &loc); 1331| 14| } 1332| 100k| cs += 5; 1333| | // KRYSTIAN TODO: this can be a two byte load 1334| | // and a single comparison. We lose error information, 1335| | // but it's faster. 1336| 100k| if(BOOST_JSON_UNLIKELY(*cs != '\\')) ------------------ | | 179| 100k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 5, False: 100k] | | ------------------ ------------------ 1337| 5| { 1338| 5| BOOST_STATIC_CONSTEXPR source_location loc 1339| 5| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 5|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1340| 5| return fail(cs.begin(), error::syntax, &loc); 1341| 5| } 1342| 100k| ++cs; 1343| 100k| if(BOOST_JSON_UNLIKELY(*cs != 'u')) ------------------ | | 179| 100k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 12, False: 100k] | | ------------------ ------------------ 1344| 12| { 1345| 12| BOOST_STATIC_CONSTEXPR source_location loc 1346| 12| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 12|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1347| 12| return fail(cs.begin(), error::syntax, &loc); 1348| 12| } 1349| 100k| ++cs; 1350| 100k| digit = detail::load_little_endian<4>(cs.begin()); 1351| 100k| d4 = detail::hex_digit(static_cast< 1352| 100k| unsigned char>(digit >> 24)); 1353| 100k| d3 = detail::hex_digit(static_cast< 1354| 100k| unsigned char>(digit >> 16)); 1355| 100k| d2 = detail::hex_digit(static_cast< 1356| 100k| unsigned char>(digit >> 8)); 1357| 100k| d1 = detail::hex_digit(static_cast< 1358| 100k| unsigned char>(digit)); 1359| 100k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 100k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 56, False: 100k] | | ------------------ ------------------ 1360| 100k| (d1 | d2 | d3 | d4) == -1)) 1361| 56| { 1362| 56| if(d1 != -1) ------------------ | Branch (1362:20): [True: 24, False: 32] ------------------ 1363| 24| ++cs; 1364| 56| if(d2 != -1) ------------------ | Branch (1364:20): [True: 25, False: 31] ------------------ 1365| 25| ++cs; 1366| 56| if(d3 != -1) ------------------ | Branch (1366:20): [True: 23, False: 33] ------------------ 1367| 23| ++cs; 1368| 56| BOOST_STATIC_CONSTEXPR source_location loc 1369| 56| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 56|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1370| 56| return fail(cs.begin(), error::expected_hex_digit, &loc); 1371| 56| } 1372| 100k| unsigned const u2 = 1373| 100k| (d1 << 12) + (d2 << 8) + 1374| 100k| (d3 << 4) + d4; 1375| | // valid trailing surrogates are [DC00, DFFF] 1376| 100k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 200k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 34, False: 100k] | | | Branch (179:54): [True: 25, False: 100k] | | | Branch (179:54): [True: 9, False: 100k] | | ------------------ ------------------ 1377| 100k| u2 < 0xdc00 || u2 > 0xdfff)) 1378| 34| { 1379| 34| BOOST_STATIC_CONSTEXPR source_location loc 1380| 34| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 34|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1381| 34| return fail(cs.begin(), error::illegal_trailing_surrogate, 1382| 34| &loc); 1383| 34| } 1384| 100k| cs += 4; 1385| 100k| unsigned cp = 1386| 100k| ((u1 - 0xd800) << 10) + 1387| 100k| ((u2 - 0xdc00)) + 1388| 100k| 0x10000; 1389| | // utf-16 surrogate pair 1390| 100k| temp.append_utf8(cp); 1391| 100k| break; 1392| 100k| } 1393| | // flush 1394| 2.77k| if(BOOST_JSON_LIKELY(! temp.empty())) ------------------ | | 171| 2.77k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 2.51k, False: 256] | | ------------------ ------------------ 1395| 2.51k| { 1396| 2.51k| BOOST_ASSERT(total <= max_size); ------------------ | | 60| 2.51k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 1397| 2.51k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 2.51k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 2.51k] | | ------------------ ------------------ 1398| 2.51k| temp.size() > max_size - total)) 1399| 0| { 1400| 0| BOOST_STATIC_CONSTEXPR source_location loc 1401| 0| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1402| 0| return fail(cs.begin(), ev_too_large, &loc); 1403| 0| } 1404| 2.51k| total += temp.size(); 1405| 2.51k| { 1406| 2.51k| bool r = is_key ------------------ | Branch (1406:26): [True: 633, False: 1.88k] ------------------ 1407| 2.51k| ? h_.on_key_part(temp.get(), total, ec_) 1408| 2.51k| : h_.on_string_part(temp.get(), total, ec_); 1409| | 1410| 2.51k| if(BOOST_JSON_UNLIKELY(!r)) ------------------ | | 179| 2.51k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 2.51k] | | ------------------ ------------------ 1411| 0| { 1412| 0| return fail(cs.begin()); 1413| 0| } 1414| 2.51k| } 1415| 2.51k| temp.clear(); 1416| 2.51k| cs.clip(temp.max_size()); 1417| 2.51k| } 1418| 2.77k| ++cs; 1419| | // utf-16 escape 1420| 2.77k|do_str4: 1421| 2.77k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 2.77k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 19, False: 2.75k] | | ------------------ ------------------ 1422| 19| return maybe_suspend(cs.begin(), state::str4, total); 1423| 2.75k| digit = detail::hex_digit(*cs); 1424| 2.75k| if(BOOST_JSON_UNLIKELY(digit == -1)) ------------------ | | 179| 2.75k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 15, False: 2.73k] | | ------------------ ------------------ 1425| 15| { 1426| 15| BOOST_STATIC_CONSTEXPR source_location loc 1427| 15| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 15|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1428| 15| return fail(cs.begin(), error::expected_hex_digit, &loc); 1429| 15| } 1430| 2.73k| ++cs; 1431| 2.73k| u1_ = digit << 12; 1432| 2.73k|do_str5: 1433| 2.73k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 2.73k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 19, False: 2.71k] | | ------------------ ------------------ 1434| 19| return maybe_suspend(cs.begin(), state::str5, total); 1435| 2.71k| digit = detail::hex_digit(*cs); 1436| 2.71k| if(BOOST_JSON_UNLIKELY(digit == -1)) ------------------ | | 179| 2.71k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 19, False: 2.69k] | | ------------------ ------------------ 1437| 19| { 1438| 19| BOOST_STATIC_CONSTEXPR source_location loc 1439| 19| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 19|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1440| 19| return fail(cs.begin(), error::expected_hex_digit, &loc); 1441| 19| } 1442| 2.69k| ++cs; 1443| 2.69k| u1_ += digit << 8; 1444| 2.69k|do_str6: 1445| 2.69k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 2.69k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 13, False: 2.68k] | | ------------------ ------------------ 1446| 13| return maybe_suspend(cs.begin(), state::str6, total); 1447| 2.68k| digit = detail::hex_digit(*cs); 1448| 2.68k| if(BOOST_JSON_UNLIKELY(digit == -1)) ------------------ | | 179| 2.68k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 18, False: 2.66k] | | ------------------ ------------------ 1449| 18| { 1450| 18| BOOST_STATIC_CONSTEXPR source_location loc 1451| 18| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 18|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1452| 18| return fail(cs.begin(), error::expected_hex_digit, &loc); 1453| 18| } 1454| 2.66k| ++cs; 1455| 2.66k| u1_ += digit << 4; 1456| 2.66k|do_str7: 1457| 2.66k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 2.66k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 26, False: 2.64k] | | ------------------ ------------------ 1458| 26| return maybe_suspend(cs.begin(), state::str7, total); 1459| 2.64k| digit = detail::hex_digit(*cs); 1460| 2.64k| if(BOOST_JSON_UNLIKELY(digit == -1)) ------------------ | | 179| 2.64k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 13, False: 2.62k] | | ------------------ ------------------ 1461| 13| { 1462| 13| BOOST_STATIC_CONSTEXPR source_location loc 1463| 13| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 13|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1464| 13| return fail(cs.begin(), error::expected_hex_digit, &loc); 1465| 13| } 1466| 2.62k| ++cs; 1467| 2.62k| u1_ += digit; 1468| 2.62k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 3.84k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 1.69k, False: 930] | | | Branch (171:52): [True: 1.40k, False: 1.22k] | | | Branch (171:52): [True: 290, False: 930] | | ------------------ ------------------ 1469| 2.62k| u1_ < 0xd800 || u1_ > 0xdfff)) 1470| 1.69k| { 1471| 1.69k| BOOST_ASSERT(temp.empty()); ------------------ | | 60| 1.69k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 1472| | // utf-8 codepoint 1473| 1.69k| temp.append_utf8(u1_); 1474| 1.69k| break; 1475| 1.69k| } 1476| 930| if(BOOST_JSON_UNLIKELY(u1_ > 0xdbff)) ------------------ | | 179| 930|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 9, False: 921] | | ------------------ ------------------ 1477| 9| { 1478| 9| BOOST_STATIC_CONSTEXPR source_location loc 1479| 9| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 9|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1480| 9| return fail(cs.begin(), error::illegal_trailing_surrogate, &loc); 1481| 9| } 1482| 921|do_sur1: 1483| 921| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 921|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 7, False: 914] | | ------------------ ------------------ 1484| 7| return maybe_suspend(cs.begin(), state::sur1, total); 1485| 914| if(BOOST_JSON_UNLIKELY(*cs != '\\')) ------------------ | | 179| 914|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 13, False: 901] | | ------------------ ------------------ 1486| 13| { 1487| 13| BOOST_STATIC_CONSTEXPR source_location loc 1488| 13| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 13|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1489| 13| return fail(cs.begin(), error::syntax, &loc); 1490| 13| } 1491| 901| ++cs; 1492| 901|do_sur2: 1493| 901| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 901|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 1, False: 900] | | ------------------ ------------------ 1494| 1| return maybe_suspend(cs.begin(), state::sur2, total); 1495| 900| if(BOOST_JSON_UNLIKELY(*cs != 'u')) ------------------ | | 179| 900|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 11, False: 889] | | ------------------ ------------------ 1496| 11| { 1497| 11| BOOST_STATIC_CONSTEXPR source_location loc 1498| 11| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 11|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1499| 11| return fail(cs.begin(), error::syntax, &loc); 1500| 11| } 1501| 889| ++cs; 1502| 889|do_sur3: 1503| 889| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 889|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 2, False: 887] | | ------------------ ------------------ 1504| 2| return maybe_suspend(cs.begin(), state::sur3, total); 1505| 887| digit = detail::hex_digit(*cs); 1506| 887| if(BOOST_JSON_UNLIKELY(digit == -1)) ------------------ | | 179| 887|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 16, False: 871] | | ------------------ ------------------ 1507| 16| { 1508| 16| BOOST_STATIC_CONSTEXPR source_location loc 1509| 16| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 16|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1510| 16| return fail(cs.begin(), error::expected_hex_digit, &loc); 1511| 16| } 1512| 871| ++cs; 1513| 871| u2_ = digit << 12; 1514| 871|do_sur4: 1515| 871| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 871|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 11, False: 860] | | ------------------ ------------------ 1516| 11| return maybe_suspend(cs.begin(), state::sur4, total); 1517| 860| digit = detail::hex_digit(*cs); 1518| 860| if(BOOST_JSON_UNLIKELY(digit == -1)) ------------------ | | 179| 860|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 15, False: 845] | | ------------------ ------------------ 1519| 15| { 1520| 15| BOOST_STATIC_CONSTEXPR source_location loc 1521| 15| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 15|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1522| 15| return fail(cs.begin(), error::expected_hex_digit, &loc); 1523| 15| } 1524| 845| ++cs; 1525| 845| u2_ += digit << 8; 1526| 845|do_sur5: 1527| 845| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 845|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 9, False: 836] | | ------------------ ------------------ 1528| 9| return maybe_suspend(cs.begin(), state::sur5, total); 1529| 836| digit = detail::hex_digit(*cs); 1530| 836| if(BOOST_JSON_UNLIKELY(digit == -1)) ------------------ | | 179| 836|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 17, False: 819] | | ------------------ ------------------ 1531| 17| { 1532| 17| BOOST_STATIC_CONSTEXPR source_location loc 1533| 17| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 17|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1534| 17| return fail(cs.begin(), error::expected_hex_digit, &loc); 1535| 17| } 1536| 819| ++cs; 1537| 819| u2_ += digit << 4; 1538| 819|do_sur6: 1539| 819| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 819|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 22, False: 797] | | ------------------ ------------------ 1540| 22| return maybe_suspend(cs.begin(), state::sur6, total); 1541| 797| digit = detail::hex_digit(*cs); 1542| 797| if(BOOST_JSON_UNLIKELY(digit == -1)) ------------------ | | 179| 797|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 3, False: 794] | | ------------------ ------------------ 1543| 3| { 1544| 3| BOOST_STATIC_CONSTEXPR source_location loc 1545| 3| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 3|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1546| 3| return fail(cs.begin(), error::expected_hex_digit, &loc); 1547| 3| } 1548| 794| ++cs; 1549| 794| u2_ += digit; 1550| 794| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 1.57k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 24, False: 770] | | | Branch (179:54): [True: 14, False: 780] | | | Branch (179:54): [True: 10, False: 770] | | ------------------ ------------------ 1551| 794| u2_ < 0xdc00 || u2_ > 0xdfff)) 1552| 24| { 1553| 24| BOOST_STATIC_CONSTEXPR source_location loc 1554| 24| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 24|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1555| 24| return fail(cs.begin(), error::expected_hex_digit, &loc); 1556| 24| } 1557| 770| unsigned cp = 1558| 770| ((u1_ - 0xd800) << 10) + 1559| 770| ((u2_ - 0xdc00)) + 1560| 770| 0x10000; 1561| 770| BOOST_ASSERT(temp.empty()); ------------------ | | 60| 770|# define BOOST_ASSERT(expr) assert(expr) ------------------ 1562| | // utf-16 surrogate pair 1563| 770| temp.append_utf8(cp); 1564| 2.92M| } 1565| 2.92M|do_str2: 1566| | // KRYSTIAN TODO: we can append the characters 1567| | // all at once instead of one at a time 1568| 2.92M| for(;;) 1569| 21.6M| { 1570| 21.6M| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 21.6M|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 3.67k, False: 21.6M] | | ------------------ ------------------ 1571| 3.67k| { 1572| | // flush 1573| 3.67k| if(BOOST_JSON_LIKELY(! temp.empty())) ------------------ | | 171| 3.67k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 3.67k, False: 0] | | ------------------ ------------------ 1574| 3.67k| { 1575| 3.67k| BOOST_ASSERT(total <= max_size); ------------------ | | 60| 3.67k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 1576| 3.67k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 3.67k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 3.67k] | | ------------------ ------------------ 1577| 3.67k| temp.size() > max_size - total)) 1578| 0| { 1579| 0| BOOST_STATIC_CONSTEXPR source_location loc 1580| 0| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1581| 0| return fail(cs.begin(), ev_too_large, &loc); 1582| 0| } 1583| 3.67k| total += temp.size(); 1584| 3.67k| { 1585| 3.67k| bool r = is_key ------------------ | Branch (1585:30): [True: 352, False: 3.31k] ------------------ 1586| 3.67k| ? h_.on_key_part(temp.get(), total, ec_) 1587| 3.67k| : h_.on_string_part(temp.get(), total, ec_); 1588| | 1589| 3.67k| if(BOOST_JSON_UNLIKELY(!r)) ------------------ | | 179| 3.67k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 3.67k] | | ------------------ ------------------ 1590| 0| { 1591| 0| return fail(cs.begin()); 1592| 0| } 1593| 3.67k| } 1594| 3.67k| temp.clear(); 1595| 3.67k| } 1596| 3.67k| cs.clip(temp.max_size()); 1597| 3.67k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 3.67k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 351, False: 3.32k] | | ------------------ ------------------ 1598| 351| return maybe_suspend(cs.begin(), state::str2, total); 1599| 3.67k| } 1600| 21.6M| c = *cs; 1601| 21.6M| if(BOOST_JSON_LIKELY(c == '\x22')) // '"' ------------------ | | 171| 21.6M|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 14.3k, False: 21.6M] | | ------------------ ------------------ 1602| 14.3k| { 1603| 14.3k| BOOST_ASSERT(total <= max_size); ------------------ | | 60| 14.3k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 1604| 14.3k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 14.3k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 14.3k] | | ------------------ ------------------ 1605| 14.3k| temp.size() > max_size - total)) 1606| 0| { 1607| 0| BOOST_STATIC_CONSTEXPR source_location loc 1608| 0| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1609| 0| return fail(cs.begin(), ev_too_large, &loc); 1610| 0| } 1611| 14.3k| total += temp.size(); 1612| 14.3k| { 1613| 14.3k| bool r = is_key ------------------ | Branch (1613:26): [True: 1.25k, False: 13.1k] ------------------ 1614| 14.3k| ? h_.on_key(temp.get(), total, ec_) 1615| 14.3k| : h_.on_string(temp.get(), total, ec_); 1616| | 1617| 14.3k| if(BOOST_JSON_UNLIKELY(!r)) ------------------ | | 179| 14.3k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 14.3k] | | ------------------ ------------------ 1618| 0| { 1619| 0| return fail(cs.begin()); 1620| 0| } 1621| 14.3k| } 1622| 14.3k| ++cs; 1623| 14.3k| return cs.begin(); 1624| 14.3k| } 1625| 21.6M| else if((c & 0x80) && !allow_bad_utf8) ------------------ | Branch (1625:17): [True: 229k, False: 21.3M] | Branch (1625:31): [True: 229k, False: 0] ------------------ 1626| 229k| { 1627| 229k| seq_.save(cs.begin(), cs.remain()); 1628| 229k| if(BOOST_JSON_UNLIKELY(! seq_.complete())) ------------------ | | 179| 229k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 673, False: 228k] | | ------------------ ------------------ 1629| 673| { 1630| 673| if(BOOST_JSON_LIKELY(! temp.empty())) ------------------ | | 171| 673|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 670, False: 3] | | ------------------ ------------------ 1631| 670| { 1632| 670| BOOST_ASSERT(total <= max_size); ------------------ | | 60| 670|# define BOOST_ASSERT(expr) assert(expr) ------------------ 1633| 670| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 670|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 670] | | ------------------ ------------------ 1634| 670| temp.size() > max_size - total)) 1635| 0| { 1636| 0| BOOST_STATIC_CONSTEXPR source_location loc 1637| 0| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1638| 0| return fail(cs.begin(), ev_too_large, &loc); 1639| 0| } 1640| 670| total += temp.size(); 1641| 670| { 1642| 670| bool r = is_key ------------------ | Branch (1642:34): [True: 544, False: 126] ------------------ 1643| 670| ? h_.on_key_part(temp.get(), total, ec_) 1644| 670| : h_.on_string_part(temp.get(), total, ec_); 1645| | 1646| 670| if(BOOST_JSON_UNLIKELY(!r)) ------------------ | | 179| 670|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 670] | | ------------------ ------------------ 1647| 0| { 1648| 0| return fail(cs.begin()); 1649| 0| } 1650| 670| } 1651| 670| temp.clear(); 1652| 670| } 1653| 673| cs = cs.end(); 1654| | // ensure there is room for the saved byte sequence 1655| 673| cs.clip(temp.max_size() - seq_.length()); 1656| 673| goto do_str8; 1657| 673| } 1658| 228k| if(BOOST_JSON_UNLIKELY(! seq_.valid())) ------------------ | | 179| 228k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 171, False: 228k] | | ------------------ ------------------ 1659| 171| { 1660| 171| BOOST_STATIC_CONSTEXPR source_location loc 1661| 171| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 171|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1662| 171| return fail(cs.begin(), error::syntax, &loc); 1663| 171| } 1664| 228k| temp.append(seq_.data(), seq_.length()); 1665| 228k| cs += seq_.length(); 1666| 228k| continue; 1667| 228k| } 1668| 21.3M| else if(BOOST_JSON_LIKELY(c == '\\')) ------------------ | | 171| 21.3M|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 2.91M, False: 18.4M] | | ------------------ ------------------ 1669| 2.91M| { 1670| 2.91M| ++cs; 1671| 2.91M| goto do_str3; 1672| 2.91M| } 1673| 18.4M| else if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 18.4M|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 37, False: 18.4M] | | ------------------ ------------------ 1674| 18.4M| detail::is_control(c))) 1675| 37| { 1676| 37| BOOST_STATIC_CONSTEXPR source_location loc 1677| 37| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 37|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1678| 37| return fail(cs.begin(), error::syntax, &loc); 1679| 37| } 1680| 18.4M| temp.push_back(c); 1681| 18.4M| ++cs; 1682| 18.4M| } 1683| 673|do_str8: 1684| 673| uint8_t needed = seq_.needed(); 1685| 673| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 673|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 32, False: 641] | | ------------------ ------------------ 1686| 673| ! seq_.append(cs.begin(), cs.remain()))) 1687| 32| return maybe_suspend(cs.end(), state::str8, total); 1688| 641| if(BOOST_JSON_UNLIKELY(! seq_.valid())) ------------------ | | 179| 641|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 9, False: 632] | | ------------------ ------------------ 1689| 9| { 1690| 9| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; ------------------ | | 170| 9|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1691| 9| return fail(cs.begin(), error::syntax, &loc); 1692| 9| } 1693| 632| temp.append(seq_.data(), seq_.length()); 1694| 632| cs += needed; 1695| 632| goto do_str2; 1696| 641|} _ZN5boost4json6detail9hex_digitEh: 176| 4.50M|{ 177| | // by Peter Dimov 178| 4.50M| if( c >= '0' && c <= '9' ) ------------------ | Branch (178:9): [True: 4.50M, False: 151] | Branch (178:21): [True: 2.04M, False: 2.46M] ------------------ 179| 2.04M| return c - '0'; 180| 2.46M| c &= ~0x20; 181| 2.46M| if( c >= 'A' && c <= 'F' ) ------------------ | Branch (181:9): [True: 2.46M, False: 181] | Branch (181:21): [True: 2.46M, False: 246] ------------------ 182| 2.46M| return 10 + c - 'A'; 183| 427| return -1; 184| 2.46M|} _ZN5boost4json6detail10is_controlEc: 169| 18.4M|{ 170| 18.4M| return static_cast(c) < 32; 171| 18.4M|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE11parse_arrayILb1ELb0EEEPKcS7_NSt3__117integral_constantIbXT_EEENS9_IbXT0_EEEbb: 1881| 4.61k|{ 1882| 4.61k| detail::const_stream_wrapper cs(p, end_); 1883| 4.61k| std::size_t size; 1884| 4.61k| if(! stack_empty && ! st_.empty()) ------------------ | Branch (1884:8): [Folded - Ignored] | Branch (1884:25): [True: 0, False: 0] ------------------ 1885| 0| { 1886| | // resume 1887| 0| state st; 1888| 0| st_.pop(st); 1889| 0| st_.pop(size); 1890| 0| switch(st) 1891| 0| { 1892| 0| default: BOOST_JSON_UNREACHABLE(); ------------------ | | 189| 0|# define BOOST_JSON_UNREACHABLE() __builtin_unreachable() ------------------ | Branch (1892:9): [True: 0, False: 0] ------------------ 1893| 0| case state::arr1: goto do_arr1; ------------------ | Branch (1893:9): [True: 0, False: 0] ------------------ 1894| 0| case state::arr2: goto do_arr2; ------------------ | Branch (1894:9): [True: 0, False: 0] ------------------ 1895| 0| case state::arr3: goto do_arr3; ------------------ | Branch (1895:9): [True: 0, False: 0] ------------------ 1896| 0| case state::arr4: goto do_arr4; ------------------ | Branch (1896:9): [True: 0, False: 0] ------------------ 1897| 0| case state::arr5: goto do_arr5; ------------------ | Branch (1897:9): [True: 0, False: 0] ------------------ 1898| 0| case state::arr6: goto do_arr6; ------------------ | Branch (1898:9): [True: 0, False: 0] ------------------ 1899| 0| } 1900| 0| } 1901| 4.61k| BOOST_ASSERT(*cs == '['); ------------------ | | 60| 4.61k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 1902| 4.61k| size = 0; 1903| 4.61k| if(BOOST_JSON_UNLIKELY(! depth_)) ------------------ | | 179| 4.61k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 5, False: 4.60k] | | ------------------ ------------------ 1904| 5| { 1905| 5| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; ------------------ | | 170| 5|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1906| 5| return fail(cs.begin(), error::too_deep, &loc); 1907| 5| } 1908| 4.60k| --depth_; 1909| 4.60k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 4.60k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 4.60k] | | ------------------ ------------------ 1910| 4.60k| ! h_.on_array_begin(ec_))) 1911| 0| return fail(cs.begin()); 1912| 4.60k| ++cs; 1913| | // array: 1914| | // '[' *ws ']' 1915| | // '[' *ws value *ws *[ ',' *ws value *ws ] ']' 1916| 4.60k|do_arr1: 1917| 4.60k| cs = detail::count_whitespace(cs.begin(), cs.end()); 1918| 4.60k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 4.60k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 36, False: 4.56k] | | ------------------ ------------------ 1919| 36| return maybe_suspend(cs.begin(), state::arr1, size); 1920| 4.56k| if(BOOST_JSON_LIKELY(*cs != ']')) ------------------ | | 171| 4.56k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 3.87k, False: 696] | | ------------------ ------------------ 1921| 3.87k| { 1922| 1.58M|loop: 1923| 1.58M| if(allow_comments && *cs == '/') ------------------ | Branch (1923:12): [Folded - Ignored] | Branch (1923:30): [True: 0, False: 0] ------------------ 1924| 0| { 1925| 0|do_arr2: 1926| 0| cs = parse_comment(cs.begin(), stack_empty, std::false_type()); 1927| 0| if(BOOST_JSON_UNLIKELY(incomplete(cs))) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 1928| 0| return suspend_or_fail(state::arr2, size); 1929| 0| goto do_arr1; 1930| 0| } 1931| 1.58M| if(BOOST_JSON_UNLIKELY(++size > ------------------ | | 179| 1.58M|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 1.58M] | | ------------------ ------------------ 1932| 1.58M| Handler::max_array_size)) 1933| 0| { 1934| 0| BOOST_STATIC_CONSTEXPR source_location loc 1935| 0| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1936| 0| return fail(cs.begin(), error::array_too_large, &loc); 1937| 0| } 1938| 1.58M|do_arr3: 1939| | // array is not empty, value required 1940| 1.58M| cs = parse_value(cs.begin(), stack_empty, allow_comments, allow_trailing, allow_bad_utf8); 1941| 1.58M| if(BOOST_JSON_UNLIKELY(incomplete(cs))) ------------------ | | 179| 1.58M|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 1.60k, False: 1.58M] | | ------------------ ------------------ 1942| 1.60k| return suspend_or_fail(state::arr3, size); 1943| 1.58M|do_arr4: 1944| 1.58M| cs = detail::count_whitespace(cs.begin(), cs.end()); 1945| 1.58M| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 1.58M|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 548, False: 1.58M] | | ------------------ ------------------ 1946| 548| return maybe_suspend(cs.begin(), state::arr4, size); 1947| 1.58M| if(BOOST_JSON_LIKELY(*cs == ',')) ------------------ | | 171| 1.58M|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 1.58M, False: 1.64k] | | ------------------ ------------------ 1948| 1.58M| { 1949| 1.58M| ++cs; 1950| 1.58M|do_arr5: 1951| 1.58M| cs = detail::count_whitespace(cs.begin(), cs.end()); 1952| 1.58M| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 1.58M|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 80, False: 1.58M] | | ------------------ ------------------ 1953| 80| return maybe_suspend(cs.begin(), state::arr5, size); 1954| | // loop for next element 1955| 1.58M| if(! allow_trailing || *cs != ']') ------------------ | Branch (1955:16): [True: 1.58M, False: 0] | Branch (1955:36): [True: 0, False: 0] ------------------ 1956| 1.58M| goto loop; 1957| 1.58M| } 1958| 1.64k| else if(BOOST_JSON_UNLIKELY(*cs != ']')) ------------------ | | 179| 1.64k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 353, False: 1.28k] | | ------------------ ------------------ 1959| 353| { 1960| 353| if(allow_comments && *cs == '/') ------------------ | Branch (1960:16): [Folded - Ignored] | Branch (1960:34): [True: 0, False: 0] ------------------ 1961| 0| { 1962| 0|do_arr6: 1963| 0| cs = parse_comment(cs.begin(), stack_empty, std::false_type()); 1964| 0| if(BOOST_JSON_UNLIKELY(incomplete(cs))) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 1965| 0| return suspend_or_fail(state::arr6, size); 1966| 0| goto do_arr4; 1967| 0| } 1968| 353| BOOST_STATIC_CONSTEXPR source_location loc 1969| 353| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 353|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1970| 353| return fail(cs.begin(), error::syntax, &loc); 1971| 353| } 1972| | // got closing bracket; fall through 1973| 1.58M| } 1974| 1.98k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 1.98k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 1.98k] | | ------------------ ------------------ 1975| 1.98k| ! h_.on_array_end(size, ec_))) 1976| 0| return fail(cs.begin()); 1977| 1.98k| ++depth_; 1978| 1.98k| ++cs; 1979| 1.98k| return cs.begin(); 1980| 1.98k|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE15suspend_or_failENS4_5stateEm: 265| 2.93k|{ 266| 2.93k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 4.60k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 0, False: 2.93k] | | | Branch (171:52): [True: 1.66k, False: 1.27k] | | | Branch (171:52): [True: 0, False: 1.66k] | | ------------------ ------------------ 267| 2.93k| ! ec_ && more_)) 268| 0| { 269| | // suspend 270| 0| reserve(); 271| 0| st_.push_unchecked(n); 272| 0| st_.push_unchecked(st); 273| 0| } 274| 2.93k| return sentinel(); 275| 2.93k|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE12parse_objectILb1ELb0EEEPKcS7_NSt3__117integral_constantIbXT_EEENS9_IbXT0_EEEbb: 1713| 14.3k|{ 1714| 14.3k| detail::const_stream_wrapper cs(p, end_); 1715| 14.3k| std::size_t size; 1716| 14.3k| if(! stack_empty && ! st_.empty()) ------------------ | Branch (1716:8): [Folded - Ignored] | Branch (1716:25): [True: 0, False: 0] ------------------ 1717| 0| { 1718| | // resume 1719| 0| state st; 1720| 0| st_.pop(st); 1721| 0| st_.pop(size); 1722| 0| switch(st) 1723| 0| { 1724| 0| default: BOOST_JSON_UNREACHABLE(); ------------------ | | 189| 0|# define BOOST_JSON_UNREACHABLE() __builtin_unreachable() ------------------ | Branch (1724:9): [True: 0, False: 0] ------------------ 1725| 0| case state::obj1: goto do_obj1; ------------------ | Branch (1725:9): [True: 0, False: 0] ------------------ 1726| 0| case state::obj2: goto do_obj2; ------------------ | Branch (1726:9): [True: 0, False: 0] ------------------ 1727| 0| case state::obj3: goto do_obj3; ------------------ | Branch (1727:9): [True: 0, False: 0] ------------------ 1728| 0| case state::obj4: goto do_obj4; ------------------ | Branch (1728:9): [True: 0, False: 0] ------------------ 1729| 0| case state::obj5: goto do_obj5; ------------------ | Branch (1729:9): [True: 0, False: 0] ------------------ 1730| 0| case state::obj6: goto do_obj6; ------------------ | Branch (1730:9): [True: 0, False: 0] ------------------ 1731| 0| case state::obj7: goto do_obj7; ------------------ | Branch (1731:9): [True: 0, False: 0] ------------------ 1732| 0| case state::obj8: goto do_obj8; ------------------ | Branch (1732:9): [True: 0, False: 0] ------------------ 1733| 0| case state::obj9: goto do_obj9; ------------------ | Branch (1733:9): [True: 0, False: 0] ------------------ 1734| 0| case state::obj10: goto do_obj10; ------------------ | Branch (1734:9): [True: 0, False: 0] ------------------ 1735| 0| case state::obj11: goto do_obj11; ------------------ | Branch (1735:9): [True: 0, False: 0] ------------------ 1736| 0| } 1737| 0| } 1738| 14.3k| BOOST_ASSERT(*cs == '{'); ------------------ | | 60| 14.3k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 1739| 14.3k| size = 0; 1740| 14.3k| if(BOOST_JSON_UNLIKELY(! depth_)) ------------------ | | 179| 14.3k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 5, False: 14.3k] | | ------------------ ------------------ 1741| 5| { 1742| 5| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; ------------------ | | 170| 5|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1743| 5| return fail(cs.begin(), error::too_deep, &loc); 1744| 5| } 1745| 14.3k| --depth_; 1746| 14.3k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 14.3k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 14.3k] | | ------------------ ------------------ 1747| 14.3k| ! h_.on_object_begin(ec_))) 1748| 0| return fail(cs.begin()); 1749| 14.3k| ++cs; 1750| | // object: 1751| | // '{' *ws '}' 1752| | // '{' *ws string *ws ':' *ws value *ws *[ ',' *ws string *ws ':' *ws value *ws ] '}' 1753| 14.3k|do_obj1: 1754| 14.3k| cs = detail::count_whitespace(cs.begin(), cs.end()); 1755| 14.3k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 14.3k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 38, False: 14.3k] | | ------------------ ------------------ 1756| 38| return maybe_suspend(cs.begin(), state::obj1, size); 1757| 14.3k| if(BOOST_JSON_LIKELY(*cs != '}')) ------------------ | | 171| 14.3k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 3.04k, False: 11.2k] | | ------------------ ------------------ 1758| 3.04k| { 1759| 3.04k| if(BOOST_JSON_UNLIKELY(*cs != '\x22')) ------------------ | | 179| 3.04k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 66, False: 2.98k] | | ------------------ ------------------ 1760| 66| { 1761| 66| if(allow_comments && *cs == '/') ------------------ | Branch (1761:16): [Folded - Ignored] | Branch (1761:34): [True: 0, False: 0] ------------------ 1762| 0| { 1763| 0|do_obj2: 1764| 0| cs = parse_comment(cs.begin(), stack_empty, std::false_type()); 1765| 0| if(BOOST_JSON_UNLIKELY(incomplete(cs))) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 1766| 0| return suspend_or_fail(state::obj2, size); 1767| 0| goto do_obj1; 1768| 0| } 1769| 66| BOOST_STATIC_CONSTEXPR source_location loc 1770| 66| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 66|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1771| 66| return fail(cs.begin(), error::syntax, &loc); 1772| 66| } 1773| 865k|loop: 1774| 865k| if(BOOST_JSON_UNLIKELY(++size > ------------------ | | 179| 865k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 865k] | | ------------------ ------------------ 1775| 865k| Handler::max_object_size)) 1776| 0| { 1777| 0| BOOST_STATIC_CONSTEXPR source_location loc 1778| 0| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1779| 0| return fail(cs.begin(), error::object_too_large, &loc); 1780| 0| } 1781| 865k|do_obj3: 1782| 865k| cs = parse_string(cs.begin(), stack_empty, std::true_type(), allow_bad_utf8); 1783| 865k| if(BOOST_JSON_UNLIKELY(incomplete(cs))) ------------------ | | 179| 865k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 331, False: 865k] | | ------------------ ------------------ 1784| 331| return suspend_or_fail(state::obj3, size); 1785| 865k|do_obj4: 1786| 865k| cs = detail::count_whitespace(cs.begin(), cs.end()); 1787| 865k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 865k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 58, False: 864k] | | ------------------ ------------------ 1788| 58| return maybe_suspend(cs.begin(), state::obj4, size); 1789| 864k| if(BOOST_JSON_UNLIKELY(*cs != ':')) ------------------ | | 179| 864k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 77, False: 864k] | | ------------------ ------------------ 1790| 77| { 1791| 77| if(allow_comments && *cs == '/') ------------------ | Branch (1791:16): [Folded - Ignored] | Branch (1791:34): [True: 0, False: 0] ------------------ 1792| 0| { 1793| 0|do_obj5: 1794| 0| cs = parse_comment(cs.begin(), stack_empty, std::false_type()); 1795| 0| if(BOOST_JSON_UNLIKELY(incomplete(cs))) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 1796| 0| return suspend_or_fail(state::obj5, size); 1797| 0| goto do_obj4; 1798| 0| } 1799| 77| BOOST_STATIC_CONSTEXPR source_location loc 1800| 77| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 77|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1801| 77| return fail(cs.begin(), error::syntax, &loc); 1802| 77| } 1803| 864k| ++cs; 1804| 864k|do_obj6: 1805| 864k| cs = detail::count_whitespace(cs.begin(), cs.end()); 1806| 864k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 864k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 32, False: 864k] | | ------------------ ------------------ 1807| 32| return maybe_suspend(cs.begin(), state::obj6, size); 1808| 864k|do_obj7: 1809| 864k| cs = parse_value(cs.begin(), stack_empty, allow_comments, allow_trailing, allow_bad_utf8); 1810| 864k| if(BOOST_JSON_UNLIKELY(incomplete(cs))) ------------------ | | 179| 864k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 1.00k, False: 863k] | | ------------------ ------------------ 1811| 1.00k| return suspend_or_fail(state::obj7, size); 1812| 863k|do_obj8: 1813| 863k| cs = detail::count_whitespace(cs.begin(), cs.end()); 1814| 863k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 863k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 31, False: 863k] | | ------------------ ------------------ 1815| 31| return maybe_suspend(cs.begin(), state::obj8, size); 1816| 863k| if(BOOST_JSON_LIKELY(*cs == ',')) ------------------ | | 171| 863k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 862k, False: 1.34k] | | ------------------ ------------------ 1817| 862k| { 1818| 862k| ++cs; 1819| 862k|do_obj9: 1820| 862k| cs = detail::count_whitespace(cs.begin(), cs.end()); 1821| 862k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 862k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 31, False: 862k] | | ------------------ ------------------ 1822| 31| return maybe_suspend(cs.begin(), state::obj9, size); 1823| | 1824| | // loop for next element 1825| 862k| if(BOOST_JSON_LIKELY(*cs == '\x22')) ------------------ | | 171| 862k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 862k, False: 69] | | ------------------ ------------------ 1826| 862k| goto loop; 1827| 69| if(! allow_trailing || *cs != '}') ------------------ | Branch (1827:16): [True: 69, False: 0] | Branch (1827:36): [True: 0, False: 0] ------------------ 1828| 69| { 1829| 69| if(allow_comments && *cs == '/') ------------------ | Branch (1829:20): [Folded - Ignored] | Branch (1829:38): [True: 0, False: 0] ------------------ 1830| 0| { 1831| 0|do_obj10: 1832| 0| cs = parse_comment(cs.begin(), stack_empty, std::false_type()); 1833| 0| if(BOOST_JSON_UNLIKELY(incomplete(cs))) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 1834| 0| return suspend_or_fail(state::obj10, size); 1835| 0| goto do_obj9; 1836| 0| } 1837| 69| BOOST_STATIC_CONSTEXPR source_location loc 1838| 69| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 69|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1839| 69| return fail(cs.begin(), error::syntax, &loc); 1840| 69| } 1841| 69| } 1842| 1.34k| else if(BOOST_JSON_UNLIKELY(*cs != '}')) ------------------ | | 179| 1.34k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 80, False: 1.26k] | | ------------------ ------------------ 1843| 80| { 1844| 80| if(allow_comments && *cs == '/') ------------------ | Branch (1844:16): [Folded - Ignored] | Branch (1844:34): [True: 0, False: 0] ------------------ 1845| 0| { 1846| 0|do_obj11: 1847| 0| cs = parse_comment(cs.begin(), stack_empty, std::false_type()); 1848| 0| if(BOOST_JSON_UNLIKELY(incomplete(cs))) ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 1849| 0| return suspend_or_fail(state::obj11, size); 1850| 0| goto do_obj8; 1851| 0| } 1852| 80| BOOST_STATIC_CONSTEXPR source_location loc 1853| 80| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 80|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1854| 80| return fail(cs.begin(), error::syntax, &loc); 1855| 80| } 1856| | // got closing brace, fall through 1857| 863k| } 1858| 12.5k| if(BOOST_JSON_UNLIKELY( ------------------ | | 179| 12.5k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 12.5k] | | ------------------ ------------------ 1859| 12.5k| ! h_.on_object_end(size, ec_))) 1860| 0| return fail(cs.begin()); 1861| 12.5k| ++depth_; 1862| 12.5k| ++cs; 1863| 12.5k| return cs.begin(); 1864| 12.5k|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE12parse_stringILb1ELb1EEEPKcS7_NSt3__117integral_constantIbXT_EEENS9_IbXT0_EEEb: 977| 865k|{ 978| 865k| if(! stack_empty && ! st_.empty()) ------------------ | Branch (978:8): [Folded - Ignored] | Branch (978:25): [True: 0, False: 0] ------------------ 979| 0| { 980| 0| state st; 981| 0| st_.peek(st); 982| 0| switch(st) 983| 0| { 984| 0| default: BOOST_JSON_UNREACHABLE(); ------------------ | | 189| 0|# define BOOST_JSON_UNREACHABLE() __builtin_unreachable() ------------------ | Branch (984:9): [True: 0, False: 0] ------------------ 985| 0| case state::str1: ------------------ | Branch (985:9): [True: 0, False: 0] ------------------ 986| 0| return parse_unescaped(p, stack_empty, is_key, allow_bad_utf8); 987| | 988| 0| case state::str2: case state::str3: ------------------ | Branch (988:9): [True: 0, False: 0] | Branch (988:27): [True: 0, False: 0] ------------------ 989| 0| case state::str4: case state::str5: ------------------ | Branch (989:9): [True: 0, False: 0] | Branch (989:27): [True: 0, False: 0] ------------------ 990| 0| case state::str6: case state::str7: ------------------ | Branch (990:9): [True: 0, False: 0] | Branch (990:27): [True: 0, False: 0] ------------------ 991| 0| case state::str8: ------------------ | Branch (991:9): [True: 0, False: 0] ------------------ 992| 0| case state::sur1: case state::sur2: ------------------ | Branch (992:9): [True: 0, False: 0] | Branch (992:27): [True: 0, False: 0] ------------------ 993| 0| case state::sur3: case state::sur4: ------------------ | Branch (993:9): [True: 0, False: 0] | Branch (993:27): [True: 0, False: 0] ------------------ 994| 0| case state::sur5: case state::sur6: ------------------ | Branch (994:9): [True: 0, False: 0] | Branch (994:27): [True: 0, False: 0] ------------------ 995| 0| return parse_escaped(p, 0, stack_empty, is_key, allow_bad_utf8); 996| 0| } 997| 0| } 998| | 999| 865k| return parse_unescaped(p, std::true_type(), is_key, allow_bad_utf8); 1000| 865k|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE15parse_unescapedILb1ELb1EEEPKcS7_NSt3__117integral_constantIbXT_EEENS9_IbXT0_EEEb: 1013| 865k|{ 1014| 865k| detail::const_stream_wrapper cs(p, end_); 1015| 865k| std::size_t total; 1016| 865k| if(stack_empty || st_.empty()) ------------------ | Branch (1016:8): [Folded - Ignored] | Branch (1016:23): [True: 0, False: 0] ------------------ 1017| 865k| { 1018| 865k| BOOST_ASSERT(*cs == '\x22'); // '"' ------------------ | | 60| 865k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 1019| 865k| ++cs; 1020| 865k| total = 0; 1021| 865k| } 1022| 0| else 1023| 0| { 1024| 0| state st; 1025| 0| st_.pop(st); 1026| 0| st_.pop(total); 1027| 0| } 1028| 865k| char const* start = cs.begin(); 1029| 865k| cs = allow_bad_utf8? ------------------ | Branch (1029:10): [True: 0, False: 865k] ------------------ 1030| 0| detail::count_valid(cs.begin(), cs.end()): 1031| 865k| detail::count_valid(cs.begin(), cs.end()); 1032| 865k| std::size_t size = cs.used(start); 1033| 865k| if(is_key) ------------------ | Branch (1033:8): [Folded - Ignored] ------------------ 1034| 865k| { 1035| 865k| BOOST_ASSERT(total <= Handler::max_key_size); ------------------ | | 60| 865k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 1036| 865k| if(BOOST_JSON_UNLIKELY(size > ------------------ | | 179| 865k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 865k] | | ------------------ ------------------ 1037| 865k| Handler::max_key_size - total)) 1038| 0| { 1039| 0| BOOST_STATIC_CONSTEXPR source_location loc 1040| 0| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1041| 0| return fail(cs.begin(), error::key_too_large, &loc); 1042| 0| } 1043| 865k| } 1044| 0| else 1045| 0| { 1046| 0| BOOST_ASSERT(total <= Handler::max_string_size); ------------------ | | 60| 0|# define BOOST_ASSERT(expr) assert(expr) ------------------ 1047| 0| if(BOOST_JSON_UNLIKELY(size > ------------------ | | 179| 0|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 0] | | ------------------ ------------------ 1048| 0| Handler::max_string_size - total)) 1049| 0| { 1050| 0| BOOST_STATIC_CONSTEXPR source_location loc 1051| 0| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1052| 0| return fail(cs.begin(), error::string_too_large, &loc); 1053| 0| } 1054| 0| } 1055| 865k| total += size; 1056| 865k| if(BOOST_JSON_UNLIKELY(! cs)) ------------------ | | 179| 865k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 115, False: 865k] | | ------------------ ------------------ 1057| 115| { 1058| | // call handler if the string isn't empty 1059| 115| if(BOOST_JSON_LIKELY(size)) ------------------ | | 171| 115|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 93, False: 22] | | ------------------ ------------------ 1060| 93| { 1061| 93| { 1062| 93| bool r = is_key? ------------------ | Branch (1062:26): [Folded - Ignored] ------------------ 1063| 93| h_.on_key_part( {start, size}, total, ec_ ): 1064| 93| h_.on_string_part( {start, size}, total, ec_ ); 1065| | 1066| 93| if(BOOST_JSON_UNLIKELY(!r)) ------------------ | | 179| 93|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 93] | | ------------------ ------------------ 1067| 0| { 1068| 0| return fail(cs.begin()); 1069| 0| } 1070| 93| } 1071| 93| } 1072| 115| return maybe_suspend(cs.begin(), state::str1, total); 1073| 115| } 1074| | // at this point all valid characters have been skipped, so any remaining 1075| | // if there are any more characters, they are either escaped, or incomplete 1076| | // utf8, or invalid utf8 1077| 865k| if(BOOST_JSON_UNLIKELY(*cs != '\x22')) // '"' ------------------ | | 179| 865k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 1.46k, False: 863k] | | ------------------ ------------------ 1078| 1.46k| { 1079| | // sequence is invalid or incomplete 1080| 1.46k| if((*cs & 0x80) && !allow_bad_utf8) ------------------ | Branch (1080:12): [True: 151, False: 1.31k] | Branch (1080:28): [True: 151, False: 0] ------------------ 1081| 151| { 1082| 151| seq_.save(cs.begin(), cs.remain()); 1083| 151| if(BOOST_JSON_UNLIKELY(seq_.complete())) ------------------ | | 179| 151|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 124, False: 27] | | ------------------ ------------------ 1084| 124| { 1085| 124| BOOST_STATIC_CONSTEXPR source_location loc 1086| 124| = BOOST_CURRENT_LOCATION; ------------------ | | 170| 124|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1087| 124| return fail(cs.begin(), error::syntax, &loc); 1088| 124| } 1089| 27| if(BOOST_JSON_LIKELY(size)) ------------------ | | 171| 27|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 18, False: 9] | | ------------------ ------------------ 1090| 18| { 1091| 18| { 1092| 18| bool r = is_key? ------------------ | Branch (1092:30): [Folded - Ignored] ------------------ 1093| 18| h_.on_key_part( {start, size}, total, ec_ ): 1094| 18| h_.on_string_part( {start, size}, total, ec_ ); 1095| | 1096| 18| if(BOOST_JSON_UNLIKELY(!r)) ------------------ | | 179| 18|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 18] | | ------------------ ------------------ 1097| 0| { 1098| 0| return fail(cs.begin()); 1099| 0| } 1100| 18| } 1101| 18| } 1102| 27| return maybe_suspend(cs.end(), state::str8, total); 1103| 27| } 1104| 1.31k| else if(BOOST_JSON_LIKELY(*cs == '\\')) ------------------ | | 171| 1.31k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 1.30k, False: 15] | | ------------------ ------------------ 1105| 1.30k| { 1106| | // flush unescaped run from input 1107| 1.30k| if(BOOST_JSON_LIKELY(size)) ------------------ | | 171| 1.30k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 699, False: 603] | | ------------------ ------------------ 1108| 699| { 1109| 699| { 1110| 699| bool r = is_key? ------------------ | Branch (1110:30): [Folded - Ignored] ------------------ 1111| 699| h_.on_key_part( {start, size}, total, ec_ ): 1112| 699| h_.on_string_part( {start, size}, total, ec_ ); 1113| | 1114| 699| if(BOOST_JSON_UNLIKELY(!r)) ------------------ | | 179| 699|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 699] | | ------------------ ------------------ 1115| 0| { 1116| 0| return fail(cs.begin()); 1117| 0| } 1118| 699| } 1119| 699| } 1120| 1.30k| return parse_escaped(cs.begin(), total, stack_empty, is_key, allow_bad_utf8); 1121| 1.30k| } 1122| | // illegal control 1123| 15| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; ------------------ | | 170| 15|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) ------------------ 1124| 15| return fail(cs.begin(), error::syntax, &loc); 1125| 1.46k| } 1126| | 1127| 863k| { 1128| 863k| bool r = is_key? ------------------ | Branch (1128:18): [Folded - Ignored] ------------------ 1129| 863k| h_.on_key( {start, size}, total, ec_ ): 1130| 863k| h_.on_string( {start, size}, total, ec_ ); 1131| | 1132| 863k| if(BOOST_JSON_UNLIKELY(!r)) ------------------ | | 179| 863k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 863k] | | ------------------ ------------------ 1133| 0| { 1134| 0| return fail(cs.begin()); 1135| 0| } 1136| 863k| } 1137| | 1138| 863k| ++cs; 1139| 863k| return cs.begin(); 1140| 863k|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE4failEPKcNS0_5errorEPKNS_15source_locationE: 294| 2.24k|{ 295| 2.24k| end_ = p; 296| 2.24k| ec_.assign(ev, loc); 297| 2.24k| return sentinel(); 298| 2.24k|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE10incompleteERKNS2_20const_stream_wrapperE: 233| 3.32M|{ 234| 3.32M| return cs.begin() == sentinel(); 235| 3.32M|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE15suspend_or_failENS4_5stateE: 248| 4.15k|{ 249| 4.15k| if(BOOST_JSON_LIKELY( ------------------ | | 171| 6.05k|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 0, False: 4.15k] | | | Branch (171:52): [True: 1.90k, False: 2.24k] | | | Branch (171:52): [True: 0, False: 1.90k] | | ------------------ ------------------ 250| 4.15k| ! ec_ && more_)) 251| 0| { 252| | // suspend 253| 0| reserve(); 254| 0| st_.push_unchecked(st); 255| 0| } 256| 4.15k| return sentinel(); 257| 4.15k|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE8sentinelEv: 220| 3.33M|{ 221| | // the "+1" ensures that the returned pointer is unique even if 222| | // the given input buffer borders on this object 223| 3.33M| return reinterpret_cast< 224| 3.33M| const char*>(this) + 1; 225| 0| return nullptr; 226| 3.33M|} _ZN5boost4json12basic_parserINS0_6detail7handlerEE4failENS_6system10error_codeE: 2677| 451|{ 2678| 451| if(! ec) ------------------ | Branch (2678:8): [True: 0, False: 451] ------------------ 2679| 0| { 2680| | // assign an arbitrary 2681| | // error code to prevent UB 2682| 0| BOOST_JSON_FAIL(ec_, error::incomplete); ------------------ | | 20| 0| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; \ | | ------------------ | | | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) | | ------------------ | | 21| 0| (ec).assign(e, &loc); ------------------ 2683| 0| } 2684| 451| else 2685| 451| { 2686| 451| ec_ = ec; 2687| 451| } 2688| 451| done_ = false; 2689| 451|} _ZN5boost4json6detail15unchecked_arrayC2EPNS0_5valueEmRKNS0_11storage_ptrE: 41| 1.98k| { 42| 1.98k| } _ZNK5boost4json6detail15unchecked_array7storageEv: 55| 1.98k| { 56| 1.98k| return sp_; 57| 1.98k| } _ZNK5boost4json6detail15unchecked_array4sizeEv: 61| 4.56k| { 62| 4.56k| return size_; 63| 4.56k| } _ZN5boost4json6detail6bufferILm4096EEC2Ev: 28| 15.5k| buffer() = default; _ZNK5boost4json6detail6bufferILm4096EE8max_sizeEv: 67| 23.3k| { 68| 23.3k| return N; 69| 23.3k| } _ZNK5boost4json6detail6bufferILm4096EE5emptyEv: 32| 8.04k| { 33| 8.04k| return size_ == 0; 34| 8.04k| } _ZNK5boost4json6detail6bufferILm4096EE4sizeEv: 55| 44.2k| { 56| 44.2k| return size_; 57| 44.2k| } _ZNK5boost4json6detail6bufferILm4096EE3getEv: 38| 22.1k| { 39| 22.1k| return {buf_, size_}; 40| 22.1k| } _ZN5boost4json6detail6bufferILm4096EE5clearEv: 73| 7.74k| { 74| 7.74k| size_ = 0; 75| 7.74k| } _ZN5boost4json6detail6bufferILm4096EE9push_backEc: 79| 20.3M| { 80| 20.3M| BOOST_ASSERT(capacity() > 0); ------------------ | | 60| 20.3M|# define BOOST_ASSERT(expr) assert(expr) ------------------ 81| 20.3M| buf_[size_++] = ch; 82| 20.3M| } _ZN5boost4json6detail6bufferILm4096EE11append_utf8Em: 99| 1.02M| { 100| 1.02M| auto dest = buf_ + size_; 101| 1.02M| if(cp < 0x80) ------------------ | Branch (101:12): [True: 296k, False: 728k] ------------------ 102| 296k| { 103| 296k| BOOST_ASSERT(size_ <= N - 1); ------------------ | | 60| 296k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 104| 296k| dest[0] = static_cast(cp); 105| 296k| size_ += 1; 106| 296k| return; 107| 296k| } 108| | 109| 728k| if(cp < 0x800) ------------------ | Branch (109:12): [True: 149k, False: 578k] ------------------ 110| 149k| { 111| 149k| BOOST_ASSERT(size_ <= N - 2); ------------------ | | 60| 149k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 112| 149k| dest[0] = static_cast( (cp >> 6) | 0xc0); 113| 149k| dest[1] = static_cast( (cp & 0x3f) | 0x80); 114| 149k| size_ += 2; 115| 149k| return; 116| 149k| } 117| | 118| 578k| if(cp < 0x10000) ------------------ | Branch (118:12): [True: 477k, False: 100k] ------------------ 119| 477k| { 120| 477k| BOOST_ASSERT(size_ <= N - 3); ------------------ | | 60| 477k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 121| 477k| dest[0] = static_cast( (cp >> 12) | 0xe0); 122| 477k| dest[1] = static_cast(((cp >> 6) & 0x3f) | 0x80); 123| 477k| dest[2] = static_cast( (cp & 0x3f) | 0x80); 124| 477k| size_ += 3; 125| 477k| return; 126| 477k| } 127| | 128| 100k| { 129| 100k| BOOST_ASSERT(size_ <= N - 4); ------------------ | | 60| 100k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 130| 100k| dest[0] = static_cast( (cp >> 18) | 0xf0); 131| 100k| dest[1] = static_cast(((cp >> 12) & 0x3f) | 0x80); 132| 100k| dest[2] = static_cast(((cp >> 6) & 0x3f) | 0x80); 133| 100k| dest[3] = static_cast( (cp & 0x3f) | 0x80); 134| 100k| size_ += 4; 135| 100k| } 136| 100k| } _ZN5boost4json6detail6bufferILm4096EE6appendEPKcm: 89| 229k| { 90| 229k| BOOST_ASSERT(n <= N - size_); ------------------ | | 60| 229k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 91| 229k| std::memcpy(buf_ + size_, s, n); 92| 229k| size_ += n; 93| 229k| } _ZN5boost4json6detail8exchangeImiEET_RS3_T0_: 286| 7.47M|{ 287| 7.47M| T v = std::move(t); 288| 7.47M| t = std::move(u); 289| 7.47M| return v; 290| 7.47M|} _ZN5boost4json6detail16default_resource3getEv: 48| 1.74M| { 49| | #ifdef BOOST_JSON_WEAK_CONSTINIT 50| | static default_resource instance_; 51| | #endif 52| 1.74M| return reinterpret_cast( 53| 1.74M| reinterpret_cast( 54| 1.74M| &instance_)); 55| 1.74M| } _ZN5boost4json6detail6digestIPKcEEmT_S5_m: 24| 813k|{ 25| 813k|#if BOOST_JSON_ARCH == 64 26| 813k| std::uint64_t const prime = 0x100000001B3ULL; 27| 813k| std::uint64_t hash = 0xcbf29ce484222325ULL; 28| |#else 29| | std::uint32_t const prime = 0x01000193UL; 30| | std::uint32_t hash = 0x811C9DC5UL; 31| |#endif 32| 813k| hash += salt; 33| 5.06M| for(; b != e; ++b) ------------------ | Branch (33:11): [True: 4.25M, False: 813k] ------------------ 34| 4.25M| hash = (*b ^ hash) * prime; 35| 813k| return hash; 36| 813k|} _ZN5boost4json6detail15unchecked_array8relocateEPNS0_5valueE: 31| 1.28k|{ 32| 1.28k| if(size_ > 0) ------------------ | Branch (32:8): [True: 1.28k, False: 0] ------------------ 33| 1.28k| std::memcpy( 34| 1.28k| static_cast(dest), 35| 1.28k| data_, size_ * sizeof(value)); 36| 1.28k| data_ = nullptr; 37| 1.28k|} _ZN5boost4json6detail15unchecked_arrayD2Ev: 19| 1.98k|{ 20| 1.98k| if(! data_ || ------------------ | Branch (20:8): [True: 1.28k, False: 696] ------------------ 21| 1.98k| sp_.is_not_shared_and_deallocate_is_trivial()) ------------------ | Branch (21:9): [True: 0, False: 696] ------------------ 22| 1.28k| return; 23| 696| for(unsigned long i = 0; 24| 696| i < size_; ++i) ------------------ | Branch (24:9): [True: 0, False: 696] ------------------ 25| 0| data_[i].~value(); 26| 696|} _ZN5boost4json6detail16default_resource11do_allocateEmm: 42| 872k|{ 43| 872k| return ::operator new(n); 44| 872k|} _ZN5boost4json6detail16default_resource13do_deallocateEPvmm: 52| 872k|{ 53| 872k| ::operator delete(p); 54| 872k|} _ZN5boost4json6detail7handlerC2IJNS0_11storage_ptrERPhRmEEEDpOT_: 24| 6.62k|{ 25| 6.62k|} _ZN5boost4json6detail7handler17on_document_beginERNS_6system10error_codeE: 31| 6.62k|{ 32| 6.62k| return true; 33| 6.62k|} _ZN5boost4json6detail7handler14on_number_partENS_4core17basic_string_viewIcEERNS_6system10error_codeE: 128| 109|{ 129| 109| return true; 130| 109|} _ZN5boost4json6detail7handler8on_int64ElNS_4core17basic_string_viewIcEERNS_6system10error_codeE: 138| 2.35M|{ 139| 2.35M| st.push_int64(i); 140| 2.35M| return true; 141| 2.35M|} _ZN5boost4json6detail7handler9on_uint64EmNS_4core17basic_string_viewIcEERNS_6system10error_codeE: 149| 2.86k|{ 150| 2.86k| st.push_uint64(u); 151| 2.86k| return true; 152| 2.86k|} _ZN5boost4json6detail7handler9on_doubleEdNS_4core17basic_string_viewIcEERNS_6system10error_codeE: 160| 30.3k|{ 161| 30.3k| st.push_double(d); 162| 30.3k| return true; 163| 30.3k|} _ZN5boost4json6detail7handler7on_boolEbRNS_6system10error_codeE: 170| 6.97k|{ 171| 6.97k| st.push_bool(b); 172| 6.97k| return true; 173| 6.97k|} _ZN5boost4json6detail7handler7on_nullERNS_6system10error_codeE: 178| 2.56k|{ 179| 2.56k| st.push_null(); 180| 2.56k| return true; 181| 2.56k|} _ZN5boost4json6detail7handler14on_string_partENS_4core17basic_string_viewIcEEmRNS_6system10error_codeE: 107| 17.2k|{ 108| 17.2k| st.push_chars(s); 109| 17.2k| return true; 110| 17.2k|} _ZN5boost4json6detail7handler11on_key_partENS_4core17basic_string_viewIcEEmRNS_6system10error_codeE: 85| 2.47k|{ 86| 2.47k| st.push_chars(s); 87| 2.47k| return true; 88| 2.47k|} _ZN5boost4json6detail7handler6on_keyENS_4core17basic_string_viewIcEEmRNS_6system10error_codeE: 96| 865k|{ 97| 865k| st.push_key(s); 98| 865k| return true; 99| 865k|} _ZN5boost4json6detail7handler9on_stringENS_4core17basic_string_viewIcEEmRNS_6system10error_codeE: 118| 33.4k|{ 119| 33.4k| st.push_string(s); 120| 33.4k| return true; 121| 33.4k|} _ZN5boost4json6detail7handler14on_array_beginERNS_6system10error_codeE: 65| 4.60k|{ 66| 4.60k| return true; 67| 4.60k|} _ZN5boost4json6detail7handler12on_array_endEmRNS_6system10error_codeE: 74| 1.98k|{ 75| 1.98k| st.push_array(n); 76| 1.98k| return true; 77| 1.98k|} _ZN5boost4json6detail7handler15on_object_beginERNS_6system10error_codeE: 47| 14.3k|{ 48| 14.3k| return true; 49| 14.3k|} _ZN5boost4json6detail7handler13on_object_endEmRNS_6system10error_codeE: 56| 12.5k|{ 57| 12.5k| st.push_object(n); 58| 12.5k| return true; 59| 12.5k|} _ZN5boost4json6detail7handler15on_document_endERNS_6system10error_codeE: 39| 2.44k|{ 40| 2.44k| return true; 41| 2.44k|} _ZN5boost4json6detail5stackD2Ev: 21| 6.62k|{ 22| 6.62k| if(base_ != buf_) ------------------ | Branch (22:8): [True: 0, False: 6.62k] ------------------ 23| 0| sp_->deallocate( 24| 0| base_, cap_); 25| 6.62k|} _ZN5boost4json6detail11string_implC2Ev: 36| 33.4k|{ 37| 33.4k| s_.k = short_string_; 38| 33.4k| s_.buf[sbo_chars_] = 39| 33.4k| static_cast( 40| 33.4k| sbo_chars_); 41| 33.4k| s_.buf[0] = 0; 42| 33.4k|} _ZN5boost4json6detail11string_implC2EmRKNS0_11storage_ptrE: 48| 3.29k|{ 49| 3.29k| if(size <= sbo_chars_) ------------------ | Branch (49:8): [True: 0, False: 3.29k] ------------------ 50| 0| { 51| 0| s_.k = short_string_; 52| 0| s_.buf[sbo_chars_] = 53| 0| static_cast( 54| 0| sbo_chars_ - size); 55| 0| s_.buf[size] = 0; 56| 0| } 57| 3.29k| else 58| 3.29k| { 59| 3.29k| s_.k = kind::string; 60| 3.29k| auto const n = growth( 61| 3.29k| size, sbo_chars_ + 1); 62| 3.29k| p_.t = ::new(sp->allocate( 63| 3.29k| sizeof(table) + 64| 3.29k| n + 1, 65| 3.29k| alignof(table))) table{ 66| 3.29k| static_cast< 67| 3.29k| std::uint32_t>(size), 68| 3.29k| static_cast< 69| 3.29k| std::uint32_t>(n)}; 70| 3.29k| data()[n] = 0; 71| 3.29k| } 72| 3.29k|} _ZN5boost4json6detail11string_implC2ENS1_5key_tENS_4core17basic_string_viewIcEERKNS0_11storage_ptrE: 80| 864k|{ 81| 864k| BOOST_ASSERT( ------------------ | | 60| 864k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 82| 864k| s.size() <= max_size()); 83| 864k| k_.k = key_string_; 84| 864k| k_.n = static_cast< 85| 864k| std::uint32_t>(s.size()); 86| 864k| k_.s = reinterpret_cast( 87| 864k| sp->allocate(s.size() + 1, 88| 864k| alignof(char))); 89| 864k| k_.s[s.size()] = 0; // null term 90| 864k| std::memcpy(&k_.s[0], 91| 864k| s.data(), s.size()); 92| 864k|} _ZN5boost4json6detail11string_implC2ENS1_5key_tENS_4core17basic_string_viewIcEES6_RKNS0_11storage_ptrE: 101| 700|{ 102| 700| auto len = s1.size() + s2.size(); 103| 700| BOOST_ASSERT(len <= max_size()); ------------------ | | 60| 700|# define BOOST_ASSERT(expr) assert(expr) ------------------ 104| 700| k_.k = key_string_; 105| 700| k_.n = static_cast< 106| 700| std::uint32_t>(len); 107| 700| k_.s = reinterpret_cast( 108| 700| sp->allocate(len + 1, 109| 700| alignof(char))); 110| 700| k_.s[len] = 0; // null term 111| 700| std::memcpy(&k_.s[0], 112| 700| s1.data(), s1.size()); 113| 700| std::memcpy(&k_.s[s1.size()], 114| 700| s2.data(), s2.size()); 115| 700|} _ZN5boost4json6detail11string_impl6growthEmm: 122| 6.59k|{ 123| 6.59k| if(new_size > max_size()) ------------------ | Branch (123:8): [True: 0, False: 6.59k] ------------------ 124| 0| detail::throw_length_error( "string too large" ); 125| | // growth factor 2 126| 6.59k| if( capacity > ------------------ | Branch (126:9): [True: 0, False: 6.59k] ------------------ 127| 6.59k| max_size() - capacity) 128| 0| return static_cast< 129| 0| std::uint32_t>(max_size()); // overflow 130| 6.59k| return static_cast( 131| 6.59k| (std::max)(capacity * 2, new_size)); 132| 6.59k|} _ZN5boost4json6detail11string_impl6assignEmRKNS0_11storage_ptrE: 139| 22.5k|{ 140| 22.5k| if(new_size > capacity()) ------------------ | Branch (140:8): [True: 2.15k, False: 20.3k] ------------------ 141| 2.15k| { 142| 2.15k| string_impl tmp(growth( 143| 2.15k| new_size, 144| 2.15k| capacity()), sp); 145| 2.15k| destroy(sp); 146| 2.15k| *this = tmp; 147| 2.15k| } 148| 22.5k| term(new_size); 149| 22.5k| return data(); 150| 22.5k|} _ZN5boost4json6detail16unchecked_objectC2EPNS0_5valueEmRKNS0_11storage_ptrE: 46| 12.5k| { 47| 12.5k| } _ZNK5boost4json6detail16unchecked_object7storageEv: 60| 12.5k| { 61| 12.5k| return sp_; 62| 12.5k| } _ZNK5boost4json6detail16unchecked_object4sizeEv: 66| 15.0k| { 67| 15.0k| return size_; 68| 15.0k| } _ZN5boost4json6detail16unchecked_object7releaseEv: 72| 1.26k| { 73| 1.26k| auto const data = data_; 74| 1.26k| data_ = nullptr; 75| 1.26k| return data; 76| 1.26k| } _ZN5boost4json6detail16count_whitespaceEPKcS3_: 425| 6.64M|{ 426| 6.64M| if( p == end ) ------------------ | Branch (426:9): [True: 2.60k, False: 6.64M] ------------------ 427| 2.60k| { 428| 2.60k| return p; 429| 2.60k| } 430| | 431| 6.64M| if( static_cast( *p ) > 0x20 ) ------------------ | Branch (431:9): [True: 6.61M, False: 26.1k] ------------------ 432| 6.61M| { 433| 6.61M| return p; 434| 6.61M| } 435| | 436| 26.1k| __m128i const q1 = _mm_set1_epi8( ' ' ); 437| 26.1k| __m128i const q2 = _mm_set1_epi8( '\n' ); 438| 26.1k| __m128i const q3 = _mm_set1_epi8( 4 ); // '\t' | 4 == '\r' 439| 26.1k| __m128i const q4 = _mm_set1_epi8( '\r' ); 440| | 441| 28.1k| while( end - p >= 16 ) ------------------ | Branch (441:12): [True: 27.4k, False: 737] ------------------ 442| 27.4k| { 443| 27.4k| __m128i v0 = _mm_loadu_si128( (__m128i const*)p ); 444| | 445| 27.4k| __m128i w0 = _mm_or_si128( 446| 27.4k| _mm_cmpeq_epi8( v0, q1 ), 447| 27.4k| _mm_cmpeq_epi8( v0, q2 )); 448| 27.4k| __m128i v1 = _mm_or_si128( v0, q3 ); 449| 27.4k| __m128i w1 = _mm_cmpeq_epi8( v1, q4 ); 450| 27.4k| __m128i w2 = _mm_or_si128( w0, w1 ); 451| | 452| 27.4k| int m = _mm_movemask_epi8( w2 ) ^ 0xFFFF; 453| | 454| 27.4k| if( m != 0 ) ------------------ | Branch (454:13): [True: 25.3k, False: 2.05k] ------------------ 455| 25.3k| { 456| 25.3k|#if defined(__GNUC__) || defined(__clang__) 457| 25.3k| std::size_t c = __builtin_ffs( m ) - 1; 458| |#else 459| | unsigned long index; 460| | _BitScanForward( &index, m ); 461| | std::size_t c = index; 462| |#endif 463| | 464| 25.3k| p += c; 465| 25.3k| return p; 466| 25.3k| } 467| | 468| 2.05k| p += 16; 469| 2.05k| } 470| | 471| 1.82k| while( p != end ) ------------------ | Branch (471:12): [True: 1.55k, False: 270] ------------------ 472| 1.55k| { 473| 1.55k| if( *p != ' ' && *p != '\t' && *p != '\r' && *p != '\n' ) ------------------ | Branch (473:13): [True: 1.23k, False: 319] | Branch (473:26): [True: 890, False: 345] | Branch (473:40): [True: 659, False: 231] | Branch (473:54): [True: 467, False: 192] ------------------ 474| 467| { 475| 467| return p; 476| 467| } 477| | 478| 1.08k| ++p; 479| 1.08k| } 480| | 481| 270| return p; 482| 737|} _ZN5boost4json6detail12count_digitsEPKc: 269| 2.35M|{ 270| 2.35M| __m128i v1 = _mm_loadu_si128( (__m128i const*)p ); 271| 2.35M| v1 = _mm_add_epi8(v1, _mm_set1_epi8(70)); 272| 2.35M| v1 = _mm_cmplt_epi8(v1, _mm_set1_epi8(118)); 273| | 274| 2.35M| int m = _mm_movemask_epi8(v1); 275| | 276| 2.35M| int n; 277| | 278| 2.35M| if( m == 0 ) ------------------ | Branch (278:9): [True: 12.3k, False: 2.34M] ------------------ 279| 12.3k| { 280| 12.3k| n = 16; 281| 12.3k| } 282| 2.34M| else 283| 2.34M| { 284| 2.34M|#if defined(__GNUC__) || defined(__clang__) 285| 2.34M| n = __builtin_ffs( m ) - 1; 286| |#else 287| | unsigned long index; 288| | _BitScanForward( &index, m ); 289| | n = static_cast(index); 290| |#endif 291| 2.34M| } 292| | 293| 2.35M| return n; 294| 2.35M|} _ZN5boost4json6detail14parse_unsignedEmPKcm: 317| 2.35M|{ 318| 2.42M| while( n >= 4 ) ------------------ | Branch (318:12): [True: 70.3k, False: 2.35M] ------------------ 319| 70.3k| { 320| | // faster on on clang for x86, 321| | // slower on gcc 322| 70.3k|#ifdef __clang__ 323| 70.3k| r = r * 10 + p[0] - '0'; 324| 70.3k| r = r * 10 + p[1] - '0'; 325| 70.3k| r = r * 10 + p[2] - '0'; 326| 70.3k| r = r * 10 + p[3] - '0'; 327| |#else 328| | uint32_t v; 329| | std::memcpy( &v, p, 4 ); 330| | 331| | v -= 0x30303030; 332| | 333| | unsigned w0 = v & 0xFF; 334| | unsigned w1 = (v >> 8) & 0xFF; 335| | unsigned w2 = (v >> 16) & 0xFF; 336| | unsigned w3 = (v >> 24); 337| | 338| |#ifdef BOOST_JSON_BIG_ENDIAN 339| | r = (((r * 10 + w3) * 10 + w2) * 10 + w1) * 10 + w0; 340| |#else 341| | r = (((r * 10 + w0) * 10 + w1) * 10 + w2) * 10 + w3; 342| |#endif 343| |#endif 344| 70.3k| p += 4; 345| 70.3k| n -= 4; 346| 70.3k| } 347| | 348| 2.35M| switch( n ) ------------------ | Branch (348:13): [True: 0, False: 2.35M] ------------------ 349| 2.35M| { 350| 16.0k| case 0: ------------------ | Branch (350:5): [True: 16.0k, False: 2.34M] ------------------ 351| 16.0k| break; 352| 2.30M| case 1: ------------------ | Branch (352:5): [True: 2.30M, False: 49.9k] ------------------ 353| 2.30M| r = r * 10 + p[0] - '0'; 354| 2.30M| break; 355| 24.5k| case 2: ------------------ | Branch (355:5): [True: 24.5k, False: 2.33M] ------------------ 356| 24.5k| r = r * 10 + p[0] - '0'; 357| 24.5k| r = r * 10 + p[1] - '0'; 358| 24.5k| break; 359| 9.41k| case 3: ------------------ | Branch (359:5): [True: 9.41k, False: 2.34M] ------------------ 360| 9.41k| r = r * 10 + p[0] - '0'; 361| 9.41k| r = r * 10 + p[1] - '0'; 362| 9.41k| r = r * 10 + p[2] - '0'; 363| 9.41k| break; 364| 2.35M| } 365| 2.35M| return r; 366| 2.35M|} _ZN5boost4json6detail11count_validILb0EEEPKcS4_S4_: 89| 900k|{ 90| 900k| __m128i const q1 = _mm_set1_epi8( '\x22' ); // '"' 91| 900k| __m128i const q2 = _mm_set1_epi8( '\\' ); 92| 900k| __m128i const q3 = _mm_set1_epi8( 0x20 ); 93| | 94| 1.41M| while(end - p >= 16) ------------------ | Branch (94:11): [True: 1.41M, False: 2.23k] ------------------ 95| 1.41M| { 96| 1.41M| __m128i v1 = _mm_loadu_si128( (__m128i const*)p ); 97| | 98| 1.41M| __m128i v2 = _mm_cmpeq_epi8( v1, q1 ); 99| 1.41M| __m128i v3 = _mm_cmpeq_epi8( v1, q2 ); 100| 1.41M| __m128i v4 = _mm_cmplt_epi8( v1, q3 ); 101| | 102| 1.41M| __m128i v5 = _mm_or_si128( v2, v3 ); 103| 1.41M| __m128i v6 = _mm_or_si128( v5, v4 ); 104| | 105| 1.41M| int w = _mm_movemask_epi8( v6 ); 106| | 107| 1.41M| if( w != 0 ) ------------------ | Branch (107:13): [True: 898k, False: 514k] ------------------ 108| 898k| { 109| 898k| int m; 110| 898k|#if defined(__GNUC__) || defined(__clang__) 111| 898k| m = __builtin_ffs( w ) - 1; 112| |#else 113| | unsigned long index; 114| | _BitScanForward( &index, w ); 115| | m = index; 116| |#endif 117| 898k| p += m; 118| 898k| break; 119| 898k| } 120| | 121| 514k| p += 16; 122| 514k| } 123| | 124| 25.9M| while(p != end) ------------------ | Branch (124:11): [True: 25.9M, False: 251] ------------------ 125| 25.9M| { 126| 25.9M| const unsigned char c = *p; 127| 25.9M| if(c == '\x22' || c == '\\' || c < 0x20) ------------------ | Branch (127:12): [True: 884k, False: 25.0M] | Branch (127:27): [True: 15.5k, False: 25.0M] | Branch (127:40): [True: 29, False: 25.0M] ------------------ 128| 899k| break; 129| 25.0M| if(c < 0x80) ------------------ | Branch (129:12): [True: 24.9M, False: 75.2k] ------------------ 130| 24.9M| { 131| 24.9M| ++p; 132| 24.9M| continue; 133| 24.9M| } 134| | // validate utf-8 135| 75.2k| uint16_t first = classify_utf8(c); 136| 75.2k| uint8_t len = first & 0xFF; 137| 75.2k| if(BOOST_JSON_UNLIKELY(end - p < len)) ------------------ | | 179| 75.2k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 55, False: 75.1k] | | ------------------ ------------------ 138| 55| break; 139| 75.1k| if(BOOST_JSON_UNLIKELY(! is_valid_utf8(p, first))) ------------------ | | 179| 75.1k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 243, False: 74.9k] | | ------------------ ------------------ 140| 243| break; 141| 74.9k| p += len; 142| 74.9k| } 143| | 144| 900k| return p; 145| 900k|} _ZN5boost4json6detail5stackC2Ev: 33| 6.62k| stack() = default; _ZN5boost4json6detail5stack5clearEv: 48| 13.2k| { 49| 13.2k| size_ = 0; 50| 13.2k| } _ZNK5boost4json6detail5stack5emptyEv: 42| 6.62k| { 43| 6.62k| return size_ == 0; 44| 6.62k| } _ZN5boost4json6detail20const_stream_wrapperC2ERPKcS4_: 133| 3.34M| { 134| 3.34M| } _ZNK5boost4json6detail20const_stream_wrapper5beginEv: 162| 26.9M| { 163| 26.9M| return p_; 164| 26.9M| } _ZNK5boost4json6detail20const_stream_wrapper3endEv: 167| 7.54M| { 168| 7.54M| return end_; 169| 7.54M| } _ZN5boost4json6detail20const_stream_wrapperaSEPKc: 147| 10.8M| { 148| 10.8M| p_ = p; 149| 10.8M| } _ZNK5boost4json6detail20const_stream_wrappercvbEv: 157| 9.75M| { 158| 9.75M| return p_ < end_; 159| 9.75M| } _ZNK5boost4json6detail20const_stream_wrapper6remainEv: 172| 2.40M| { 173| 2.40M| return end_ - p_; 174| 2.40M| } _ZN5boost4json6detail20const_stream_wrapperppEv: 137| 30.8M| { 138| 30.8M| ++p_; 139| 30.8M| } _ZN5boost4json6detail20const_stream_wrapperpLEm: 142| 3.72M| { 143| 3.72M| p_ += n; 144| 3.72M| } _ZNK5boost4json6detail20const_stream_wrapper4usedEPKc: 182| 3.29M| { 183| 3.29M| return p_ - p; 184| 3.29M| } _ZN5boost4json6detail20clipped_const_streamC2ERPKcS4_: 198| 15.5k| { 199| 15.5k| } _ZN5boost4json6detail20clipped_const_stream4clipEm: 228| 23.3k| { 229| 23.3k| if(static_cast( ------------------ | Branch (229:12): [True: 19.1k, False: 4.23k] ------------------ 230| 23.3k| end_ - p_) > n) 231| 19.1k| clip_ = p_ + n; 232| 4.23k| else 233| 4.23k| clip_ = end_; 234| 23.3k| } _ZNK5boost4json6detail20clipped_const_streamcvbEv: 212| 24.5M| { 213| 24.5M| return p_ < clip_; 214| 24.5M| } _ZNK5boost4json6detail20clipped_const_stream6remainEv: 217| 1.25M| { 218| 1.25M| return clip_ - p_; 219| 1.25M| } _ZNK5boost4json6detail20clipped_const_stream3endEv: 207| 705| { 208| 705| return clip_; 209| 705| } _ZN5boost4json6detail20clipped_const_streamaSEPKc: 202| 673| { 203| 673| p_ = p; 204| 673| } _ZNK5boost4json6detail20const_stream_wrapperdeEv: 152| 34.5M| { 153| 34.5M| return *p_; 154| 34.5M| } _ZN5boost4json6detail11string_impl8max_sizeEv: 102| 13.1k| { 103| | // max_size depends on the address model 104| 13.1k| using min = std::integral_constant; 106| 13.1k| return min::value < BOOST_JSON_MAX_STRING_SIZE ? ------------------ | | 226| 13.1k|# define BOOST_JSON_MAX_STRING_SIZE 0x7ffffffe ------------------ | Branch (106:16): [Folded - Ignored] ------------------ 107| 13.1k| min::value : BOOST_JSON_MAX_STRING_SIZE; ------------------ | | 226| 13.1k|# define BOOST_JSON_MAX_STRING_SIZE 0x7ffffffe ------------------ 108| 13.1k| } _ZNK5boost4json6detail11string_impl4sizeEv: 190| 13.2k| { 191| 13.2k| return s_.k == kind::string ? ------------------ | Branch (191:16): [True: 1.14k, False: 12.1k] ------------------ 192| 1.14k| p_.t->size : 193| 13.2k| sbo_chars_ - 194| 12.1k| s_.buf[sbo_chars_]; 195| 13.2k| } _ZNK5boost4json6detail11string_impl8capacityEv: 199| 37.9k| { 200| 37.9k| return s_.k == kind::string ? ------------------ | Branch (200:16): [True: 0, False: 37.9k] ------------------ 201| 0| p_.t->capacity : 202| 37.9k| sbo_chars_; 203| 37.9k| } _ZN5boost4json6detail11string_impl4sizeEm: 207| 1.14k| { 208| 1.14k| if(s_.k == kind::string) ------------------ | Branch (208:12): [True: 1.14k, False: 0] ------------------ 209| 1.14k| p_.t->size = static_cast< 210| 1.14k| std::uint32_t>(n); 211| 0| else 212| 0| s_.buf[sbo_chars_] = 213| 0| static_cast( 214| 0| sbo_chars_ - n); 215| 1.14k| } _ZN5boost4json6detail11string_impl11release_keyERm: 227| 815k| { 228| 815k| BOOST_ASSERT( ------------------ | | 60| 815k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 229| 815k| k_.k == key_string_); 230| 815k| n = k_.n; 231| 815k| auto const s = k_.s; 232| | // prevent deallocate 233| 815k| k_.k = short_string_; 234| 815k| return s; 235| 815k| } _ZN5boost4json6detail11string_impl7destroyERKNS0_11storage_ptrE: 240| 86.8k| { 241| 86.8k| if(s_.k == kind::string) ------------------ | Branch (241:12): [True: 3.29k, False: 83.5k] ------------------ 242| 3.29k| { 243| 3.29k| sp->deallocate(p_.t, 244| 3.29k| sizeof(table) + 245| 3.29k| p_.t->capacity + 1, 246| 3.29k| alignof(table)); 247| 3.29k| } 248| 83.5k| else if(s_.k != key_string_) ------------------ | Branch (248:17): [True: 33.4k, False: 50.0k] ------------------ 249| 33.4k| { 250| | // do nothing 251| 33.4k| } 252| 50.0k| else 253| 50.0k| { 254| 50.0k| BOOST_ASSERT( ------------------ | | 60| 50.0k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 255| 50.0k| s_.k == key_string_); 256| | // VFALCO unfortunately the key string 257| | // kind increases the cost of the destructor. 258| | // This function should be skipped when using 259| | // monotonic_resource. 260| 50.0k| sp->deallocate(k_.s, k_.n + 1); 261| 50.0k| } 262| 86.8k| } _ZN5boost4json6detail11string_impl4termEm: 315| 33.4k| { 316| 33.4k| if(s_.k == short_string_) ------------------ | Branch (316:12): [True: 30.2k, False: 3.29k] ------------------ 317| 30.2k| { 318| 30.2k| s_.buf[sbo_chars_] = 319| 30.2k| static_cast( 320| 30.2k| sbo_chars_ - n); 321| 30.2k| s_.buf[n] = 0; 322| 30.2k| } 323| 3.29k| else 324| 3.29k| { 325| 3.29k| p_.t->size = static_cast< 326| 3.29k| std::uint32_t>(n); 327| 3.29k| data()[n] = 0; 328| 3.29k| } 329| 33.4k| } _ZN5boost4json6detail11string_impl4dataEv: 333| 53.3k| { 334| 53.3k| if(s_.k == short_string_) ------------------ | Branch (334:12): [True: 41.1k, False: 12.1k] ------------------ 335| 41.1k| return s_.buf; 336| 12.1k| return reinterpret_cast< 337| 12.1k| char*>(p_.t + 1); 338| 53.3k| } _ZN5boost4json6detail13classify_utf8Ec: 41| 304k|{ 42| | // 0x000 = invalid 43| | // 0x102 = 2 bytes, second byte [80, BF] 44| | // 0x203 = 3 bytes, second byte [A0, BF] 45| | // 0x303 = 3 bytes, second byte [80, BF] 46| | // 0x403 = 3 bytes, second byte [80, 9F] 47| | // 0x504 = 4 bytes, second byte [90, BF] 48| | // 0x604 = 4 bytes, second byte [80, BF] 49| | // 0x704 = 4 bytes, second byte [80, 8F] 50| 304k| static constexpr uint16_t first[128] 51| 304k| { 52| 304k| 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 53| 304k| 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 54| 304k| 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 55| 304k| 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 56| 304k| 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 57| 304k| 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 58| 304k| 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 59| 304k| 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 60| | 61| 304k| 0x000, 0x000, 0x102, 0x102, 0x102, 0x102, 0x102, 0x102, 62| 304k| 0x102, 0x102, 0x102, 0x102, 0x102, 0x102, 0x102, 0x102, 63| 304k| 0x102, 0x102, 0x102, 0x102, 0x102, 0x102, 0x102, 0x102, 64| 304k| 0x102, 0x102, 0x102, 0x102, 0x102, 0x102, 0x102, 0x102, 65| 304k| 0x203, 0x303, 0x303, 0x303, 0x303, 0x303, 0x303, 0x303, 66| 304k| 0x303, 0x303, 0x303, 0x303, 0x303, 0x403, 0x303, 0x303, 67| 304k| 0x504, 0x604, 0x604, 0x604, 0x704, 0x000, 0x000, 0x000, 68| 304k| 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 69| 304k| }; 70| 304k| return first[static_cast(c & 0x7F)]; 71| 304k|} _ZN5boost4json6detail13is_valid_utf8EPKct: 76| 304k|{ 77| 304k| uint32_t v; 78| 304k| switch(first >> 8) 79| 304k| { 80| 120| default: ------------------ | Branch (80:5): [True: 120, False: 304k] ------------------ 81| 120| return false; 82| | 83| | // 2 bytes, second byte [80, BF] 84| 71.8k| case 1: ------------------ | Branch (84:5): [True: 71.8k, False: 232k] ------------------ 85| 71.8k| v = load_little_endian<2>(p); 86| 71.8k| return (v & 0xC000) == 0x8000; 87| | 88| | // 3 bytes, second byte [A0, BF] 89| 6.72k| case 2: ------------------ | Branch (89:5): [True: 6.72k, False: 297k] ------------------ 90| 6.72k| v = load_little_endian<3>(p); 91| 6.72k| return (v & 0xC0E000) == 0x80A000; 92| | 93| | // 3 bytes, second byte [80, BF] 94| 30.6k| case 3: ------------------ | Branch (94:5): [True: 30.6k, False: 273k] ------------------ 95| 30.6k| v = load_little_endian<3>(p); 96| 30.6k| return (v & 0xC0C000) == 0x808000; 97| | 98| | // 3 bytes, second byte [80, 9F] 99| 63.2k| case 4: ------------------ | Branch (99:5): [True: 63.2k, False: 241k] ------------------ 100| 63.2k| v = load_little_endian<3>(p); 101| 63.2k| return (v & 0xC0E000) == 0x808000; 102| | 103| | // 4 bytes, second byte [90, BF] 104| 8.66k| case 5: ------------------ | Branch (104:5): [True: 8.66k, False: 295k] ------------------ 105| 8.66k| v = load_little_endian<4>(p); 106| 8.66k| return (v & 0xC0C0FF00) + 0x7F7F7000 <= 0x2F00; 107| | 108| | // 4 bytes, second byte [80, BF] 109| 112k| case 6: ------------------ | Branch (109:5): [True: 112k, False: 192k] ------------------ 110| 112k| v = load_little_endian<4>(p); 111| 112k| return (v & 0xC0C0C000) == 0x80808000; 112| | 113| | // 4 bytes, second byte [80, 8F] 114| 10.9k| case 7: ------------------ | Branch (114:5): [True: 10.9k, False: 293k] ------------------ 115| 10.9k| v = load_little_endian<4>(p); 116| 10.9k| return (v & 0xC0C0F000) == 0x80808000; 117| 304k| } 118| 304k|} _ZN5boost4json6detail18load_little_endianILi2EEEjPKv: 26| 71.8k|{ 27| 71.8k| std::uint32_t v = 0; 28| 71.8k| std::memcpy(&v, p, N); 29| |#ifdef BOOST_JSON_BIG_ENDIAN 30| | v = ((v & 0xFF000000) >> 24) | 31| | ((v & 0x00FF0000) >> 8) | 32| | ((v & 0x0000FF00) << 8) | 33| | ((v & 0x000000FF) << 24); 34| |#endif 35| 71.8k| return v; 36| 71.8k|} _ZN5boost4json6detail18load_little_endianILi3EEEjPKv: 26| 100k|{ 27| 100k| std::uint32_t v = 0; 28| 100k| std::memcpy(&v, p, N); 29| |#ifdef BOOST_JSON_BIG_ENDIAN 30| | v = ((v & 0xFF000000) >> 24) | 31| | ((v & 0x00FF0000) >> 8) | 32| | ((v & 0x0000FF00) << 8) | 33| | ((v & 0x000000FF) << 24); 34| |#endif 35| 100k| return v; 36| 100k|} _ZN5boost4json6detail18load_little_endianILi4EEEjPKv: 26| 1.25M|{ 27| 1.25M| std::uint32_t v = 0; 28| 1.25M| std::memcpy(&v, p, N); 29| |#ifdef BOOST_JSON_BIG_ENDIAN 30| | v = ((v & 0xFF000000) >> 24) | 31| | ((v & 0x00FF0000) >> 8) | 32| | ((v & 0x0000FF00) << 8) | 33| | ((v & 0x000000FF) << 24); 34| |#endif 35| 1.25M| return v; 36| 1.25M|} _ZN5boost4json6detail13utf8_sequence4saveEPKcm: 131| 229k| { 132| 229k| first_ = classify_utf8(*p ); 133| 229k| if(remain >= length()) ------------------ | Branch (133:12): [True: 228k, False: 728] ------------------ 134| 228k| size_ = length(); 135| 728| else 136| 728| size_ = static_cast(remain); 137| 229k| std::memcpy(seq_, p, size_); 138| 229k| } _ZNK5boost4json6detail13utf8_sequence6lengthEv: 142| 1.14M| { 143| 1.14M| return first_ & 0xFF; 144| 1.14M| } _ZNK5boost4json6detail13utf8_sequence8completeEv: 148| 229k| { 149| 229k| return size_ >= length(); 150| 229k| } _ZNK5boost4json6detail13utf8_sequence5validEv: 189| 229k| { 190| 229k| BOOST_ASSERT(size_ >= length()); ------------------ | | 60| 229k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 191| 229k| return is_valid_utf8(seq_, first_); 192| 229k| } _ZNK5boost4json6detail13utf8_sequence4dataEv: 177| 229k| { 178| 229k| return seq_; 179| 229k| } _ZNK5boost4json6detail13utf8_sequence6neededEv: 183| 2.66k| { 184| 2.66k| return length() - size_; 185| 2.66k| } _ZN5boost4json6detail13utf8_sequence6appendEPKcm: 157| 673| { 158| 673| if(BOOST_JSON_UNLIKELY(needed() == 0)) ------------------ | | 179| 673|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 0, False: 673] | | ------------------ ------------------ 159| 0| return true; 160| 673| if(BOOST_JSON_LIKELY(remain >= needed())) ------------------ | | 171| 673|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 641, False: 32] | | ------------------ ------------------ 161| 641| { 162| 641| std::memcpy( 163| 641| seq_ + size_, p, needed()); 164| 641| size_ = length(); 165| 641| return true; 166| 641| } 167| 32| if(BOOST_JSON_LIKELY(remain > 0)) ------------------ | | 171| 32|# define BOOST_JSON_LIKELY(x) __builtin_expect(!!(x), 1) | | ------------------ | | | Branch (171:32): [True: 2, False: 30] | | ------------------ ------------------ 168| 2| { 169| 2| std::memcpy(seq_ + size_, p, remain); 170| 2| size_ += static_cast(remain); 171| 2| } 172| 32| return false; 173| 673| } _ZN5boost4json6detail6scalarC2ENS0_11storage_ptrE: 180| 824k| { 181| 824k| } _ZN5boost4json6detail6scalarC2EbNS0_11storage_ptrE: 189| 6.97k| { 190| 6.97k| } _ZN5boost4json6detail6scalarC2ElNS0_11storage_ptrE: 198| 2.35M| { 199| 2.35M| } _ZN5boost4json6detail6scalarC2EmNS0_11storage_ptrE: 207| 2.86k| { 208| 2.86k| } _ZN5boost4json6detail6scalarC2EdNS0_11storage_ptrE: 216| 30.3k| { 217| 30.3k| } _ZN5boost4json6detail6access4nextINS0_14key_value_pairEEERjRT_: 262| 1.62M| { 263| 1.62M| return e.next_; 264| 1.62M| } _ZN5boost4json6detail6access24construct_key_value_pairINS0_14key_value_pairEJNS0_8pilferedINS0_5valueEEES7_EEERT_PS8_DpOT0_: 237| 815k| { 238| 815k| return *reinterpret_cast< 239| 815k| KeyValuePair*>(::new(p) 240| 815k| KeyValuePair( 241| 815k| std::forward(args)...)); 242| 815k| } _ZN5boost4json6detail6access11release_keyINS0_5valueEEEPKcRT_Rm: 250| 815k| { 251| 815k| BOOST_ASSERT(jv.is_string()); ------------------ | | 60| 815k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 252| 815k| jv.str_.sp_.~storage_ptr(); 253| 815k| return jv.str_.impl_.release_key(len); 254| 815k| } _ZN5boost4json6detail6access15construct_valueINS0_5valueEJNS1_15unchecked_arrayEEEERT_PS6_DpOT0_: 226| 1.98k| { 227| 1.98k| return *reinterpret_cast< 228| 1.98k| Value*>(::new(p) Value( 229| 1.98k| std::forward(args)...)); 230| 1.98k| } _ZN5boost4json6detail6access15construct_valueINS0_5valueEJNS1_16unchecked_objectEEEERT_PS6_DpOT0_: 226| 12.5k| { 227| 12.5k| return *reinterpret_cast< 228| 12.5k| Value*>(::new(p) Value( 229| 12.5k| std::forward(args)...)); 230| 12.5k| } _ZN5boost4json6detail6access15construct_valueINS0_5valueEJNS1_5key_tERNS_4core17basic_string_viewIcEERNS0_11storage_ptrEEEERT_PSC_DpOT0_: 226| 864k| { 227| 864k| return *reinterpret_cast< 228| 864k| Value*>(::new(p) Value( 229| 864k| std::forward(args)...)); 230| 864k| } _ZN5boost4json6detail6access15construct_valueINS0_5valueEJNS1_5key_tERNS_4core17basic_string_viewIcEES9_RNS0_11storage_ptrEEEERT_PSC_DpOT0_: 226| 700| { 227| 700| return *reinterpret_cast< 228| 700| Value*>(::new(p) Value( 229| 700| std::forward(args)...)); 230| 700| } _ZN5boost4json6detail6access15construct_valueINS0_5valueEJRNS_4core17basic_string_viewIcEERNS0_11storage_ptrEEEERT_PSB_DpOT0_: 226| 22.5k| { 227| 22.5k| return *reinterpret_cast< 228| 22.5k| Value*>(::new(p) Value( 229| 22.5k| std::forward(args)...)); 230| 22.5k| } _ZN5boost4json6detail6access15construct_valueINS0_5valueEJRKNS0_13string_kind_tERNS0_11storage_ptrEEEERT_PSA_DpOT0_: 226| 10.9k| { 227| 10.9k| return *reinterpret_cast< 228| 10.9k| Value*>(::new(p) Value( 229| 10.9k| std::forward(args)...)); 230| 10.9k| } _ZN5boost4json6detail6access15construct_valueINS0_5valueEJRlRNS0_11storage_ptrEEEERT_PS8_DpOT0_: 226| 2.35M| { 227| 2.35M| return *reinterpret_cast< 228| 2.35M| Value*>(::new(p) Value( 229| 2.35M| std::forward(args)...)); 230| 2.35M| } _ZN5boost4json6detail6access15construct_valueINS0_5valueEJRmRNS0_11storage_ptrEEEERT_PS8_DpOT0_: 226| 2.86k| { 227| 2.86k| return *reinterpret_cast< 228| 2.86k| Value*>(::new(p) Value( 229| 2.86k| std::forward(args)...)); 230| 2.86k| } _ZN5boost4json6detail6access15construct_valueINS0_5valueEJRdRNS0_11storage_ptrEEEERT_PS8_DpOT0_: 226| 30.3k| { 227| 30.3k| return *reinterpret_cast< 228| 30.3k| Value*>(::new(p) Value( 229| 30.3k| std::forward(args)...)); 230| 30.3k| } _ZN5boost4json6detail6access15construct_valueINS0_5valueEJRbRNS0_11storage_ptrEEEERT_PS8_DpOT0_: 226| 6.97k| { 227| 6.97k| return *reinterpret_cast< 228| 6.97k| Value*>(::new(p) Value( 229| 6.97k| std::forward(args)...)); 230| 6.97k| } _ZN5boost4json6detail6access15construct_valueINS0_5valueEJDnRNS0_11storage_ptrEEEERT_PS7_DpOT0_: 226| 2.56k| { 227| 2.56k| return *reinterpret_cast< 228| 2.56k| Value*>(::new(p) Value( 229| 2.56k| std::forward(args)...)); 230| 2.56k| } _ZN5boost4json5array5tableixEm: 34| 5.25k| { 35| 5.25k| return (reinterpret_cast< 36| 5.25k| value*>(this + 1))[pos]; 37| 5.25k| } _ZN5boost4json5array4dataEv: 304| 1.28k|{ 305| 1.28k| return &(*t_)[0]; 306| 1.28k|} _ZN5boost4json5array5beginEv: 345| 1.98k|{ 346| 1.98k| return &(*t_)[0]; 347| 1.98k|} _ZN5boost4json5array3endEv: 369| 1.98k|{ 370| 1.98k| return &(*t_)[t_->size]; 371| 1.98k|} _ZN5boost4json5array8max_sizeEv: 454| 1.28k|{ 455| | // max_size depends on the address model 456| 1.28k| using min = std::integral_constant; 458| 1.28k| return min::value < BOOST_JSON_MAX_STRUCTURED_SIZE ? ------------------ | | 230| 1.28k|# define BOOST_JSON_MAX_STRUCTURED_SIZE 0x7ffffffe ------------------ | Branch (458:12): [Folded - Ignored] ------------------ 459| 1.28k| min::value : BOOST_JSON_MAX_STRUCTURED_SIZE; ------------------ | | 230| 1.28k|# define BOOST_JSON_MAX_STRUCTURED_SIZE 0x7ffffffe ------------------ 460| 1.28k|} _ZN5boost4json5array5table8allocateEmRKNS0_11storage_ptrE: 40| 1.28k|{ 41| 1.28k| BOOST_ASSERT(capacity > 0); ------------------ | | 60| 1.28k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 42| 1.28k| if(capacity > array::max_size()) ------------------ | Branch (42:8): [True: 0, False: 1.28k] ------------------ 43| 0| detail::throw_length_error( "array too large" ); 44| 1.28k| auto p = reinterpret_cast< 45| 1.28k| table*>(sp->allocate( 46| 1.28k| sizeof(table) + 47| 1.28k| capacity * sizeof(value), 48| 1.28k| alignof(value))); 49| 1.28k| p->capacity = static_cast< 50| 1.28k| std::uint32_t>(capacity); 51| 1.28k| return p; 52| 1.28k|} _ZN5boost4json5array5table10deallocateEPS2_RKNS0_11storage_ptrE: 60| 1.98k|{ 61| 1.98k| if(p->capacity == 0) ------------------ | Branch (61:8): [True: 696, False: 1.28k] ------------------ 62| 696| return; 63| 1.28k| sp->deallocate(p, 64| 1.28k| sizeof(table) + 65| 1.28k| p->capacity * sizeof(value), 66| 1.28k| alignof(value)); 67| 1.28k|} _ZN5boost4json5array7destroyEv: 155| 1.98k|{ 156| 1.98k| if(sp_.is_not_shared_and_deallocate_is_trivial()) ------------------ | Branch (156:8): [True: 0, False: 1.98k] ------------------ 157| 0| return; 158| 1.98k| auto last = end(); 159| 1.98k| auto const first = begin(); 160| 1.08M| while(last-- != first) ------------------ | Branch (160:11): [True: 1.08M, False: 1.98k] ------------------ 161| 1.08M| last->~value(); 162| 1.98k| table::deallocate(t_, sp_); 163| 1.98k|} _ZN5boost4json5arrayC2EONS0_6detail15unchecked_arrayE: 174| 1.98k|{ 175| 1.98k| BOOST_STATIC_ASSERT( ------------------ | | 71| 1.98k|# define BOOST_STATIC_ASSERT( ... ) static_assert(__VA_ARGS__, #__VA_ARGS__) ------------------ 176| 1.98k| alignof(table) == alignof(value)); 177| 1.98k| if(ua.size() == 0) ------------------ | Branch (177:8): [True: 696, False: 1.28k] ------------------ 178| 696| { 179| 696| t_ = &empty_; 180| 696| return; 181| 696| } 182| 1.28k| t_= table::allocate( 183| 1.28k| ua.size(), sp_); 184| 1.28k| t_->size = static_cast< 185| 1.28k| std::uint32_t>(ua.size()); 186| 1.28k| ua.relocate(data()); 187| 1.28k|} _ZN5boost4json5arrayD2Ev: 191| 1.98k|{ 192| 1.98k| destroy(); 193| 1.98k|} _ZN5boost4json15make_error_codeENS0_5errorE: 20| 4.63k|{ 21| 4.63k| struct codes : error_category 22| 4.63k| { 23| 4.63k| const char* 24| 4.63k| name() const noexcept override 25| 4.63k| { 26| 4.63k| return "boost.json"; 27| 4.63k| } 28| | 29| 4.63k| char const* message( int ev, char*, std::size_t ) const noexcept 30| 4.63k| override 31| 4.63k| { 32| 4.63k| switch(static_cast(ev)) 33| 4.63k| { 34| 4.63k| default: 35| 4.63k|case error::syntax: return "syntax error"; 36| 4.63k|case error::extra_data: return "extra data"; 37| 4.63k|case error::incomplete: return "incomplete JSON"; 38| 4.63k|case error::exponent_overflow: return "exponent overflow"; 39| 4.63k|case error::too_deep: return "too deep"; 40| 4.63k|case error::illegal_leading_surrogate: return "illegal leading surrogate"; 41| 4.63k|case error::illegal_trailing_surrogate: return "illegal trailing surrogate"; 42| 4.63k|case error::expected_hex_digit: return "expected hex digit"; 43| 4.63k|case error::expected_utf16_escape: return "expected utf16 escape"; 44| 4.63k|case error::object_too_large: return "object too large"; 45| 4.63k|case error::array_too_large: return "array too large"; 46| 4.63k|case error::key_too_large: return "key too large"; 47| 4.63k|case error::string_too_large: return "string too large"; 48| 4.63k|case error::input_error: return "input error"; 49| | 50| 4.63k|case error::exception: return "got exception"; 51| 4.63k|case error::test_failure: return "test failure"; 52| | 53| 4.63k|case error::missing_slash: return "missing slash character"; 54| 4.63k|case error::invalid_escape: return "invalid escape sequence"; 55| 4.63k|case error::token_not_number: return "token is not a number"; 56| 4.63k|case error::value_is_scalar: return "current value is scalar"; 57| 4.63k|case error::not_found: return "no referenced value"; 58| 4.63k|case error::token_overflow: return "token overflow"; 59| 4.63k|case error::past_the_end: return "past-the-end token not supported"; 60| | 61| 4.63k|case error::not_number: return "not a number"; 62| 4.63k|case error::not_exact: return "not exact"; 63| 4.63k|case error::not_null: return "value is not null"; 64| 4.63k|case error::not_bool: return "value is not boolean"; 65| 4.63k|case error::not_array: return "value is not an array"; 66| 4.63k|case error::not_object: return "value is not an object"; 67| 4.63k|case error::not_string: return "value is not a string"; 68| 4.63k|case error::size_mismatch: return "array size does not match target size"; 69| 4.63k|case error::exhausted_variants: return "exhausted all variants"; 70| 4.63k|case error::unknown_name: return "unknown name"; 71| 4.63k| } 72| 4.63k| } 73| | 74| 4.63k| std::string 75| 4.63k| message( int ev ) const override 76| 4.63k| { 77| 4.63k| return message( ev, nullptr, 0 ); 78| 4.63k| } 79| | 80| 4.63k| error_condition 81| 4.63k| default_error_condition( 82| 4.63k| int ev) const noexcept override 83| 4.63k| { 84| 4.63k| switch(static_cast(ev)) 85| 4.63k| { 86| 4.63k| default: 87| 4.63k| return {ev, *this}; 88| | 89| 4.63k|case error::syntax: 90| 4.63k|case error::extra_data: 91| 4.63k|case error::incomplete: 92| 4.63k|case error::exponent_overflow: 93| 4.63k|case error::too_deep: 94| 4.63k|case error::illegal_leading_surrogate: 95| 4.63k|case error::illegal_trailing_surrogate: 96| 4.63k|case error::expected_hex_digit: 97| 4.63k|case error::expected_utf16_escape: 98| 4.63k|case error::object_too_large: 99| 4.63k|case error::array_too_large: 100| 4.63k|case error::key_too_large: 101| 4.63k|case error::string_too_large: 102| 4.63k|case error::input_error: 103| 4.63k| return condition::parse_error; 104| | 105| 4.63k|case error::missing_slash: 106| 4.63k|case error::invalid_escape: 107| 4.63k| return condition::pointer_parse_error; 108| | 109| 4.63k|case error::token_not_number: 110| 4.63k|case error::value_is_scalar: 111| 4.63k|case error::not_found: 112| 4.63k|case error::token_overflow: 113| 4.63k|case error::past_the_end: 114| 4.63k| return condition::pointer_use_error; 115| | 116| 4.63k|case error::not_number: 117| 4.63k|case error::not_exact: 118| 4.63k|case error::not_null: 119| 4.63k|case error::not_bool: 120| 4.63k|case error::not_array: 121| 4.63k|case error::not_object: 122| 4.63k|case error::not_string: 123| 4.63k|case error::size_mismatch: 124| 4.63k|case error::exhausted_variants: 125| 4.63k|case error::unknown_name: 126| 4.63k| return condition::conversion_error; 127| | 128| 4.63k|case error::exception: 129| 4.63k| return condition::generic_error; 130| 4.63k| } 131| 4.63k| } 132| 4.63k| }; 133| | // on some versions of msvc-14.2 the category is put in RO memory 134| | // erroneusly, if the category object is const, 135| | // and that may result in crash 136| 4.63k| static codes cat{}; 137| 4.63k| return error_code{static_cast< 138| 4.63k| std::underlying_type::type>(e), cat}; 139| 4.63k|} _ZNK5boost4json6object5table8is_smallEv: 61| 4.41k| { 62| 4.41k| return capacity <= 63| 4.41k| detail::small_object_size_; 64| 4.41k| } _ZN5boost4json6object5tableixEm: 69| 1.63M| { 70| 1.63M| return reinterpret_cast< 71| 1.63M| key_value_pair*>( 72| 1.63M| this + 1)[pos]; 73| 1.63M| } _ZN5boost4json6object5table10deallocateEPS2_RKNS0_11storage_ptrE: 105| 1.26k| { 106| 1.26k| if(p->capacity == 0) ------------------ | Branch (106:12): [True: 0, False: 1.26k] ------------------ 107| 0| return; 108| 1.26k| if(! p->is_small()) ------------------ | Branch (108:12): [True: 345, False: 923] ------------------ 109| 345| sp->deallocate(p, 110| 345| sizeof(table) + p->capacity * ( 111| 345| sizeof(key_value_pair) + 112| 345| sizeof(index_t))); 113| 923| else 114| 923| sp->deallocate(p, 115| 923| sizeof(table) + p->capacity * 116| 923| sizeof(key_value_pair)); 117| 1.26k| } _ZN5boost4json6object5beginEv: 198| 4.92k|{ 199| 4.92k| return &(*t_)[0]; 200| 4.92k|} _ZN5boost4json6object3endEv: 222| 1.26k|{ 223| 1.26k| return &(*t_)[t_->size]; 224| 1.26k|} _ZN5boost4json6detail16unchecked_objectD2Ev: 517| 12.5k|{ 518| 12.5k| if(! data_) ------------------ | Branch (518:8): [True: 1.26k, False: 11.2k] ------------------ 519| 1.26k| return; 520| 11.2k| if(sp_.is_not_shared_and_deallocate_is_trivial()) ------------------ | Branch (520:8): [True: 0, False: 11.2k] ------------------ 521| 0| return; 522| 11.2k| value* p = data_; 523| 11.2k| while(size_--) ------------------ | Branch (523:11): [True: 0, False: 11.2k] ------------------ 524| 0| { 525| 0| p[0].~value(); 526| 0| p[1].~value(); 527| 0| p += 2; 528| 0| } 529| 11.2k|} _ZN5boost4json6detail14find_in_objectINS_4core17basic_string_viewIcEEEENSt3__14pairIPNS0_14key_value_pairEmEERKNS0_6objectET_: 34| 1.88k|{ 35| 1.88k| BOOST_ASSERT(obj.t_->capacity > 0); ------------------ | | 60| 1.88k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 36| 1.88k| if(obj.t_->is_small()) ------------------ | Branch (36:8): [True: 1.88k, False: 0] ------------------ 37| 1.88k| { 38| 1.88k| auto it = &(*obj.t_)[0]; 39| 1.88k| auto const last = 40| 1.88k| &(*obj.t_)[obj.t_->size]; 41| 4.38k| for(;it != last; ++it) ------------------ | Branch (41:14): [True: 2.95k, False: 1.42k] ------------------ 42| 2.95k| if( key == it->key() ) ------------------ | Branch (42:17): [True: 460, False: 2.49k] ------------------ 43| 460| return { it, 0 }; 44| 1.42k| return { nullptr, 0 }; 45| 1.88k| } 46| 0| std::pair< 47| 0| key_value_pair*, 48| 0| std::size_t> result; 49| 0| BOOST_ASSERT(obj.t_->salt != 0); ------------------ | | 60| 0|# define BOOST_ASSERT(expr) assert(expr) ------------------ 50| 0| result.second = detail::digest(key.begin(), key.end(), obj.t_->salt); 51| 0| auto i = obj.t_->bucket( 52| 0| result.second); 53| 0| while(i != object::null_index_) ------------------ | Branch (53:11): [True: 0, False: 0] ------------------ 54| 0| { 55| 0| auto& v = (*obj.t_)[i]; 56| 0| if( key == v.key() ) ------------------ | Branch (56:13): [True: 0, False: 0] ------------------ 57| 0| { 58| 0| result.first = &v; 59| 0| return result; 60| 0| } 61| 0| i = access::next(v); 62| 0| } 63| 0| result.first = nullptr; 64| 0| return result; 65| 0|} _ZNK5boost4json6object5table6digestENS_4core17basic_string_viewIcEE: 87| 813k|{ 88| 813k| BOOST_ASSERT(salt != 0); ------------------ | | 60| 813k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 89| 813k| return detail::digest( 90| 813k| key.begin(), key.end(), salt); 91| 813k|} _ZN5boost4json6objectC2EONS0_6detail16unchecked_objectE: 203| 12.5k|{ 204| 12.5k| if(uo.size() == 0) ------------------ | Branch (204:8): [True: 11.2k, False: 1.26k] ------------------ 205| 11.2k| { 206| 11.2k| t_ = &empty_; 207| 11.2k| return; 208| 11.2k| } 209| | // should already be checked 210| 1.26k| BOOST_ASSERT( ------------------ | | 60| 1.26k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 211| 1.26k| uo.size() <= max_size()); 212| 1.26k| t_ = table::allocate( 213| 1.26k| uo.size(), 0, sp_); 214| | 215| | // insert all elements, keeping 216| | // the last of any duplicate keys. 217| 1.26k| auto dest = begin(); 218| 1.26k| auto src = uo.release(); 219| 1.26k| auto const end = src + 2 * uo.size(); 220| 1.26k| if(t_->is_small()) ------------------ | Branch (220:8): [True: 923, False: 345] ------------------ 221| 923| { 222| 923| t_->size = 0; 223| 2.80k| while(src != end) ------------------ | Branch (223:15): [True: 1.88k, False: 923] ------------------ 224| 1.88k| { 225| 1.88k| access::construct_key_value_pair( 226| 1.88k| dest, pilfer(src[0]), pilfer(src[1])); 227| 1.88k| src += 2; 228| 1.88k| auto result = detail::find_in_object(*this, dest->key()); 229| 1.88k| if(! result.first) ------------------ | Branch (229:16): [True: 1.42k, False: 460] ------------------ 230| 1.42k| { 231| 1.42k| ++dest; 232| 1.42k| ++t_->size; 233| 1.42k| continue; 234| 1.42k| } 235| | // handle duplicate 236| 460| auto& v = *result.first; 237| | // don't bother to check if 238| | // storage deallocate is trivial 239| 460| v.~key_value_pair(); 240| | // trivial relocate 241| 460| std::memcpy( 242| 460| static_cast(&v), 243| 460| dest, sizeof(v)); 244| 460| } 245| 923| return; 246| 923| } 247| 813k| while(src != end) ------------------ | Branch (247:11): [True: 813k, False: 345] ------------------ 248| 813k| { 249| 813k| access::construct_key_value_pair( 250| 813k| dest, pilfer(src[0]), pilfer(src[1])); 251| 813k| src += 2; 252| 813k| auto& head = t_->bucket(dest->key()); 253| 813k| auto i = head; 254| 813k| for(;;) 255| 813k| { 256| 813k| if(i == null_index_) ------------------ | Branch (256:16): [True: 2.04k, False: 811k] ------------------ 257| 2.04k| { 258| | // end of bucket 259| 2.04k| access::next( 260| 2.04k| *dest) = head; 261| 2.04k| head = static_cast( 262| 2.04k| dest - begin()); 263| 2.04k| ++dest; 264| 2.04k| break; 265| 2.04k| } 266| 811k| auto& v = (*t_)[i]; 267| 811k| if(v.key() != dest->key()) ------------------ | Branch (267:16): [True: 796, False: 811k] ------------------ 268| 796| { 269| 796| i = access::next(v); 270| 796| continue; 271| 796| } 272| | 273| | // handle duplicate 274| 811k| access::next(*dest) = 275| 811k| access::next(v); 276| | // don't bother to check if 277| | // storage deallocate is trivial 278| 811k| v.~key_value_pair(); 279| | // trivial relocate 280| 811k| std::memcpy( 281| 811k| static_cast(&v), 282| 811k| dest, sizeof(v)); 283| 811k| break; 284| 811k| } 285| 813k| } 286| 345| t_->size = static_cast< 287| 345| index_t>(dest - begin()); 288| 345|} _ZN5boost4json6objectD2Ev: 292| 12.5k|{ 293| 12.5k| if(sp_.is_not_shared_and_deallocate_is_trivial()) ------------------ | Branch (293:8): [True: 0, False: 12.5k] ------------------ 294| 0| return; 295| 12.5k| if(t_->capacity == 0) ------------------ | Branch (295:8): [True: 11.2k, False: 1.26k] ------------------ 296| 11.2k| return; 297| 1.26k| destroy(); 298| 1.26k|} _ZN5boost4json6object5table6bucketEm: 97| 813k|{ 98| 813k| return reinterpret_cast< 99| 813k| index_t*>(&(*this)[capacity])[ 100| 813k| hash % capacity]; 101| 813k|} _ZN5boost4json6object5table8allocateEmmRKNS0_11storage_ptrE: 130| 1.26k|{ 131| 1.26k| BOOST_STATIC_ASSERT( ------------------ | | 71| 1.26k|# define BOOST_STATIC_ASSERT( ... ) static_assert(__VA_ARGS__, #__VA_ARGS__) ------------------ 132| 1.26k| alignof(key_value_pair) >= 133| 1.26k| alignof(index_t)); 134| 1.26k| BOOST_ASSERT(capacity > 0); ------------------ | | 60| 1.26k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 135| 1.26k| BOOST_ASSERT(capacity <= max_size()); ------------------ | | 60| 1.26k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 136| 1.26k| table* p; 137| 1.26k| if(capacity <= detail::small_object_size_) ------------------ | Branch (137:8): [True: 923, False: 345] ------------------ 138| 923| { 139| 923| p = reinterpret_cast< 140| 923| table*>(sp->allocate( 141| 923| sizeof(table) + capacity * 142| 923| sizeof(key_value_pair))); 143| 923| p->capacity = static_cast< 144| 923| std::uint32_t>(capacity); 145| 923| } 146| 345| else 147| 345| { 148| 345| p = reinterpret_cast< 149| 345| table*>(sp->allocate( 150| 345| sizeof(table) + capacity * ( 151| 345| sizeof(key_value_pair) + 152| 345| sizeof(index_t)))); 153| 345| p->capacity = static_cast< 154| 345| std::uint32_t>(capacity); 155| 345| p->clear(); 156| 345| } 157| 1.26k| if(salt) ------------------ | Branch (157:8): [True: 0, False: 1.26k] ------------------ 158| 0| { 159| 0| p->salt = salt; 160| 0| } 161| 1.26k| else 162| 1.26k| { 163| | // VFALCO This would be better if it 164| | // was random, but maybe this 165| | // is good enough. 166| 1.26k| p->salt = reinterpret_cast< 167| 1.26k| std::uintptr_t>(p); 168| 1.26k| } 169| 1.26k| return p; 170| 1.26k|} _ZN5boost4json6object5table6bucketENS_4core17basic_string_viewIcEE: 107| 813k|{ 108| 813k| return bucket(digest(key)); 109| 813k|} _ZN5boost4json6object5table5clearEv: 114| 345|{ 115| 345| BOOST_ASSERT(! is_small()); ------------------ | | 60| 345|# define BOOST_ASSERT(expr) assert(expr) ------------------ 116| | // initialize buckets 117| 345| std::memset( 118| 345| reinterpret_cast( 119| 345| &(*this)[capacity]), 120| 345| 0xff, // null_index_ 121| 345| capacity * sizeof(index_t)); 122| 345|} _ZN5boost4json6object7destroyEv: 822| 1.26k|{ 823| 1.26k| BOOST_ASSERT(t_->capacity > 0); ------------------ | | 60| 1.26k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 824| 1.26k| BOOST_ASSERT(! sp_.is_not_shared_and_deallocate_is_trivial()); ------------------ | | 60| 1.26k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 825| 1.26k| destroy(begin(), end()); 826| 1.26k| table::deallocate(t_, sp_); 827| 1.26k|} _ZN5boost4json6object7destroyEPNS0_14key_value_pairES3_: 834| 1.26k|{ 835| 1.26k| BOOST_ASSERT(! sp_.is_not_shared_and_deallocate_is_trivial()); ------------------ | | 60| 1.26k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 836| 4.73k| while(last != first) ------------------ | Branch (836:11): [True: 3.46k, False: 1.26k] ------------------ 837| 3.46k| (--last)->~key_value_pair(); 838| 1.26k|} _ZN5boost4json5parseENS_4core17basic_string_viewIcEERNS_6system10error_codeENS0_11storage_ptrERKNS0_13parse_optionsE: 29| 6.62k|{ 30| 6.62k| unsigned char temp[ 31| 6.62k| BOOST_JSON_STACK_BUFFER_SIZE]; 32| 6.62k| parser p(storage_ptr(), opt, temp); 33| 6.62k| p.reset(std::move(sp)); 34| 6.62k| p.write(s, ec); 35| 6.62k| if(ec) ------------------ | Branch (35:8): [True: 4.63k, False: 1.99k] ------------------ 36| 4.63k| return nullptr; 37| 1.99k| return p.release(); 38| 6.62k|} _ZN5boost4json6parserC2ENS0_11storage_ptrERKNS0_13parse_optionsEPhm: 34| 6.62k|{ 35| 6.62k| reset(); 36| 6.62k|} _ZN5boost4json6parser5resetENS0_11storage_ptrE: 54| 13.2k|{ 55| 13.2k| p_.reset(); 56| 13.2k| p_.handler().st.reset(sp); 57| 13.2k|} _ZN5boost4json6parser10write_someEPKcmRNS_6system10error_codeE: 65| 6.62k|{ 66| 6.62k| auto const n = p_.write_some( 67| 6.62k| false, data, size, ec); 68| 6.62k| BOOST_ASSERT(ec || p_.done()); ------------------ | | 60| 6.62k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 69| 6.62k| return n; 70| 6.62k|} _ZN5boost4json6parser5writeEPKcmRNS_6system10error_codeE: 105| 6.62k|{ 106| 6.62k| auto const n = write_some( 107| 6.62k| data, size, ec); 108| 6.62k| if(! ec && n < size) ------------------ | Branch (108:8): [True: 2.44k, False: 4.17k] | Branch (108:16): [True: 451, False: 1.99k] ------------------ 109| 451| { 110| 451| BOOST_JSON_FAIL(ec, error::extra_data); ------------------ | | 20| 451| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; \ | | ------------------ | | | | 170| 451|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) | | ------------------ | | 21| 451| (ec).assign(e, &loc); ------------------ 111| 451| p_.fail(ec); 112| 451| } 113| 6.62k| return n; 114| 6.62k|} _ZN5boost4json6parser7releaseEv: 146| 1.99k|{ 147| 1.99k| if( ! p_.done()) ------------------ | Branch (147:9): [True: 0, False: 1.99k] ------------------ 148| 0| { 149| | // prevent undefined behavior 150| 0| if(! p_.last_error()) ------------------ | Branch (150:12): [True: 0, False: 0] ------------------ 151| 0| { 152| 0| error_code ec; 153| 0| BOOST_JSON_FAIL(ec, error::incomplete); ------------------ | | 20| 0| BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION; \ | | ------------------ | | | | 170| 0|# define BOOST_CURRENT_LOCATION ::boost::source_location(__builtin_FILE(), __builtin_LINE(), __builtin_FUNCTION(), __builtin_COLUMN()) | | ------------------ | | 21| 0| (ec).assign(e, &loc); ------------------ 154| 0| p_.fail(ec); 155| 0| } 156| 0| detail::throw_system_error( 157| 0| p_.last_error()); 158| 0| } 159| 1.99k| return p_.handler().st.release(); 160| 1.99k|} _ZN5boost4json6stringC2ERKNS0_6detail5key_tENS_4core17basic_string_viewIcEENS0_11storage_ptrE: 26| 864k|{ 27| 864k|} _ZN5boost4json6stringC2ERKNS0_6detail5key_tENS_4core17basic_string_viewIcEES8_NS0_11storage_ptrE: 38| 700|{ 39| 700|} _ZN5boost4json6stringC2ENS_4core17basic_string_viewIcEENS0_11storage_ptrE: 89| 22.5k|{ 90| 22.5k| assign(s); 91| 22.5k|} _ZN5boost4json6string6assignEPKcm: 178| 22.5k|{ 179| 22.5k| std::char_traits::copy( 180| 22.5k| impl_.assign(count, sp_), 181| 22.5k| s, count); 182| 22.5k| return *this; 183| 22.5k|} _ZN5boost4json6string12reserve_implEm: 398| 1.14k|{ 399| 1.14k| BOOST_ASSERT( ------------------ | | 60| 1.14k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 400| 1.14k| new_cap >= impl_.capacity()); 401| 1.14k| if(new_cap > impl_.capacity()) ------------------ | Branch (401:8): [True: 1.14k, False: 0] ------------------ 402| 1.14k| { 403| | // grow 404| 1.14k| new_cap = detail::string_impl::growth( 405| 1.14k| new_cap, impl_.capacity()); 406| 1.14k| detail::string_impl tmp(new_cap, sp_); 407| 1.14k| std::char_traits::copy(tmp.data(), 408| 1.14k| impl_.data(), impl_.size() + 1); 409| 1.14k| tmp.size(impl_.size()); 410| 1.14k| impl_.destroy(sp_); 411| 1.14k| impl_ = tmp; 412| 1.14k| return; 413| 1.14k| } 414| 1.14k|} _ZN5boost4json5valueD2Ev: 43| 2.50M|{ 44| 2.50M| switch(kind()) ------------------ | Branch (44:12): [True: 0, False: 2.50M] ------------------ 45| 2.50M| { 46| 7.19k| case json::kind::null: ------------------ | Branch (46:5): [True: 7.19k, False: 2.49M] ------------------ 47| 14.1k| case json::kind::bool_: ------------------ | Branch (47:5): [True: 6.97k, False: 2.49M] ------------------ 48| 2.37M| case json::kind::int64: ------------------ | Branch (48:5): [True: 2.35M, False: 145k] ------------------ 49| 2.37M| case json::kind::uint64: ------------------ | Branch (49:5): [True: 2.86k, False: 2.50M] ------------------ 50| 2.40M| case json::kind::double_: ------------------ | Branch (50:5): [True: 30.3k, False: 2.47M] ------------------ 51| 2.40M| sca_.~scalar(); 52| 2.40M| break; 53| | 54| 83.5k| case json::kind::string: ------------------ | Branch (54:5): [True: 83.5k, False: 2.42M] ------------------ 55| 83.5k| str_.~string(); 56| 83.5k| break; 57| | 58| 1.98k| case json::kind::array: ------------------ | Branch (58:5): [True: 1.98k, False: 2.50M] ------------------ 59| 1.98k| arr_.~array(); 60| 1.98k| break; 61| | 62| 12.5k| case json::kind::object: ------------------ | Branch (62:5): [True: 12.5k, False: 2.49M] ------------------ 63| 12.5k| obj_.~object(); 64| 12.5k| break; 65| 2.50M| } 66| 2.50M|} _ZN5boost4json14key_value_pairC2ENS0_8pilferedINS0_5valueEEES4_: 583| 815k|{ 584| 815k| std::size_t len; 585| 815k| key_ = access::release_key(key.get(), len); 586| 815k| len_ = static_cast(len); 587| 815k|} _ZN5boost4json11value_stackD2Ev: 305| 6.62k|{ 306| | // default dtor is here so the 307| | // definition goes in the library 308| | // instead of the caller's TU. 309| 6.62k|} _ZN5boost4json11value_stackC2ENS0_11storage_ptrEPhm: 320| 6.62k|{ 321| 6.62k|} _ZN5boost4json11value_stack5resetENS0_11storage_ptrE: 326| 13.2k|{ 327| 13.2k| st_.clear(); 328| | 329| 13.2k| sp_.~storage_ptr(); 330| 13.2k| ::new(&sp_) storage_ptr( 331| 13.2k| pilfer(sp)); 332| | 333| | // `stack` needs this 334| | // to clean up correctly 335| 13.2k| st_.run_dtors( 336| 13.2k| ! sp_.is_not_shared_and_deallocate_is_trivial()); 337| 13.2k|} _ZN5boost4json11value_stack7releaseEv: 342| 1.99k|{ 343| | // This means the caller did not 344| | // cause a single top level element 345| | // to be produced. 346| 1.99k| BOOST_ASSERT(st_.size() == 1); ------------------ | | 60| 1.99k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 347| | 348| | // give up shared ownership 349| 1.99k| sp_ = {}; 350| | 351| 1.99k| return pilfer(*st_.release(1)); 352| 1.99k|} _ZN5boost4json11value_stack10push_arrayEm: 359| 1.98k|{ 360| | // we already have room if n > 0 361| 1.98k| if(BOOST_JSON_UNLIKELY(n == 0)) ------------------ | | 179| 1.98k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 696, False: 1.28k] | | ------------------ ------------------ 362| 696| st_.maybe_grow(); 363| 1.98k| detail::unchecked_array ua( 364| 1.98k| st_.release(n), n, sp_); 365| 1.98k| st_.exchange(std::move(ua)); 366| 1.98k|} _ZN5boost4json11value_stack11push_objectEm: 371| 12.5k|{ 372| | // we already have room if n > 0 373| 12.5k| if(BOOST_JSON_UNLIKELY(n == 0)) ------------------ | | 179| 12.5k|# define BOOST_JSON_UNLIKELY(x) __builtin_expect(!!(x), 0) | | ------------------ | | | Branch (179:34): [True: 11.2k, False: 1.26k] | | ------------------ ------------------ 374| 11.2k| st_.maybe_grow(); 375| 12.5k| detail::unchecked_object uo( 376| 12.5k| st_.release(n * 2), n, sp_); 377| 12.5k| st_.exchange(std::move(uo)); 378| 12.5k|} _ZN5boost4json11value_stack10push_charsENS_4core17basic_string_viewIcEE: 384| 19.7k|{ 385| 19.7k| st_.append(s); 386| 19.7k|} _ZN5boost4json11value_stack8push_keyENS_4core17basic_string_viewIcEE: 392| 865k|{ 393| 865k| if(! st_.has_chars()) ------------------ | Branch (393:8): [True: 864k, False: 700] ------------------ 394| 864k| { 395| 864k| st_.push(detail::key_t{}, s, sp_); 396| 864k| return; 397| 864k| } 398| 700| auto part = st_.release_string(); 399| 700| st_.push(detail::key_t{}, part, s, sp_); 400| 700|} _ZN5boost4json11value_stack11push_stringENS_4core17basic_string_viewIcEE: 406| 33.4k|{ 407| 33.4k| if(! st_.has_chars()) ------------------ | Branch (407:8): [True: 22.5k, False: 10.9k] ------------------ 408| 22.5k| { 409| | // fast path 410| 22.5k| st_.push(s, sp_); 411| 22.5k| return; 412| 22.5k| } 413| | 414| | // VFALCO We could add a special 415| | // private ctor to string that just 416| | // creates uninitialized space, 417| | // to reduce member function calls. 418| 10.9k| auto part = st_.release_string(); 419| 10.9k| auto& str = st_.push( 420| 10.9k| string_kind, sp_).get_string(); 421| 10.9k| str.reserve( 422| 10.9k| part.size() + s.size()); 423| 10.9k| std::memcpy( 424| 10.9k| str.data(), 425| 10.9k| part.data(), part.size()); 426| 10.9k| std::memcpy( 427| 10.9k| str.data() + part.size(), 428| 10.9k| s.data(), s.size()); 429| 10.9k| str.grow(part.size() + s.size()); 430| 10.9k|} _ZN5boost4json11value_stack10push_int64El: 436| 2.35M|{ 437| 2.35M| st_.push(i, sp_); 438| 2.35M|} _ZN5boost4json11value_stack11push_uint64Em: 444| 2.86k|{ 445| 2.86k| st_.push(u, sp_); 446| 2.86k|} _ZN5boost4json11value_stack11push_doubleEd: 452| 30.3k|{ 453| 30.3k| st_.push(d, sp_); 454| 30.3k|} _ZN5boost4json11value_stack9push_boolEb: 460| 6.97k|{ 461| 6.97k| st_.push(b, sp_); 462| 6.97k|} _ZN5boost4json11value_stack9push_nullEv: 467| 2.56k|{ 468| 2.56k| st_.push(nullptr, sp_); 469| 2.56k|} _ZN5boost4json11value_stack5stackD2Ev: 26| 6.62k|{ 27| 6.62k| clear(); 28| 6.62k| if( begin_ != temp_ && ------------------ | Branch (28:9): [True: 553, False: 6.07k] ------------------ 29| 6.62k| begin_ != nullptr) ------------------ | Branch (29:9): [True: 553, False: 0] ------------------ 30| 553| sp_->deallocate( 31| 553| begin_, 32| 553| (end_ - begin_) * 33| 553| sizeof(value)); 34| 6.62k|} _ZN5boost4json11value_stack5stackC2ENS0_11storage_ptrEPvm: 44| 6.62k|{ 45| 6.62k| if(size >= min_size_ * ------------------ | Branch (45:8): [True: 6.62k, False: 0] ------------------ 46| 6.62k| sizeof(value)) 47| 6.62k| { 48| 6.62k| begin_ = reinterpret_cast< 49| 6.62k| value*>(temp); 50| 6.62k| top_ = begin_; 51| 6.62k| end_ = begin_ + 52| 6.62k| size / sizeof(value); 53| 6.62k| } 54| 0| else 55| 0| { 56| 0| begin_ = nullptr; 57| 0| top_ = nullptr; 58| 0| end_ = nullptr; 59| 0| } 60| 6.62k|} _ZN5boost4json11value_stack5stack5clearEv: 94| 19.8k|{ 95| 19.8k| if(top_ != begin_) ------------------ | Branch (95:8): [True: 2.35k, False: 17.5k] ------------------ 96| 2.35k| { 97| 2.35k| if(run_dtors_) ------------------ | Branch (97:12): [True: 2.35k, False: 0] ------------------ 98| 2.35k| for(auto it = top_; 99| 601k| it-- != begin_;) ------------------ | Branch (99:17): [True: 599k, False: 2.35k] ------------------ 100| 599k| it->~value(); 101| 2.35k| top_ = begin_; 102| 2.35k| } 103| 19.8k| chars_ = 0; 104| 19.8k|} _ZN5boost4json11value_stack5stack9run_dtorsEb: 66| 13.2k|{ 67| 13.2k| run_dtors_ = b; 68| 13.2k|} _ZN5boost4json11value_stack5stack7releaseEm: 252| 16.5k|{ 253| 16.5k| BOOST_ASSERT(n <= size()); ------------------ | | 60| 16.5k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 254| 16.5k| BOOST_ASSERT(chars_ == 0); ------------------ | | 60| 16.5k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 255| 16.5k| top_ -= n; 256| 16.5k| return top_; 257| 16.5k|} _ZN5boost4json11value_stack5stack10maybe_growEv: 110| 11.9k|{ 111| 11.9k| if(top_ >= end_) ------------------ | Branch (111:8): [True: 43, False: 11.9k] ------------------ 112| 43| grow_one(); 113| 11.9k|} _ZN5boost4json11value_stack5stack8grow_oneEv: 120| 810|{ 121| 810| BOOST_ASSERT(chars_ == 0); ------------------ | | 60| 810|# define BOOST_ASSERT(expr) assert(expr) ------------------ 122| 810| std::size_t const capacity = 123| 810| end_ - begin_; 124| 810| std::size_t new_cap = min_size_; 125| | // VFALCO check overflow here 126| 6.29k| while(new_cap < capacity + 1) ------------------ | Branch (126:11): [True: 5.48k, False: 810] ------------------ 127| 5.48k| new_cap <<= 1; 128| 810| auto const begin = 129| 810| reinterpret_cast( 130| 810| sp_->allocate( 131| 810| new_cap * sizeof(value))); 132| 810| if(begin_) ------------------ | Branch (132:8): [True: 810, False: 0] ------------------ 133| 810| { 134| 810| std::memcpy( 135| 810| reinterpret_cast(begin), 136| 810| reinterpret_cast(begin_), 137| 810| size() * sizeof(value)); 138| 810| if(begin_ != temp_) ------------------ | Branch (138:12): [True: 635, False: 175] ------------------ 139| 635| sp_->deallocate(begin_, 140| 635| capacity * sizeof(value)); 141| 810| } 142| | // book-keeping 143| 810| top_ = begin + (top_ - begin_); 144| 810| end_ = begin + new_cap; 145| 810| begin_ = begin; 146| 810|} _ZNK5boost4json11value_stack5stack4sizeEv: 74| 2.65k|{ 75| 2.65k| return top_ - begin_; 76| 2.65k|} _ZN5boost4json11value_stack5stack6appendENS_4core17basic_string_viewIcEE: 199| 19.7k|{ 200| 19.7k| std::size_t const bytes_avail = 201| 19.7k| reinterpret_cast< 202| 19.7k| char const*>(end_) - 203| 19.7k| reinterpret_cast< 204| 19.7k| char const*>(top_); 205| | // make sure there is room for 206| | // pushing one more value without 207| | // clobbering the string. 208| 19.7k| if(sizeof(value) + chars_ + ------------------ | Branch (208:8): [True: 920, False: 18.7k] ------------------ 209| 19.7k| s.size() > bytes_avail) 210| 920| grow(s.size()); 211| | 212| | // copy the new piece 213| 19.7k| std::memcpy( 214| 19.7k| reinterpret_cast( 215| 19.7k| top_ + 1) + chars_, 216| 19.7k| s.data(), s.size()); 217| 19.7k| chars_ += s.size(); 218| | 219| | // ensure a pushed value cannot 220| | // clobber the released string. 221| 19.7k| BOOST_ASSERT( ------------------ | | 60| 19.7k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 222| 19.7k| reinterpret_cast( 223| 19.7k| top_ + 1) + chars_ <= 224| 19.7k| reinterpret_cast( 225| 19.7k| end_)); 226| 19.7k|} _ZN5boost4json11value_stack5stack4growEm: 153| 920|{ 154| | // needed capacity in values 155| 920| std::size_t const needed = 156| 920| size() + 157| 920| 1 + 158| 920| ((chars_ + nchars + 159| 920| sizeof(value) - 1) / 160| 920| sizeof(value)); 161| 920| std::size_t const capacity = 162| 920| end_ - begin_; 163| 920| BOOST_ASSERT( ------------------ | | 60| 920|# define BOOST_ASSERT(expr) assert(expr) ------------------ 164| 920| needed > capacity); 165| 920| std::size_t new_cap = min_size_; 166| | // VFALCO check overflow here 167| 6.55k| while(new_cap < needed) ------------------ | Branch (167:11): [True: 5.63k, False: 920] ------------------ 168| 5.63k| new_cap <<= 1; 169| 920| auto const begin = 170| 920| reinterpret_cast( 171| 920| sp_->allocate( 172| 920| new_cap * sizeof(value))); 173| 920| if(begin_) ------------------ | Branch (173:8): [True: 920, False: 0] ------------------ 174| 920| { 175| 920| std::size_t amount = 176| 920| size() * sizeof(value); 177| 920| if(chars_ > 0) ------------------ | Branch (177:12): [True: 653, False: 267] ------------------ 178| 653| amount += sizeof(value) + chars_; 179| 920| std::memcpy( 180| 920| reinterpret_cast(begin), 181| 920| reinterpret_cast(begin_), 182| 920| amount); 183| 920| if(begin_ != temp_) ------------------ | Branch (183:12): [True: 542, False: 378] ------------------ 184| 542| sp_->deallocate(begin_, 185| 542| capacity * sizeof(value)); 186| 920| } 187| | // book-keeping 188| 920| top_ = begin + (top_ - begin_); 189| 920| end_ = begin + new_cap; 190| 920| begin_ = begin; 191| 920|} _ZN5boost4json11value_stack5stack9has_charsEv: 82| 898k|{ 83| 898k| return chars_ != 0; 84| 898k|} _ZN5boost4json11value_stack5stack14release_stringEv: 232| 11.6k|{ 233| | // ensure a pushed value cannot 234| | // clobber the released string. 235| 11.6k| BOOST_ASSERT( ------------------ | | 60| 11.6k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 236| 11.6k| reinterpret_cast( 237| 11.6k| top_ + 1) + chars_ <= 238| 11.6k| reinterpret_cast( 239| 11.6k| end_)); 240| 11.6k| auto const n = chars_; 241| 11.6k| chars_ = 0; 242| 11.6k| return { reinterpret_cast< 243| 11.6k| char const*>(top_ + 1), n }; 244| 11.6k|} _ZN5boost4json11value_stack5stack8exchangeINS0_6detail15unchecked_arrayEEEvOT_: 280| 1.98k|{ 281| 1.98k| BOOST_ASSERT(chars_ == 0); ------------------ | | 60| 1.98k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 282| 1.98k| union U 283| 1.98k| { 284| 1.98k| value v; 285| 1.98k| U() {} 286| 1.98k| ~U() {} 287| 1.98k| } jv; 288| | // construct value on the stack 289| | // to avoid clobbering top_[0], 290| | // which belongs to `u`. 291| 1.98k| detail::access:: 292| 1.98k| construct_value( 293| 1.98k| &jv.v, std::move(u)); 294| 1.98k| std::memcpy( 295| 1.98k| reinterpret_cast< 296| 1.98k| char*>(top_), 297| 1.98k| &jv.v, sizeof(value)); 298| 1.98k| ++top_; 299| 1.98k|} _ZZN5boost4json11value_stack5stack8exchangeINS0_6detail15unchecked_arrayEEEvOT_EN1UC2Ev: 285| 1.98k| U() {} _ZZN5boost4json11value_stack5stack8exchangeINS0_6detail15unchecked_arrayEEEvOT_EN1UD2Ev: 286| 1.98k| ~U() {} _ZN5boost4json11value_stack5stack8exchangeINS0_6detail16unchecked_objectEEEvOT_: 280| 12.5k|{ 281| 12.5k| BOOST_ASSERT(chars_ == 0); ------------------ | | 60| 12.5k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 282| 12.5k| union U 283| 12.5k| { 284| 12.5k| value v; 285| 12.5k| U() {} 286| 12.5k| ~U() {} 287| 12.5k| } jv; 288| | // construct value on the stack 289| | // to avoid clobbering top_[0], 290| | // which belongs to `u`. 291| 12.5k| detail::access:: 292| 12.5k| construct_value( 293| 12.5k| &jv.v, std::move(u)); 294| 12.5k| std::memcpy( 295| 12.5k| reinterpret_cast< 296| 12.5k| char*>(top_), 297| 12.5k| &jv.v, sizeof(value)); 298| 12.5k| ++top_; 299| 12.5k|} _ZZN5boost4json11value_stack5stack8exchangeINS0_6detail16unchecked_objectEEEvOT_EN1UC2Ev: 285| 12.5k| U() {} _ZZN5boost4json11value_stack5stack8exchangeINS0_6detail16unchecked_objectEEEvOT_EN1UD2Ev: 286| 12.5k| ~U() {} _ZN5boost4json11value_stack5stack4pushIJNS0_6detail5key_tERNS_4core17basic_string_viewIcEERNS0_11storage_ptrEEEERNS0_5valueEDpOT_: 264| 864k|{ 265| 864k| BOOST_ASSERT(chars_ == 0); ------------------ | | 60| 864k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 266| 864k| if(top_ >= end_) ------------------ | Branch (266:8): [True: 137, False: 864k] ------------------ 267| 137| grow_one(); 268| 864k| value& jv = detail::access:: 269| 864k| construct_value(top_, 270| 864k| std::forward(args)...); 271| 864k| ++top_; 272| 864k| return jv; 273| 864k|} _ZN5boost4json11value_stack5stack4pushIJNS0_6detail5key_tERNS_4core17basic_string_viewIcEES9_RNS0_11storage_ptrEEEERNS0_5valueEDpOT_: 264| 700|{ 265| 700| BOOST_ASSERT(chars_ == 0); ------------------ | | 60| 700|# define BOOST_ASSERT(expr) assert(expr) ------------------ 266| 700| if(top_ >= end_) ------------------ | Branch (266:8): [True: 0, False: 700] ------------------ 267| 0| grow_one(); 268| 700| value& jv = detail::access:: 269| 700| construct_value(top_, 270| 700| std::forward(args)...); 271| 700| ++top_; 272| 700| return jv; 273| 700|} _ZN5boost4json11value_stack5stack4pushIJRNS_4core17basic_string_viewIcEERNS0_11storage_ptrEEEERNS0_5valueEDpOT_: 264| 22.5k|{ 265| 22.5k| BOOST_ASSERT(chars_ == 0); ------------------ | | 60| 22.5k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 266| 22.5k| if(top_ >= end_) ------------------ | Branch (266:8): [True: 42, False: 22.4k] ------------------ 267| 42| grow_one(); 268| 22.5k| value& jv = detail::access:: 269| 22.5k| construct_value(top_, 270| 22.5k| std::forward(args)...); 271| 22.5k| ++top_; 272| 22.5k| return jv; 273| 22.5k|} _ZN5boost4json11value_stack5stack4pushIJRKNS0_13string_kind_tERNS0_11storage_ptrEEEERNS0_5valueEDpOT_: 264| 10.9k|{ 265| 10.9k| BOOST_ASSERT(chars_ == 0); ------------------ | | 60| 10.9k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 266| 10.9k| if(top_ >= end_) ------------------ | Branch (266:8): [True: 0, False: 10.9k] ------------------ 267| 0| grow_one(); 268| 10.9k| value& jv = detail::access:: 269| 10.9k| construct_value(top_, 270| 10.9k| std::forward(args)...); 271| 10.9k| ++top_; 272| 10.9k| return jv; 273| 10.9k|} _ZN5boost4json11value_stack5stack4pushIJRlRNS0_11storage_ptrEEEERNS0_5valueEDpOT_: 264| 2.35M|{ 265| 2.35M| BOOST_ASSERT(chars_ == 0); ------------------ | | 60| 2.35M|# define BOOST_ASSERT(expr) assert(expr) ------------------ 266| 2.35M| if(top_ >= end_) ------------------ | Branch (266:8): [True: 410, False: 2.35M] ------------------ 267| 410| grow_one(); 268| 2.35M| value& jv = detail::access:: 269| 2.35M| construct_value(top_, 270| 2.35M| std::forward(args)...); 271| 2.35M| ++top_; 272| 2.35M| return jv; 273| 2.35M|} _ZN5boost4json11value_stack5stack4pushIJRmRNS0_11storage_ptrEEEERNS0_5valueEDpOT_: 264| 2.86k|{ 265| 2.86k| BOOST_ASSERT(chars_ == 0); ------------------ | | 60| 2.86k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 266| 2.86k| if(top_ >= end_) ------------------ | Branch (266:8): [True: 43, False: 2.81k] ------------------ 267| 43| grow_one(); 268| 2.86k| value& jv = detail::access:: 269| 2.86k| construct_value(top_, 270| 2.86k| std::forward(args)...); 271| 2.86k| ++top_; 272| 2.86k| return jv; 273| 2.86k|} _ZN5boost4json11value_stack5stack4pushIJRdRNS0_11storage_ptrEEEERNS0_5valueEDpOT_: 264| 30.3k|{ 265| 30.3k| BOOST_ASSERT(chars_ == 0); ------------------ | | 60| 30.3k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 266| 30.3k| if(top_ >= end_) ------------------ | Branch (266:8): [True: 55, False: 30.2k] ------------------ 267| 55| grow_one(); 268| 30.3k| value& jv = detail::access:: 269| 30.3k| construct_value(top_, 270| 30.3k| std::forward(args)...); 271| 30.3k| ++top_; 272| 30.3k| return jv; 273| 30.3k|} _ZN5boost4json11value_stack5stack4pushIJRbRNS0_11storage_ptrEEEERNS0_5valueEDpOT_: 264| 6.97k|{ 265| 6.97k| BOOST_ASSERT(chars_ == 0); ------------------ | | 60| 6.97k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 266| 6.97k| if(top_ >= end_) ------------------ | Branch (266:8): [True: 40, False: 6.93k] ------------------ 267| 40| grow_one(); 268| 6.97k| value& jv = detail::access:: 269| 6.97k| construct_value(top_, 270| 6.97k| std::forward(args)...); 271| 6.97k| ++top_; 272| 6.97k| return jv; 273| 6.97k|} _ZN5boost4json11value_stack5stack4pushIJDnRNS0_11storage_ptrEEEERNS0_5valueEDpOT_: 264| 2.56k|{ 265| 2.56k| BOOST_ASSERT(chars_ == 0); ------------------ | | 60| 2.56k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 266| 2.56k| if(top_ >= end_) ------------------ | Branch (266:8): [True: 40, False: 2.52k] ------------------ 267| 40| grow_one(); 268| 2.56k| value& jv = detail::access:: 269| 2.56k| construct_value(top_, 270| 2.56k| std::forward(args)...); 271| 2.56k| ++top_; 272| 2.56k| return jv; 273| 2.56k|} _ZN5boost4json6parser5writeENS_4core17basic_string_viewIcEERNS_6system10error_codeE: 750| 6.62k| { 751| 6.62k| return write( 752| 6.62k| s.data(), s.size(), ec); 753| 6.62k| } _ZN5boost4json6parserD2Ev: 137| 6.62k| ~parser() = default; _ZN5boost4json6parserC2ILm4096EEENS0_11storage_ptrERKNS0_13parse_optionsERAT__h: 282| 6.62k| { 283| 6.62k| } _ZNK5boost4json8pilferedINS0_5valueEE3getEv: 78| 2.44M| { 79| 2.44M| return t_; 80| 2.44M| } _ZN5boost4json6pilferIRNS0_5valueEEENSt3__111conditionalIXaasr3std24is_nothrow_constructibleINS4_16remove_referenceIT_E4typeENS0_8pilferedIS9_EEEE5valuentsr3std24is_nothrow_constructibleIS9_NS0_13detail_pilfer12not_pilferedIS9_EEEE5valueESB_OS9_E4typeEOS7_: 187| 1.63M|{ 188| 1.63M| using U = 189| 1.63M| typename std::remove_reference::type; 190| 1.63M| static_assert( 191| 1.63M| is_pilfer_constructible::value, ""); 192| 1.63M| return typename std::conditional< 193| 1.63M| std::is_nothrow_constructible< 194| 1.63M| U, pilfered >::value && 195| 1.63M| ! std::is_nothrow_constructible< 196| 1.63M| U, detail_pilfer::not_pilfered >::value, 197| 1.63M| pilfered, U&& 198| 1.63M| >::type(std::move(t)); 199| 1.63M|} _ZN5boost4json8pilferedINS0_5valueEEC2EOS2_: 69| 1.63M| { 70| 1.63M| } _ZN5boost4json6pilferIRNS0_11storage_ptrEEENSt3__111conditionalIXaasr3std24is_nothrow_constructibleINS4_16remove_referenceIT_E4typeENS0_8pilferedIS9_EEEE5valuentsr3std24is_nothrow_constructibleIS9_NS0_13detail_pilfer12not_pilferedIS9_EEEE5valueESB_OS9_E4typeEOS7_: 187| 13.2k|{ 188| 13.2k| using U = 189| 13.2k| typename std::remove_reference::type; 190| 13.2k| static_assert( 191| 13.2k| is_pilfer_constructible::value, ""); 192| 13.2k| return typename std::conditional< 193| 13.2k| std::is_nothrow_constructible< 194| 13.2k| U, pilfered >::value && 195| 13.2k| ! std::is_nothrow_constructible< 196| 13.2k| U, detail_pilfer::not_pilfered >::value, 197| 13.2k| pilfered, U&& 198| 13.2k| >::type(std::move(t)); 199| 13.2k|} _ZNK5boost4json11storage_ptr6addrefEv: 108| 3.32M| { 109| 3.32M| if(is_shared()) ------------------ | Branch (109:12): [True: 0, False: 3.32M] ------------------ 110| 0| get_shared()->refs.fetch_add( 111| 0| 1, std::memory_order_relaxed); 112| 3.32M| } _ZN5boost4json11storage_ptrC2EOS1_: 264| 7.47M| { 265| 7.47M| } _ZN5boost4json11storage_ptrC2ERKS1_: 290| 3.32M| { 291| 3.32M| addref(); 292| 3.32M| } _ZN5boost4json11storage_ptraSEOS1_: 322| 1.99k| { 323| 1.99k| release(); 324| 1.99k| i_ = detail::exchange(other.i_, 0); 325| 1.99k| return *this; 326| 1.99k| } _ZNK5boost4json11storage_ptr39is_not_shared_and_deallocate_is_trivialEv: 396| 854k| { 397| 854k| return (i_ & 3) == 2; 398| 854k| } _ZNK5boost4json11storage_ptr3getEv: 413| 1.74M| { 414| 1.74M| if(i_ != 0) ------------------ | Branch (414:12): [True: 0, False: 1.74M] ------------------ 415| 0| return reinterpret_cast< 416| 0| memory_resource*>(i_ & ~3); 417| 1.74M| return default_resource::get(); 418| 1.74M| } _ZNK5boost4json11storage_ptrptEv: 433| 1.74M| { 434| 1.74M| return get(); 435| 1.74M| } _ZN5boost4json6stringD2Ev: 158| 83.5k| { 159| 83.5k| impl_.destroy(sp_); 160| 83.5k| } _ZN5boost4json6stringC2ENS0_11storage_ptrE: 225| 10.9k| { 226| 10.9k| } _ZN5boost4json6string6assignENS_4core17basic_string_viewIcEE: 836| 22.5k| { 837| 22.5k| return assign(s.data(), s.size()); 838| 22.5k| } _ZN5boost4json6string4dataEv: 1079| 21.9k| { 1080| 21.9k| return impl_.data(); 1081| 21.9k| } _ZNK5boost4json6string8capacityEv: 1454| 10.9k| { 1455| 10.9k| return impl_.capacity(); 1456| 10.9k| } _ZN5boost4json6string7reserveEm: 1489| 10.9k| { 1490| 10.9k| if(new_capacity <= capacity()) ------------------ | Branch (1490:12): [True: 9.81k, False: 1.14k] ------------------ 1491| 9.81k| return; 1492| 1.14k| reserve_impl(new_capacity); 1493| 1.14k| } _ZN5boost4json6string4growEm: 2361| 10.9k| { 2362| 10.9k| BOOST_ASSERT( ------------------ | | 60| 10.9k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2363| 10.9k| n <= impl_.capacity() - impl_.size()); 2364| 10.9k| impl_.term(impl_.size() + n); 2365| 10.9k| } _ZN5boost4json5valueC2EONS0_6detail15unchecked_arrayE: 81| 1.98k| { 82| 1.98k| } _ZN5boost4json5valueC2EONS0_6detail16unchecked_objectE: 88| 12.5k| { 89| 12.5k| } _ZN5boost4json5valueC2ERKNS0_6detail5key_tENS_4core17basic_string_viewIcEENS0_11storage_ptrE: 96| 864k| { 97| 864k| } _ZN5boost4json5valueC2ERKNS0_6detail5key_tENS_4core17basic_string_viewIcEES8_NS0_11storage_ptrE: 105| 700| { 106| 700| } _ZN5boost4json5valueC2ENS0_8pilferedIS1_EE: 200| 817k| { 201| 817k| relocate(this, other.get()); 202| 817k| ::new(&other.get().sca_) scalar(); 203| 817k| } _ZN5boost4json5valueC2EDnNS0_11storage_ptrE: 331| 7.19k| { 332| 7.19k| } _ZN5boost4json5valueC2ElNS0_11storage_ptrE: 453| 2.35M| { 454| 2.35M| } _ZN5boost4json5valueC2EmNS0_11storage_ptrE: 563| 2.86k| { 564| 2.86k| } _ZN5boost4json5valueC2EdNS0_11storage_ptrE: 606| 30.3k| { 607| 30.3k| } _ZN5boost4json5valueC2ENS_4core17basic_string_viewIcEENS0_11storage_ptrE: 631| 22.5k| { 632| 22.5k| } _ZN5boost4json5valueC2ENS0_13string_kind_tENS0_11storage_ptrE: 776| 10.9k| { 777| 10.9k| } _ZNK5boost4json5value7storageEv: 2467| 815k| { 2468| 815k| return sp_; 2469| 815k| } _ZNR5boost4json5value10get_stringEv: 2883| 10.9k| { 2884| 10.9k| BOOST_ASSERT(is_string()); ------------------ | | 60| 10.9k|# define BOOST_ASSERT(expr) assert(expr) ------------------ 2885| 10.9k| return str_; 2886| 10.9k| } _ZN5boost4json5value8relocateEPS1_RKS1_: 3539| 817k| { 3540| 817k| std::memcpy( 3541| 817k| static_cast(dest), 3542| 817k| &src, 3543| 817k| sizeof(src)); 3544| 817k| } _ZN5boost4json14key_value_pairD2Ev: 3722| 815k| { 3723| 815k| auto const& sp = value_.storage(); 3724| 815k| if(sp.is_not_shared_and_deallocate_is_trivial()) ------------------ | Branch (3724:12): [True: 0, False: 815k] ------------------ 3725| 0| return; 3726| 815k| if(key_ == empty_) ------------------ | Branch (3726:12): [True: 0, False: 815k] ------------------ 3727| 0| return; 3728| 815k| sp->deallocate(const_cast(key_), 3729| 815k| len_ + 1, alignof(char)); 3730| 815k| } _ZNK5boost4json14key_value_pair3keyEv: 3956| 2.44M| { 3957| 2.44M| return { key_, len_ }; 3958| 2.44M| } _ZN5boost4json5valueC2IbvEET_NS0_11storage_ptrE: 364| 6.97k| { 365| 6.97k| } _ZN5boost6system6detail11failed_implEiRKNS0_14error_categoryE: 210| 4.63k|{ 211| 4.63k| if( cat.id_ == system_category_id || cat.id_ == generic_category_id ) ------------------ | Branch (211:9): [True: 0, False: 4.63k] | Branch (211:42): [True: 0, False: 4.63k] ------------------ 212| 0| { 213| 0| return ev != 0; 214| 0| } 215| 4.63k| else 216| 4.63k| { 217| 4.63k| return cat.failed( ev ); 218| 4.63k| } 219| 4.63k|} _ZN5boost6system10error_codeC2EiRKNS0_14error_categoryE: 130| 4.63k| { 131| 4.63k| d1_.val_ = val; 132| 4.63k| d1_.cat_ = &cat; 133| 4.63k| } _ZN5boost6system10error_codeC2ERKS1_PKNS_15source_locationE: 155| 4.63k| { 156| 4.63k| *this = ec; 157| | 158| 4.63k| if( ec.lc_flags_ != 0 && ec.lc_flags_ != 1 ) ------------------ | Branch (158:13): [True: 4.63k, False: 0] | Branch (158:34): [True: 4.63k, False: 0] ------------------ 159| 4.63k| { 160| 4.63k| lc_flags_ = ( loc? reinterpret_cast( loc ): 2 ) | ( ec.lc_flags_ & 1 ); ------------------ | Branch (160:27): [True: 4.63k, False: 0] ------------------ 161| 4.63k| } 162| 4.63k| } _ZN5boost6system10error_code6assignERKS1_PKNS_15source_locationE: 199| 4.63k| { 200| 4.63k| *this = error_code( ec, loc ); 201| 4.63k| } _ZN5boost6system10error_codeC2INS_4json5errorEEET_PNS0_6detail9enable_ifIXoosr18is_error_code_enumIS5_EE5valuesr3std18is_error_code_enumIS5_EE5valueEvE4typeE: 149| 4.63k| { 150| 4.63k| *this = make_error_code( e ); 151| 4.63k| } _Z10fuzz_parseN5boost4core17basic_string_viewIcEE: 17| 6.62k|{ 18| 6.62k| error_code ec; 19| 6.62k| value jv = parse( sv, ec ); 20| 6.62k| if(ec) ------------------ | Branch (20:8): [True: 4.63k, False: 1.99k] ------------------ 21| 4.63k| return false; 22| 1.99k| return jv.is_number(); 23| 6.62k|} LLVMFuzzerTestOneInput: 29| 6.62k|{ 30| 6.62k| try 31| 6.62k| { 32| 6.62k| string_view s{reinterpret_cast< 33| 6.62k| const char*>(data), size}; 34| 6.62k| fuzz_parse(s); 35| 6.62k| } 36| 6.62k| catch(...) 37| 6.62k| { 38| 0| } 39| 6.62k| return 0; 40| 6.62k|} _ZN5boost4core17basic_string_viewIcEC2EPKcm: 380| 5.77M| { 381| 5.77M| } _ZN5boost4json11storage_ptrC2Ev: 170| 856k| { 171| 856k| } _ZN5boost4json11storage_ptrD2Ev: 151| 10.8M| { 152| 10.8M| release(); 153| 10.8M| } _ZNK5boost4json11storage_ptr7releaseEv: 116| 10.8M| { 117| 10.8M| if(is_shared()) ------------------ | Branch (117:12): [True: 0, False: 10.8M] ------------------ 118| 0| { 119| 0| auto const p = get_shared(); 120| 0| if(p->refs.fetch_sub(1, ------------------ | Branch (120:16): [True: 0, False: 0] ------------------ 121| 0| std::memory_order_acq_rel) == 1) 122| 0| delete p; 123| 0| } 124| 10.8M| } _ZNK5boost4json11storage_ptr9is_sharedEv: 368| 14.1M| { 369| 14.1M| return (i_ & 1) != 0; 370| 14.1M| } _ZNK5boost4json5value9is_numberEv: 1923| 1.99k| { 1924| | // VFALCO Could use bit 0x40 for this 1925| 1.99k| return 1926| 1.99k| kind() == json::kind::int64 || ------------------ | Branch (1926:13): [True: 261, False: 1.73k] ------------------ 1927| 1.99k| kind() == json::kind::uint64 || ------------------ | Branch (1927:13): [True: 76, False: 1.66k] ------------------ 1928| 1.99k| kind() == json::kind::double_; ------------------ | Branch (1928:13): [True: 1.14k, False: 520] ------------------ 1929| 1.99k| } _ZNK5boost4json5value4kindEv: 1684| 2.50M| { 1685| 2.50M| return static_cast( 1686| 2.50M| static_cast( 1687| 2.50M| sca_.k) & 0x3f); 1688| 2.50M| } _ZNK5boost6system14error_category6failedEi: 147| 4.63k| { 148| 4.63k| return ev != 0; 149| 4.63k| } _ZN5boost6system10error_codeC2Ev: 125| 26.5k| { 126| 26.5k| } _ZNK5boost6system10error_codecvbEv: 341| 38.2k| { 342| 38.2k| return failed(); 343| 38.2k| } _ZNK5boost6system10error_code6failedEv: 320| 38.2k| { 321| 38.2k| if( lc_flags_ & 1 ) ------------------ | Branch (321:13): [True: 19.6k, False: 18.5k] ------------------ 322| 19.6k| { 323| 19.6k|#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR) 324| 19.6k| if( lc_flags_ == 1 ) ------------------ | Branch (324:17): [True: 0, False: 19.6k] ------------------ 325| 0| { 326| 0| std::error_code const& ec = *reinterpret_cast( d2_ ); 327| 0| return ec.value() != 0; 328| 0| } 329| 19.6k|#endif 330| 19.6k| return true; 331| 19.6k| } 332| 18.5k| else 333| 18.5k| { 334| 18.5k| return false; 335| 18.5k| } 336| 38.2k| }