_ZN5boost11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEC2Ev: 338| 4| explicit basic_regex(){} _ZN5boost11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEED2Ev: 353| 1.69k| ~basic_regex(){} _ZN5boost11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE6assignEPKcj: 371| 3.39k| { 372| 3.39k| return assign(p, p + traits::length(p), f); 373| 3.39k| } _ZN5boost11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE6assignEPKcS7_j: 386| 3.39k| { 387| 3.39k| return do_assign(p1, p2, f); 388| 3.39k| } _ZN5boost11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE9do_assignEPKcS7_j: 636| 3.39k|{ 637| 3.39k| std::shared_ptr > temp; 638| 3.39k| if(!m_pimpl.get()) ------------------ | Branch (638:7): [True: 2, False: 3.39k] ------------------ 639| 2| { 640| 2| temp = std::shared_ptr >(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation()); ------------------ | | 158| 2|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 2|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 2|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 2|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 641| 2| } 642| 3.39k| else 643| 3.39k| { 644| 3.39k| temp = std::shared_ptr >(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation(m_pimpl->m_ptraits)); ------------------ | | 158| 3.39k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 3.39k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 3.39k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 3.39k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 645| 3.39k| } 646| 3.39k| temp->assign(p1, p2, f); 647| 3.39k| temp.swap(m_pimpl); 648| 3.39k| return *this; 649| 3.39k|} _ZN5boost13re_detail_50026basic_regex_implementationIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEC2Ev: 212| 2| basic_regex_implementation(){} _ZN5boost13re_detail_50010regex_dataIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEC2Ev: 172| 2| : m_ptraits(new ::boost::regex_traits_wrapper()), m_flags(0), m_status(0), m_expression(0), m_expression_len(0), 173| 2| m_mark_count(0), m_first_state(0), m_restart_type(0), 174| 2| m_startmap{ 0 }, 175| 2| m_can_be_null(0), m_word_mask(0), m_has_recursions(false), m_disable_match_any(false) {} _ZN5boost13re_detail_50020named_subexpressionsC2Ev: 111| 3.39k| named_subexpressions(){} _ZN5boost13re_detail_50026basic_regex_implementationIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEC2ERKNSt3__110shared_ptrINS_20regex_traits_wrapperIS5_EEEE: 215| 3.39k| : regex_data(t) {} _ZN5boost13re_detail_50010regex_dataIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEC2ERKNSt3__110shared_ptrINS_20regex_traits_wrapperIS5_EEEE: 167| 3.39k| : m_ptraits(t), m_flags(0), m_status(0), m_expression(0), m_expression_len(0), 168| 3.39k| m_mark_count(0), m_first_state(0), m_restart_type(0), 169| 3.39k| m_startmap{ 0 }, 170| 3.39k| m_can_be_null(0), m_word_mask(0), m_has_recursions(false), m_disable_match_any(false) {} _ZN5boost13re_detail_50026basic_regex_implementationIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE6assignEPKcS8_j: 219| 3.39k| { 220| 3.39k| regex_data* pdat = this; 221| 3.39k| basic_regex_parser parser(pdat); 222| 3.39k| parser.parse(arg_first, arg_last, f); 223| 3.39k| } _ZN5boost13re_detail_50028hash_value_from_capture_nameIPKcEEiT_S4_: 65| 187k|{ 66| 187k| std::size_t r = 0; 67| 289M| while (i != j) ------------------ | Branch (67:11): [True: 289M, False: 187k] ------------------ 68| 289M| { 69| 289M| r ^= *i + 0x9e3779b9 + (r << 6) + (r >> 2); 70| 289M| ++i; 71| 289M| } 72| 187k| r %= ((std::numeric_limits::max)()); 73| 187k| return static_cast(r) | hash_value_mask; 74| 187k|} _ZN5boost13re_detail_50020named_subexpressions4nameC2IcEEPKT_S6_i: 83| 187k| : index(idx) 84| 187k| { 85| 187k| hash = hash_value_from_capture_name(i, j); 86| 187k| } _ZN5boost11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEC2ERKS5_: 352| 1.69k| : m_pimpl(that.m_pimpl) {} _ZNK5boost11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE5flagsEv: 459| 162k| { 460| 162k| return m_pimpl.get() ? m_pimpl->flags() : 0; ------------------ | Branch (460:14): [True: 162k, False: 0] ------------------ 461| 162k| } _ZNK5boost13re_detail_50026basic_regex_implementationIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE5flagsEv: 261| 162k| { 262| 162k| return this->m_flags; 263| 162k| } _ZNK5boost11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE10get_traitsEv: 603| 106k| { 604| 106k| BOOST_REGEX_ASSERT(0 != m_pimpl.get()); ------------------ | | 58| 106k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 106k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 605| 106k| return m_pimpl->get_traits(); 606| 106k| } _ZNK5boost13re_detail_50026basic_regex_implementationIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE10get_traitsEv: 289| 106k| { 290| 106k| return *(this->m_ptraits); 291| 106k| } _ZNK5boost11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE5emptyEv: 510| 54.2k| { 511| 54.2k| return (m_pimpl.get() ? 0 != m_pimpl->status() : true); ------------------ | Branch (511:15): [True: 54.2k, False: 0] ------------------ 512| 54.2k| } _ZNK5boost13re_detail_50026basic_regex_implementationIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE6statusEv: 269| 54.2k| { 270| 54.2k| return this->m_status; 271| 54.2k| } _ZNK5boost11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE4sizeEv: 498| 54.2k| { 499| 54.2k| return (m_pimpl.get() ? m_pimpl->size() : 0); ------------------ | Branch (499:15): [True: 54.2k, False: 0] ------------------ 500| 54.2k| } _ZNK5boost13re_detail_50026basic_regex_implementationIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE4sizeEv: 265| 54.2k| { 266| 54.2k| return this->m_expression_len; 267| 54.2k| } _ZNK5boost11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE8get_dataEv: 613| 108k| { 614| 108k| BOOST_REGEX_ASSERT(0 != m_pimpl.get()); ------------------ | | 58| 108k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 108k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 615| 108k| return m_pimpl->get_data(); 616| 108k| } _ZNK5boost13re_detail_50026basic_regex_implementationIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE8get_dataEv: 297| 108k| { 298| 108k| basic_regex_implementation const* p = this; 299| 108k| return *static_cast*>(p); 300| 108k| } _ZNK5boost11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE7get_mapEv: 598| 54.2k| { 599| 54.2k| BOOST_REGEX_ASSERT(0 != m_pimpl.get()); ------------------ | | 58| 54.2k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 54.2k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 600| 54.2k| return m_pimpl->get_map(); 601| 54.2k| } _ZNK5boost13re_detail_50026basic_regex_implementationIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE7get_mapEv: 285| 54.2k| { 286| 54.2k| return this->m_startmap; 287| 54.2k| } _ZNK5boost11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE11can_be_nullEv: 608| 1.69k| { 609| 1.69k| BOOST_REGEX_ASSERT(0 != m_pimpl.get()); ------------------ | | 58| 1.69k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 1.69k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 610| 1.69k| return m_pimpl->can_be_null(); 611| 1.69k| } _ZNK5boost13re_detail_50026basic_regex_implementationIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE11can_be_nullEv: 293| 1.69k| { 294| 1.69k| return this->m_can_be_null; 295| 1.69k| } _ZNK5boost11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE15get_first_stateEv: 588| 106k| { 589| 106k| BOOST_REGEX_ASSERT(0 != m_pimpl.get()); ------------------ | | 58| 106k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 106k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 590| 106k| return m_pimpl->get_first_state(); 591| 106k| } _ZNK5boost13re_detail_50026basic_regex_implementationIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE15get_first_stateEv: 277| 106k| { 278| 106k| return this->m_first_state; 279| 106k| } _ZNK5boost11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE10mark_countEv: 515| 54.2k| { 516| 54.2k| return (m_pimpl.get() ? m_pimpl->mark_count() : 0); ------------------ | Branch (516:15): [True: 54.2k, False: 0] ------------------ 517| 54.2k| } _ZNK5boost13re_detail_50026basic_regex_implementationIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE10mark_countEv: 273| 54.2k| { 274| 54.2k| return this->m_mark_count - 1; 275| 54.2k| } _ZNK5boost11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE14get_named_subsEv: 618| 54.2k| { 619| 54.2k| return m_pimpl; 620| 54.2k| } _ZNK5boost11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE16get_restart_typeEv: 593| 54.2k| { 594| 54.2k| BOOST_REGEX_ASSERT(0 != m_pimpl.get()); ------------------ | | 58| 54.2k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 54.2k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 595| 54.2k| return m_pimpl->get_restart_type(); 596| 54.2k| } _ZNK5boost13re_detail_50026basic_regex_implementationIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE16get_restart_typeEv: 281| 54.2k| { 282| 54.2k| return this->m_restart_type; 283| 54.2k| } _ZNK5boost13re_detail_50020named_subexpressions11equal_rangeIcEENSt3__14pairINS3_11__wrap_iterIPKNS1_4nameEEES9_EEPKT_SD_: 132| 187k| { 133| 187k| name t(i, j, 0); 134| 187k| return std::equal_range(m_sub_names.begin(), m_sub_names.end(), t); 135| 187k| } _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEC2EPNS0_10regex_dataIcS5_EE: 262| 3.39k| : m_pdata(data), m_traits(*(data->m_ptraits)), m_last_state(0), m_icase(false), m_repeater_id(0), 263| 3.39k| m_has_backrefs(false), m_bad_repeats(0), m_has_recursions(false), m_word_mask(0), m_mask_space(0), m_lower_mask(0), m_upper_mask(0), m_alpha_mask(0) 264| 3.39k|{ 265| 3.39k| m_pdata->m_data.clear(); 266| 3.39k| m_pdata->m_status = ::boost::regex_constants::error_ok; 267| 3.39k| static const charT w = 'w'; 268| 3.39k| static const charT s = 's'; 269| 3.39k| static const charT l[5] = { 'l', 'o', 'w', 'e', 'r', }; 270| 3.39k| static const charT u[5] = { 'u', 'p', 'p', 'e', 'r', }; 271| 3.39k| static const charT a[5] = { 'a', 'l', 'p', 'h', 'a', }; 272| 3.39k| m_word_mask = m_traits.lookup_classname(&w, &w +1); 273| 3.39k| m_mask_space = m_traits.lookup_classname(&s, &s +1); 274| 3.39k| m_lower_mask = m_traits.lookup_classname(l, l + 5); 275| 3.39k| m_upper_mask = m_traits.lookup_classname(u, u + 5); 276| 3.39k| m_alpha_mask = m_traits.lookup_classname(a, a + 5); 277| 3.39k| m_pdata->m_word_mask = m_word_mask; 278| 3.39k| BOOST_REGEX_ASSERT(m_word_mask != 0); ------------------ | | 58| 3.39k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 3.39k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 279| 3.39k| BOOST_REGEX_ASSERT(m_mask_space != 0); ------------------ | | 58| 3.39k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 3.39k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 280| 3.39k| BOOST_REGEX_ASSERT(m_lower_mask != 0); ------------------ | | 58| 3.39k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 3.39k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 281| 3.39k| BOOST_REGEX_ASSERT(m_upper_mask != 0); ------------------ | | 58| 3.39k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 3.39k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 282| 3.39k| BOOST_REGEX_ASSERT(m_alpha_mask != 0); ------------------ | | 58| 3.39k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 3.39k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 283| 3.39k|} _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE4initEj: 204| 3.39k| { 205| 3.39k| m_pdata->m_flags = l_flags; 206| 3.39k| m_icase = l_flags & regex_constants::icase; 207| 3.39k| } _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE10getaddressEl: 196| 1.22M| { 197| 1.22M| return getaddress(off, m_pdata->m_data.data()); 198| 1.22M| } _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE12insert_stateElNS0_19syntax_element_typeEm: 306| 205k|{ 307| | // append a new state, start by aligning our last one: 308| 205k| m_pdata->m_data.align(); 309| | // set the offset to the next state in our last one: 310| 205k| if(m_last_state) ------------------ | Branch (310:7): [True: 205k, False: 0] ------------------ 311| 205k| m_last_state->next.i = m_pdata->m_data.size() - getoffset(m_last_state); 312| | // remember the last state position: 313| 205k| std::ptrdiff_t off = getoffset(m_last_state) + s; 314| | // now actually insert our data: 315| 205k| re_syntax_base* new_state = static_cast(m_pdata->m_data.insert(pos, s)); 316| | // fill in boilerplate options in the new state: 317| 205k| new_state->next.i = s; 318| 205k| new_state->type = t; 319| 205k| m_last_state = getaddress(off); 320| 205k| return new_state; 321| 205k|} _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE10getaddressElPv: 200| 2.34M| { 201| 2.34M| return static_cast(static_cast(static_cast(base) + off)); 202| 2.34M| } _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE9getoffsetEPv: 188| 2.18M| { 189| 2.18M| return getoffset(addr, m_pdata->m_data.data()); 190| 2.18M| } _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE9getoffsetEPKvS8_: 192| 2.18M| { 193| 2.18M| return static_cast(addr) - static_cast(base); 194| 2.18M| } _ZN5boost13re_detail_50014basic_char_setIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEC2Ev: 65| 23.7k| { 66| 23.7k| m_negate = false; 67| 23.7k| m_has_digraphs = false; 68| 23.7k| m_classes = 0; 69| 23.7k| m_negated_classes = 0; 70| 23.7k| m_empty = true; 71| 23.7k| } _ZN5boost13re_detail_50014basic_char_setIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE6negateEv: 117| 8.48k| { 118| 8.48k| m_negate = true; 119| | //m_empty = false; 120| 8.48k| } _ZN5boost13re_detail_50014basic_char_setIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE9add_classEj: 97| 15.2k| { 98| 15.2k| m_classes |= m; 99| 15.2k| m_empty = false; 100| 15.2k| } _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE10append_setERKNS0_14basic_char_setIcS5_EE: 351| 23.7k|{ 352| 23.7k| typedef std::integral_constant truth_type; 353| 23.7k| return char_set.has_digraphs() ------------------ | Branch (353:11): [True: 0, False: 23.7k] ------------------ 354| 23.7k| ? append_set(char_set, static_cast*>(0)) 355| 23.7k| : append_set(char_set, static_cast(0)); 356| 23.7k|} _ZNK5boost13re_detail_50014basic_char_setIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE12has_digraphsEv: 126| 23.7k| { 127| 23.7k| return m_has_digraphs; 128| 23.7k| } _ZNK5boost13re_detail_50014basic_char_setIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE13singles_beginEv: 136| 23.7k| { 137| 23.7k| return m_singles.begin(); 138| 23.7k| } _ZNK5boost13re_detail_50014basic_char_setIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE11singles_endEv: 140| 23.7k| { 141| 23.7k| return m_singles.end(); 142| 23.7k| } _ZNK5boost13re_detail_50014basic_char_setIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE12ranges_beginEv: 144| 23.7k| { 145| 23.7k| return m_ranges.begin(); 146| 23.7k| } _ZNK5boost13re_detail_50014basic_char_setIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE10ranges_endEv: 148| 23.7k| { 149| 23.7k| return m_ranges.end(); 150| 23.7k| } _ZNK5boost13re_detail_50014basic_char_setIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE17equivalents_beginEv: 152| 23.7k| { 153| 23.7k| return m_equivalents.begin(); 154| 23.7k| } _ZNK5boost13re_detail_50014basic_char_setIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE15equivalents_endEv: 156| 23.7k| { 157| 23.7k| return m_equivalents.end(); 158| 23.7k| } _ZNK5boost13re_detail_50014basic_char_setIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE7classesEv: 160| 23.7k| { 161| 23.7k| return m_classes; 162| 23.7k| } _ZNK5boost13re_detail_50014basic_char_setIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE15negated_classesEv: 164| 23.7k| { 165| 23.7k| return m_negated_classes; 166| 23.7k| } _ZNK5boost13re_detail_50014basic_char_setIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE10is_negatedEv: 130| 23.7k| { 131| 23.7k| return m_negate; 132| 23.7k| } _ZN5boost13re_detail_5007digraphIcEC2ERKS2_: 44| 25.4k| digraph(const digraph& d) : std::pair(d.first, d.second){} _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE10append_setERKNS0_14basic_char_setIcS5_EEPNSt3__117integral_constantIbLb1EEE: 520| 23.7k|{ 521| 23.7k| typedef typename traits::string_type string_type; 522| 23.7k| typedef typename basic_char_set::list_iterator item_iterator; 523| 23.7k| typedef typename basic_char_set::set_iterator set_iterator; 524| | 525| 23.7k| re_set* result = static_cast(append_state(syntax_element_set, sizeof(re_set))); 526| 23.7k| bool negate = char_set.is_negated(); 527| 23.7k| std::memset(result->_map, 0, sizeof(result->_map)); 528| | // 529| | // handle singles first: 530| | // 531| 23.7k| item_iterator first, last; 532| 23.7k| set_iterator sfirst, slast; 533| 23.7k| sfirst = char_set.singles_begin(); 534| 23.7k| slast = char_set.singles_end(); 535| 49.1k| while(sfirst != slast) ------------------ | Branch (535:10): [True: 25.4k, False: 23.7k] ------------------ 536| 25.4k| { 537| 6.53M| for(unsigned int i = 0; i < (1 << CHAR_BIT); ++i) ------------------ | Branch (537:31): [True: 6.51M, False: 25.4k] ------------------ 538| 6.51M| { 539| 6.51M| if(this->m_traits.translate(static_cast(i), this->m_icase) ------------------ | Branch (539:13): [True: 25.4k, False: 6.48M] ------------------ 540| 6.51M| == this->m_traits.translate(sfirst->first, this->m_icase)) 541| 25.4k| result->_map[i] = true; 542| 6.51M| } 543| 25.4k| ++sfirst; 544| 25.4k| } 545| | // 546| | // OK now handle ranges: 547| | // 548| 23.7k| first = char_set.ranges_begin(); 549| 23.7k| last = char_set.ranges_end(); 550| 23.7k| while(first != last) ------------------ | Branch (550:10): [True: 0, False: 23.7k] ------------------ 551| 0| { 552| | // first grab the endpoints of the range: 553| 0| charT c1 = this->m_traits.translate(first->first, this->m_icase); 554| 0| ++first; 555| 0| charT c2 = this->m_traits.translate(first->first, this->m_icase); 556| 0| ++first; 557| | // different actions now depending upon whether collation is turned on: 558| 0| if(flags() & regex_constants::collate) ------------------ | Branch (558:10): [True: 0, False: 0] ------------------ 559| 0| { 560| | // we need to transform our range into sort keys: 561| 0| charT c3[2] = { c1, charT(0), }; 562| 0| string_type s1 = this->m_traits.transform(c3, c3+1); 563| 0| c3[0] = c2; 564| 0| string_type s2 = this->m_traits.transform(c3, c3+1); 565| 0| if(s1 > s2) ------------------ | Branch (565:13): [True: 0, False: 0] ------------------ 566| 0| { 567| | // Oops error: 568| 0| return 0; 569| 0| } 570| 0| BOOST_REGEX_ASSERT(c3[1] == charT(0)); ------------------ | | 58| 0|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 0|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 571| 0| for(unsigned i = 0; i < (1u << CHAR_BIT); ++i) ------------------ | Branch (571:30): [True: 0, False: 0] ------------------ 572| 0| { 573| 0| c3[0] = static_cast(i); 574| 0| string_type s3 = this->m_traits.transform(c3, c3 +1); 575| 0| if((s1 <= s3) && (s3 <= s2)) ------------------ | Branch (575:16): [True: 0, False: 0] | Branch (575:30): [True: 0, False: 0] ------------------ 576| 0| result->_map[i] = true; 577| 0| } 578| 0| } 579| 0| else 580| 0| { 581| 0| if(char_less(c2, c1)) ------------------ | Branch (581:13): [True: 0, False: 0] ------------------ 582| 0| { 583| | // Oops error: 584| 0| return 0; 585| 0| } 586| | // everything in range matches: 587| 0| std::memset(result->_map + static_cast(c1), true, static_cast(1u) + static_cast(static_cast(c2) - static_cast(c1))); 588| 0| } 589| 0| } 590| | // 591| | // and now the classes: 592| | // 593| 23.7k| typedef typename traits::char_class_type m_type; 594| 23.7k| m_type m = char_set.classes(); 595| 23.7k| if(flags() & regbase::icase) ------------------ | Branch (595:7): [True: 0, False: 23.7k] ------------------ 596| 0| { 597| | // adjust m as needed: 598| 0| if(((m & m_lower_mask) == m_lower_mask) || ((m & m_upper_mask) == m_upper_mask)) ------------------ | Branch (598:10): [True: 0, False: 0] | Branch (598:50): [True: 0, False: 0] ------------------ 599| 0| m |= m_alpha_mask; 600| 0| } 601| 23.7k| if(m != 0) ------------------ | Branch (601:7): [True: 11.8k, False: 11.8k] ------------------ 602| 11.8k| { 603| 3.05M| for(unsigned i = 0; i < (1u << CHAR_BIT); ++i) ------------------ | Branch (603:27): [True: 3.03M, False: 11.8k] ------------------ 604| 3.03M| { 605| 3.03M| if(this->m_traits.isctype(static_cast(i), m)) ------------------ | Branch (605:13): [True: 412k, False: 2.62M] ------------------ 606| 412k| result->_map[i] = true; 607| 3.03M| } 608| 11.8k| } 609| | // 610| | // and now the negated classes: 611| | // 612| 23.7k| m = char_set.negated_classes(); 613| 23.7k| if(flags() & regbase::icase) ------------------ | Branch (613:7): [True: 0, False: 23.7k] ------------------ 614| 0| { 615| | // adjust m as needed: 616| 0| if(((m & m_lower_mask) == m_lower_mask) || ((m & m_upper_mask) == m_upper_mask)) ------------------ | Branch (616:10): [True: 0, False: 0] | Branch (616:50): [True: 0, False: 0] ------------------ 617| 0| m |= m_alpha_mask; 618| 0| } 619| 23.7k| if(m != 0) ------------------ | Branch (619:7): [True: 0, False: 23.7k] ------------------ 620| 0| { 621| 0| for(unsigned i = 0; i < (1u << CHAR_BIT); ++i) ------------------ | Branch (621:27): [True: 0, False: 0] ------------------ 622| 0| { 623| 0| if(0 == this->m_traits.isctype(static_cast(i), m)) ------------------ | Branch (623:13): [True: 0, False: 0] ------------------ 624| 0| result->_map[i] = true; 625| 0| } 626| 0| } 627| | // 628| | // now process the equivalence classes: 629| | // 630| 23.7k| sfirst = char_set.equivalents_begin(); 631| 23.7k| slast = char_set.equivalents_end(); 632| 23.7k| while(sfirst != slast) ------------------ | Branch (632:10): [True: 0, False: 23.7k] ------------------ 633| 0| { 634| 0| string_type s; 635| 0| BOOST_REGEX_ASSERT(static_cast(0) == sfirst->second); ------------------ | | 58| 0|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 0|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 636| 0| s = m_traits.transform_primary(&sfirst->first, &sfirst->first+1); 637| 0| if(s.empty()) ------------------ | Branch (637:10): [True: 0, False: 0] ------------------ 638| 0| return 0; // invalid or unsupported equivalence class 639| 0| for(unsigned i = 0; i < (1u << CHAR_BIT); ++i) ------------------ | Branch (639:27): [True: 0, False: 0] ------------------ 640| 0| { 641| 0| charT c[2] = { (static_cast(i)), charT(0), }; 642| 0| string_type s2 = this->m_traits.transform_primary(c, c+1); 643| 0| if(s == s2) ------------------ | Branch (643:13): [True: 0, False: 0] ------------------ 644| 0| result->_map[i] = true; 645| 0| } 646| 0| ++sfirst; 647| 0| } 648| 23.7k| if(negate) ------------------ | Branch (648:7): [True: 8.48k, False: 15.2k] ------------------ 649| 8.48k| { 650| 2.17M| for(unsigned i = 0; i < (1u << CHAR_BIT); ++i) ------------------ | Branch (650:27): [True: 2.17M, False: 8.48k] ------------------ 651| 2.17M| { 652| 2.17M| result->_map[i] = !(result->_map[i]); 653| 2.17M| } 654| 8.48k| } 655| 23.7k| return result; 656| 23.7k|} _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE14append_literalEc: 325| 1.00M|{ 326| 1.00M| re_literal* result; 327| | // start by seeing if we have an existing re_literal we can extend: 328| 1.00M| if((0 == m_last_state) || (m_last_state->type != syntax_element_literal)) ------------------ | Branch (328:7): [True: 0, False: 1.00M] | Branch (328:30): [True: 189k, False: 814k] ------------------ 329| 189k| { 330| | // no existing re_literal, create a new one: 331| 189k| result = static_cast(append_state(syntax_element_literal, sizeof(re_literal) + sizeof(charT))); 332| 189k| result->length = 1; 333| 189k| *static_cast(static_cast(result+1)) = m_traits.translate(c, m_icase); 334| 189k| } 335| 814k| else 336| 814k| { 337| | // we have an existing re_literal, extend it: 338| 814k| std::ptrdiff_t off = getoffset(m_last_state); 339| 814k| m_pdata->m_data.extend(sizeof(charT)); 340| 814k| m_last_state = result = static_cast(getaddress(off)); 341| 814k| charT* characters = static_cast(static_cast(result+1)); 342| 814k| characters[result->length] = m_traits.translate(c, m_icase); 343| 814k| result->length += 1; 344| 814k| } 345| 1.00M| return result; 346| 1.00M|} _ZN5boost13re_detail_5007digraphIcEC2Ev: 40| 25.4k| digraph() : std::pair(charT(0), charT(0)){} _ZNK5boost13re_detail_50014basic_char_setIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE5emptyEv: 168| 3.39k| { 169| 3.39k| return m_empty; 170| 3.39k| } _ZN5boost13re_detail_5007digraphIcEC2Ec: 41| 22.0k| digraph(charT c1) : std::pair(c1, charT(0)){} _ZN5boost13re_detail_5007digraphIcEaSERKS2_: 45| 22.0k| digraph& operator=(const digraph&) = default; _ZN5boost13re_detail_50014basic_char_setIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE10add_singleERKNS0_7digraphIcEE: 74| 25.4k| { 75| 25.4k| m_singles.insert(s); 76| 25.4k| if(s.second) ------------------ | Branch (76:10): [True: 0, False: 25.4k] ------------------ 77| 0| m_has_digraphs = true; 78| 25.4k| m_empty = false; 79| 25.4k| } _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE12append_stateENS0_19syntax_element_typeEm: 287| 503k|{ 288| | // if the state is a backref then make a note of it: 289| 503k| if(t == syntax_element_backref) ------------------ | Branch (289:7): [True: 0, False: 503k] ------------------ 290| 0| this->m_has_backrefs = true; 291| | // append a new state, start by aligning our last one: 292| 503k| m_pdata->m_data.align(); 293| | // set the offset to the next state in our last one: 294| 503k| if(m_last_state) ------------------ | Branch (294:7): [True: 500k, False: 3.39k] ------------------ 295| 500k| m_last_state->next.i = m_pdata->m_data.size() - getoffset(m_last_state); 296| | // now actually extend our data: 297| 503k| m_last_state = static_cast(m_pdata->m_data.extend(s)); 298| | // fill in boilerplate options in the new state: 299| 503k| m_last_state->next.i = 0; 300| 503k| m_last_state->type = t; 301| 503k| return m_last_state; 302| 503k|} _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE5flagsEv: 209| 1.33M| { 210| 1.33M| return m_pdata->m_flags; 211| 1.33M| } _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE5flagsEj: 213| 35.6k| { 214| 35.6k| m_pdata->m_flags = f; 215| 35.6k| if(m_icase != static_cast(f & regbase::icase)) ------------------ | Branch (215:10): [True: 0, False: 35.6k] ------------------ 216| 0| { 217| 0| m_icase = static_cast(f & regbase::icase); 218| 0| } 219| 35.6k| } _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE8finalizeEPKcS8_: 660| 3.39k|{ 661| 3.39k| if(this->m_pdata->m_status) ------------------ | Branch (661:7): [True: 0, False: 3.39k] ------------------ 662| 0| return; 663| | // we've added all the states we need, now finish things off. 664| | // start by adding a terminating state: 665| 3.39k| append_state(syntax_element_match); 666| | // extend storage to store original expression: 667| 3.39k| std::ptrdiff_t len = p2 - p1; 668| 3.39k| m_pdata->m_expression_len = len; 669| 3.39k| charT* ps = static_cast(m_pdata->m_data.extend(sizeof(charT) * (1 + (p2 - p1)))); 670| 3.39k| m_pdata->m_expression = ps; 671| 3.39k| BOOST_REGEX_DETAIL_NS::copy(p1, p2, ps); ------------------ | | 158| 3.39k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 3.39k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 3.39k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 3.39k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 672| 3.39k| ps[p2 - p1] = 0; 673| | // fill in our other data... 674| | // successful parsing implies a zero status: 675| 3.39k| m_pdata->m_status = 0; 676| | // get the first state of the machine: 677| 3.39k| m_pdata->m_first_state = static_cast(m_pdata->m_data.data()); 678| | // fixup pointers in the machine: 679| 3.39k| fixup_pointers(m_pdata->m_first_state); 680| 3.39k| if(m_has_recursions) ------------------ | Branch (680:7): [True: 0, False: 3.39k] ------------------ 681| 0| { 682| 0| m_pdata->m_has_recursions = true; 683| 0| fixup_recursions(m_pdata->m_first_state); 684| 0| if(this->m_pdata->m_status) ------------------ | Branch (684:10): [True: 0, False: 0] ------------------ 685| 0| return; 686| 0| } 687| 3.39k| else 688| 3.39k| m_pdata->m_has_recursions = false; 689| | // create nested startmaps: 690| 3.39k| create_startmaps(m_pdata->m_first_state); 691| | // create main startmap: 692| 3.39k| std::memset(m_pdata->m_startmap, 0, sizeof(m_pdata->m_startmap)); 693| 3.39k| m_pdata->m_can_be_null = 0; 694| | 695| 3.39k| m_bad_repeats = 0; 696| 3.39k| if(m_has_recursions) ------------------ | Branch (696:7): [True: 0, False: 3.39k] ------------------ 697| 0| m_recursion_checks.assign(1 + m_pdata->m_mark_count, 0u); 698| 3.39k| create_startmap(m_pdata->m_first_state, m_pdata->m_startmap, &(m_pdata->m_can_be_null), mask_all); 699| | // get the restart type: 700| 3.39k| m_pdata->m_restart_type = get_restart_type(m_pdata->m_first_state); 701| | // optimise a leading repeat if there is one: 702| 3.39k| probe_leading_repeat(m_pdata->m_first_state); 703| 3.39k|} _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE14fixup_pointersEPNS0_14re_syntax_baseE: 707| 3.39k|{ 708| 712k| while(state) ------------------ | Branch (708:10): [True: 708k, False: 3.39k] ------------------ 709| 708k| { 710| 708k| switch(state->type) 711| 708k| { 712| 0| case syntax_element_recurse: ------------------ | Branch (712:7): [True: 0, False: 708k] ------------------ 713| 0| m_has_recursions = true; 714| 0| if(state->next.i) ------------------ | Branch (714:13): [True: 0, False: 0] ------------------ 715| 0| state->next.p = getaddress(state->next.i, state); 716| 0| else 717| 0| state->next.p = 0; 718| 0| break; 719| 28.8k| case syntax_element_rep: ------------------ | Branch (719:7): [True: 28.8k, False: 680k] ------------------ 720| 28.8k| case syntax_element_dot_rep: ------------------ | Branch (720:7): [True: 0, False: 708k] ------------------ 721| 28.8k| case syntax_element_char_rep: ------------------ | Branch (721:7): [True: 0, False: 708k] ------------------ 722| 28.8k| case syntax_element_short_set_rep: ------------------ | Branch (722:7): [True: 0, False: 708k] ------------------ 723| 28.8k| case syntax_element_long_set_rep: ------------------ | Branch (723:7): [True: 0, False: 708k] ------------------ 724| | // set the state_id of this repeat: 725| 28.8k| static_cast(state)->state_id = m_repeater_id++; 726| 28.8k| BOOST_REGEX_FALLTHROUGH; ------------------ | | 127| 28.8k|# define BOOST_REGEX_FALLTHROUGH BOOST_FALLTHROUGH | | ------------------ | | | | 125| 28.8k|# define BOOST_FALLTHROUGH [[clang::fallthrough]] | | ------------------ ------------------ 727| 205k| case syntax_element_alt: ------------------ | Branch (727:7): [True: 176k, False: 532k] ------------------ 728| 205k| std::memset(static_cast(state)->_map, 0, sizeof(static_cast(state)->_map)); 729| 205k| static_cast(state)->can_be_null = 0; 730| 205k| BOOST_REGEX_FALLTHROUGH; ------------------ | | 127| 205k|# define BOOST_REGEX_FALLTHROUGH BOOST_FALLTHROUGH | | ------------------ | | | | 125| 205k|# define BOOST_FALLTHROUGH [[clang::fallthrough]] | | ------------------ ------------------ 731| 410k| case syntax_element_jump: ------------------ | Branch (731:7): [True: 205k, False: 503k] ------------------ 732| 410k| static_cast(state)->alt.p = getaddress(static_cast(state)->alt.i, state); 733| 410k| BOOST_REGEX_FALLTHROUGH; ------------------ | | 127| 410k|# define BOOST_REGEX_FALLTHROUGH BOOST_FALLTHROUGH | | ------------------ | | | | 125| 410k|# define BOOST_FALLTHROUGH [[clang::fallthrough]] | | ------------------ ------------------ 734| 708k| default: ------------------ | Branch (734:7): [True: 298k, False: 410k] ------------------ 735| 708k| if(state->next.i) ------------------ | Branch (735:13): [True: 705k, False: 3.39k] ------------------ 736| 705k| state->next.p = getaddress(state->next.i, state); 737| 3.39k| else 738| 3.39k| state->next.p = 0; 739| 708k| } 740| 708k| state = state->next.p; 741| 708k| } 742| 3.39k|} _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE16create_startmapsEPNS0_14re_syntax_baseE: 882| 3.39k|{ 883| | // non-recursive implementation: 884| | // create the last map in the machine first, so that earlier maps 885| | // can make use of the result... 886| | // 887| | // This was originally a recursive implementation, but that caused stack 888| | // overflows with complex expressions on small stacks (think COM+). 889| | 890| | // start by saving the case setting: 891| 3.39k| bool l_icase = m_icase; 892| 3.39k| std::vector > v; 893| | 894| 712k| while(state) ------------------ | Branch (894:10): [True: 708k, False: 3.39k] ------------------ 895| 708k| { 896| 708k| switch(state->type) 897| 708k| { 898| 0| case syntax_element_toggle_case: ------------------ | Branch (898:7): [True: 0, False: 708k] ------------------ 899| | // we need to track case changes here: 900| 0| m_icase = static_cast(state)->icase; 901| 0| state = state->next.p; 902| 0| continue; 903| 176k| case syntax_element_alt: ------------------ | Branch (903:7): [True: 176k, False: 532k] ------------------ 904| 205k| case syntax_element_rep: ------------------ | Branch (904:7): [True: 28.8k, False: 680k] ------------------ 905| 205k| case syntax_element_dot_rep: ------------------ | Branch (905:7): [True: 0, False: 708k] ------------------ 906| 205k| case syntax_element_char_rep: ------------------ | Branch (906:7): [True: 0, False: 708k] ------------------ 907| 205k| case syntax_element_short_set_rep: ------------------ | Branch (907:7): [True: 0, False: 708k] ------------------ 908| 205k| case syntax_element_long_set_rep: ------------------ | Branch (908:7): [True: 0, False: 708k] ------------------ 909| | // just push the state onto our stack for now: 910| 205k| v.push_back(std::pair(m_icase, state)); 911| 205k| state = state->next.p; 912| 205k| break; 913| 0| case syntax_element_backstep: ------------------ | Branch (913:7): [True: 0, False: 708k] ------------------ 914| | // we need to calculate how big the backstep is: 915| 0| static_cast(state)->index 916| 0| = this->calculate_backstep(state->next.p); 917| 0| if(static_cast(state)->index < 0) ------------------ | Branch (917:13): [True: 0, False: 0] ------------------ 918| 0| { 919| | // Oops error: 920| 0| if(0 == this->m_pdata->m_status) // update the error code if not already set ------------------ | Branch (920:16): [True: 0, False: 0] ------------------ 921| 0| this->m_pdata->m_status = boost::regex_constants::error_bad_pattern; 922| | // 923| | // clear the expression, we should be empty: 924| | // 925| 0| this->m_pdata->m_expression = 0; 926| 0| this->m_pdata->m_expression_len = 0; 927| | // 928| | // and throw if required: 929| | // 930| 0| if(0 == (this->flags() & regex_constants::no_except)) ------------------ | Branch (930:16): [True: 0, False: 0] ------------------ 931| 0| { 932| 0| std::string message = "Invalid lookbehind assertion encountered in the regular expression."; 933| 0| boost::regex_error e(message, boost::regex_constants::error_bad_pattern, 0); 934| 0| e.raise(); 935| 0| } 936| 0| } 937| 0| BOOST_REGEX_FALLTHROUGH; ------------------ | | 127| 0|# define BOOST_REGEX_FALLTHROUGH BOOST_FALLTHROUGH | | ------------------ | | | | 125| 0|# define BOOST_FALLTHROUGH [[clang::fallthrough]] | | ------------------ ------------------ 938| 503k| default: ------------------ | Branch (938:7): [True: 503k, False: 205k] ------------------ 939| 503k| state = state->next.p; 940| 708k| } 941| 708k| } 942| | 943| | // now work through our list, building all the maps as we go: 944| 208k| while(!v.empty()) ------------------ | Branch (944:10): [True: 205k, False: 3.39k] ------------------ 945| 205k| { 946| | // Initialize m_recursion_checks if we need it: 947| 205k| if(m_has_recursions) ------------------ | Branch (947:10): [True: 0, False: 205k] ------------------ 948| 0| m_recursion_checks.assign(1 + m_pdata->m_mark_count, 0u); 949| | 950| 205k| const std::pair& p = v.back(); 951| 205k| m_icase = p.first; 952| 205k| state = p.second; 953| 205k| v.pop_back(); 954| | 955| | // Build maps: 956| 205k| m_bad_repeats = 0; 957| 205k| create_startmap(state->next.p, static_cast(state)->_map, &static_cast(state)->can_be_null, mask_take); 958| 205k| m_bad_repeats = 0; 959| | 960| 205k| if(m_has_recursions) ------------------ | Branch (960:10): [True: 0, False: 205k] ------------------ 961| 0| m_recursion_checks.assign(1 + m_pdata->m_mark_count, 0u); 962| 205k| create_startmap(static_cast(state)->alt.p, static_cast(state)->_map, &static_cast(state)->can_be_null, mask_skip); 963| | // adjust the type of the state to allow for faster matching: 964| 205k| state->type = this->get_repeat_type(state); 965| 205k| } 966| | // restore case sensitivity: 967| 3.39k| m_icase = l_icase; 968| 3.39k|} _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE15get_repeat_typeEPNS0_14re_syntax_baseE: 1480| 205k|{ 1481| 205k| typedef typename traits::char_class_type m_type; 1482| 205k| if(state->type == syntax_element_rep) ------------------ | Branch (1482:7): [True: 28.8k, False: 176k] ------------------ 1483| 28.8k| { 1484| | // check to see if we are repeating a single state: 1485| 28.8k| if(state->next.p->next.p->next.p == static_cast(state)->alt.p) ------------------ | Branch (1485:10): [True: 18.6k, False: 10.1k] ------------------ 1486| 18.6k| { 1487| 18.6k| switch(state->next.p->type) 1488| 18.6k| { 1489| 1.69k| case BOOST_REGEX_DETAIL_NS::syntax_element_wild: ------------------ | | 158| 1.69k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 1.69k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 1.69k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 1.69k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1489:10): [True: 1.69k, False: 16.9k] ------------------ 1490| 1.69k| return BOOST_REGEX_DETAIL_NS::syntax_element_dot_rep; ------------------ | | 158| 1.69k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 1.69k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 1.69k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 1.69k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1491| 1.69k| case BOOST_REGEX_DETAIL_NS::syntax_element_literal: ------------------ | | 158| 1.69k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 1.69k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 1.69k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 1.69k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1491:10): [True: 1.69k, False: 16.9k] ------------------ 1492| 1.69k| return BOOST_REGEX_DETAIL_NS::syntax_element_char_rep; ------------------ | | 158| 1.69k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 1.69k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 1.69k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 1.69k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1493| 15.2k| case BOOST_REGEX_DETAIL_NS::syntax_element_set: ------------------ | | 158| 15.2k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 15.2k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 15.2k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 15.2k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1493:10): [True: 15.2k, False: 3.39k] ------------------ 1494| 15.2k| return BOOST_REGEX_DETAIL_NS::syntax_element_short_set_rep; ------------------ | | 158| 15.2k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 15.2k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 15.2k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 15.2k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1495| 0| case BOOST_REGEX_DETAIL_NS::syntax_element_long_set: ------------------ | | 158| 0|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 0|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 0|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 0|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1495:10): [True: 0, False: 18.6k] ------------------ 1496| 0| if(static_cast*>(state->next.p)->singleton) ------------------ | Branch (1496:16): [True: 0, False: 0] ------------------ 1497| 0| return BOOST_REGEX_DETAIL_NS::syntax_element_long_set_rep; ------------------ | | 158| 0|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 0|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 0|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 0|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1498| 0| break; 1499| 0| default: ------------------ | Branch (1499:10): [True: 0, False: 18.6k] ------------------ 1500| 0| break; 1501| 18.6k| } 1502| 18.6k| } 1503| 28.8k| } 1504| 186k| return state->type; 1505| 205k|} _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE15create_startmapEPNS0_14re_syntax_baseEPhPjh: 1078| 422k|{ 1079| 422k| recursion_saver saved_recursions(&m_recursion_checks); 1080| 422k| int not_last_jump = 1; 1081| 422k| re_syntax_base* recursion_start = 0; 1082| 422k| int recursion_sub = 0; 1083| 422k| re_syntax_base* recursion_restart = 0; 1084| | 1085| | // track case sensitivity: 1086| 422k| bool l_icase = m_icase; 1087| | 1088| 486k| while(state) ------------------ | Branch (1088:10): [True: 486k, False: 0] ------------------ 1089| 486k| { 1090| 486k| switch(state->type) 1091| 486k| { 1092| 0| case syntax_element_toggle_case: ------------------ | Branch (1092:7): [True: 0, False: 486k] ------------------ 1093| 0| l_icase = static_cast(state)->icase; 1094| 0| state = state->next.p; 1095| 0| break; 1096| 189k| case syntax_element_literal: ------------------ | Branch (1096:7): [True: 189k, False: 296k] ------------------ 1097| 189k| { 1098| | // don't set anything in *pnull, set each element in l_map 1099| | // that could match the first character in the literal: 1100| 189k| if(l_map) ------------------ | Branch (1100:13): [True: 189k, False: 0] ------------------ 1101| 189k| { 1102| 189k| l_map[0] |= mask_init; 1103| 189k| charT first_char = *static_cast(static_cast(static_cast(state) + 1)); 1104| 48.8M| for(unsigned int i = 0; i < (1u << CHAR_BIT); ++i) ------------------ | Branch (1104:37): [True: 48.6M, False: 189k] ------------------ 1105| 48.6M| { 1106| 48.6M| if(m_traits.translate(static_cast(i), l_icase) == first_char) ------------------ | Branch (1106:19): [True: 189k, False: 48.4M] ------------------ 1107| 189k| l_map[i] |= mask; 1108| 48.6M| } 1109| 189k| } 1110| 189k| return; 1111| 0| } 1112| 0| case syntax_element_end_line: ------------------ | Branch (1112:7): [True: 0, False: 486k] ------------------ 1113| 0| { 1114| | // next character must be a line separator (if there is one): 1115| 0| if(l_map) ------------------ | Branch (1115:13): [True: 0, False: 0] ------------------ 1116| 0| { 1117| 0| l_map[0] |= mask_init; 1118| 0| l_map[static_cast('\n')] |= mask; 1119| 0| l_map[static_cast('\r')] |= mask; 1120| 0| l_map[static_cast('\f')] |= mask; 1121| 0| l_map[0x85] |= mask; 1122| 0| } 1123| | // now figure out if we can match a NULL string at this point: 1124| 0| if(pnull) ------------------ | Branch (1124:13): [True: 0, False: 0] ------------------ 1125| 0| create_startmap(state->next.p, 0, pnull, mask); 1126| 0| return; 1127| 0| } 1128| 0| case syntax_element_recurse: ------------------ | Branch (1128:7): [True: 0, False: 486k] ------------------ 1129| 0| { 1130| 0| BOOST_REGEX_ASSERT(static_cast(state)->alt.p->type == syntax_element_startmark); ------------------ | | 58| 0|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 0|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 1131| 0| recursion_sub = static_cast(static_cast(state)->alt.p)->index; 1132| 0| if(m_recursion_checks[recursion_sub] & 1u) ------------------ | Branch (1132:16): [True: 0, False: 0] ------------------ 1133| 0| { 1134| | // Infinite recursion!! 1135| 0| if(0 == this->m_pdata->m_status) // update the error code if not already set ------------------ | Branch (1135:19): [True: 0, False: 0] ------------------ 1136| 0| this->m_pdata->m_status = boost::regex_constants::error_bad_pattern; 1137| | // 1138| | // clear the expression, we should be empty: 1139| | // 1140| 0| this->m_pdata->m_expression = 0; 1141| 0| this->m_pdata->m_expression_len = 0; 1142| | // 1143| | // and throw if required: 1144| | // 1145| 0| if(0 == (this->flags() & regex_constants::no_except)) ------------------ | Branch (1145:19): [True: 0, False: 0] ------------------ 1146| 0| { 1147| 0| std::string message = "Encountered an infinite recursion."; 1148| 0| boost::regex_error e(message, boost::regex_constants::error_bad_pattern, 0); 1149| 0| e.raise(); 1150| 0| } 1151| 0| } 1152| 0| else if(recursion_start == 0) ------------------ | Branch (1152:21): [True: 0, False: 0] ------------------ 1153| 0| { 1154| 0| recursion_start = state; 1155| 0| recursion_restart = state->next.p; 1156| 0| state = static_cast(state)->alt.p; 1157| 0| m_recursion_checks[recursion_sub] |= 1u; 1158| 0| break; 1159| 0| } 1160| 0| m_recursion_checks[recursion_sub] |= 1u; 1161| | // can't handle nested recursion here... 1162| 0| BOOST_REGEX_FALLTHROUGH; ------------------ | | 127| 0|# define BOOST_REGEX_FALLTHROUGH BOOST_FALLTHROUGH | | ------------------ | | | | 125| 0|# define BOOST_FALLTHROUGH [[clang::fallthrough]] | | ------------------ ------------------ 1163| 0| } 1164| 0| case syntax_element_backref: ------------------ | Branch (1164:7): [True: 0, False: 486k] ------------------ 1165| | // can be null, and any character can match: 1166| 0| if(pnull) ------------------ | Branch (1166:13): [True: 0, False: 0] ------------------ 1167| 0| *pnull |= mask; 1168| 0| BOOST_REGEX_FALLTHROUGH; ------------------ | | 127| 0|# define BOOST_REGEX_FALLTHROUGH BOOST_FALLTHROUGH | | ------------------ | | | | 125| 0|# define BOOST_FALLTHROUGH [[clang::fallthrough]] | | ------------------ ------------------ 1169| 1.69k| case syntax_element_wild: ------------------ | Branch (1169:7): [True: 1.69k, False: 485k] ------------------ 1170| 1.69k| { 1171| | // can't be null, any character can match: 1172| 1.69k| set_all_masks(l_map, mask); 1173| 1.69k| return; 1174| 0| } 1175| 0| case syntax_element_accept: ------------------ | Branch (1175:7): [True: 0, False: 486k] ------------------ 1176| 5.08k| case syntax_element_match: ------------------ | Branch (1176:7): [True: 5.08k, False: 481k] ------------------ 1177| 5.08k| { 1178| | // must be null, any character can match: 1179| 5.08k| set_all_masks(l_map, mask); 1180| 5.08k| if(pnull) ------------------ | Branch (1180:13): [True: 5.08k, False: 0] ------------------ 1181| 5.08k| *pnull |= mask; 1182| 5.08k| return; 1183| 0| } 1184| 3.39k| case syntax_element_word_start: ------------------ | Branch (1184:7): [True: 3.39k, False: 483k] ------------------ 1185| 3.39k| { 1186| | // recurse, then AND with all the word characters: 1187| 3.39k| create_startmap(state->next.p, l_map, pnull, mask); 1188| 3.39k| if(l_map) ------------------ | Branch (1188:13): [True: 3.39k, False: 0] ------------------ 1189| 3.39k| { 1190| 3.39k| l_map[0] |= mask_init; 1191| 871k| for(unsigned int i = 0; i < (1u << CHAR_BIT); ++i) ------------------ | Branch (1191:37): [True: 868k, False: 3.39k] ------------------ 1192| 868k| { 1193| 868k| if(!m_traits.isctype(static_cast(i), m_word_mask)) ------------------ | Branch (1193:19): [True: 654k, False: 213k] ------------------ 1194| 654k| l_map[i] &= static_cast(~mask); 1195| 868k| } 1196| 3.39k| } 1197| 3.39k| return; 1198| 0| } 1199| 1.69k| case syntax_element_word_end: ------------------ | Branch (1199:7): [True: 1.69k, False: 485k] ------------------ 1200| 1.69k| { 1201| | // recurse, then AND with all the word characters: 1202| 1.69k| create_startmap(state->next.p, l_map, pnull, mask); 1203| 1.69k| if(l_map) ------------------ | Branch (1203:13): [True: 1.69k, False: 0] ------------------ 1204| 1.69k| { 1205| 1.69k| l_map[0] |= mask_init; 1206| 435k| for(unsigned int i = 0; i < (1u << CHAR_BIT); ++i) ------------------ | Branch (1206:37): [True: 434k, False: 1.69k] ------------------ 1207| 434k| { 1208| 434k| if(m_traits.isctype(static_cast(i), m_word_mask)) ------------------ | Branch (1208:19): [True: 106k, False: 327k] ------------------ 1209| 106k| l_map[i] &= static_cast(~mask); 1210| 434k| } 1211| 1.69k| } 1212| 1.69k| return; 1213| 0| } 1214| 0| case syntax_element_buffer_end: ------------------ | Branch (1214:7): [True: 0, False: 486k] ------------------ 1215| 0| { 1216| | // we *must be null* : 1217| 0| if(pnull) ------------------ | Branch (1217:13): [True: 0, False: 0] ------------------ 1218| 0| *pnull |= mask; 1219| 0| return; 1220| 0| } 1221| 0| case syntax_element_long_set: ------------------ | Branch (1221:7): [True: 0, False: 486k] ------------------ 1222| 0| if(l_map) ------------------ | Branch (1222:13): [True: 0, False: 0] ------------------ 1223| 0| { 1224| 0| typedef typename traits::char_class_type m_type; 1225| 0| if(static_cast*>(state)->singleton) ------------------ | Branch (1225:16): [True: 0, False: 0] ------------------ 1226| 0| { 1227| 0| l_map[0] |= mask_init; 1228| 0| for(unsigned int i = 0; i < (1u << CHAR_BIT); ++i) ------------------ | Branch (1228:40): [True: 0, False: 0] ------------------ 1229| 0| { 1230| 0| charT c = static_cast(i); 1231| 0| if(&c != re_is_set_member(&c, &c + 1, static_cast*>(state), *m_pdata, l_icase)) ------------------ | Branch (1231:22): [True: 0, False: 0] ------------------ 1232| 0| l_map[i] |= mask; 1233| 0| } 1234| 0| } 1235| 0| else 1236| 0| set_all_masks(l_map, mask); 1237| 0| } 1238| 0| return; 1239| 25.4k| case syntax_element_set: ------------------ | Branch (1239:7): [True: 25.4k, False: 461k] ------------------ 1240| 25.4k| if(l_map) ------------------ | Branch (1240:13): [True: 25.4k, False: 0] ------------------ 1241| 25.4k| { 1242| 25.4k| l_map[0] |= mask_init; 1243| 6.53M| for(unsigned int i = 0; i < (1u << CHAR_BIT); ++i) ------------------ | Branch (1243:37): [True: 6.51M, False: 25.4k] ------------------ 1244| 6.51M| { 1245| 6.51M| if(static_cast(state)->_map[ ------------------ | Branch (1245:19): [True: 2.26M, False: 4.24M] ------------------ 1246| 6.51M| static_cast(m_traits.translate(static_cast(i), l_icase))]) 1247| 2.26M| l_map[i] |= mask; 1248| 6.51M| } 1249| 25.4k| } 1250| 25.4k| return; 1251| 10.1k| case syntax_element_jump: ------------------ | Branch (1251:7): [True: 10.1k, False: 476k] ------------------ 1252| | // take the jump: 1253| 10.1k| state = static_cast(state)->alt.p; 1254| 10.1k| not_last_jump = -1; 1255| 10.1k| break; 1256| 174k| case syntax_element_alt: ------------------ | Branch (1256:7): [True: 174k, False: 312k] ------------------ 1257| 181k| case syntax_element_rep: ------------------ | Branch (1257:7): [True: 6.78k, False: 479k] ------------------ 1258| 181k| case syntax_element_dot_rep: ------------------ | Branch (1258:7): [True: 0, False: 486k] ------------------ 1259| 186k| case syntax_element_char_rep: ------------------ | Branch (1259:7): [True: 5.08k, False: 481k] ------------------ 1260| 195k| case syntax_element_short_set_rep: ------------------ | Branch (1260:7): [True: 8.48k, False: 478k] ------------------ 1261| 195k| case syntax_element_long_set_rep: ------------------ | Branch (1261:7): [True: 0, False: 486k] ------------------ 1262| 195k| { 1263| 195k| re_alt* rep = static_cast(state); 1264| 195k| if(rep->_map[0] & mask_init) ------------------ | Branch (1264:16): [True: 193k, False: 1.69k] ------------------ 1265| 193k| { 1266| 193k| if(l_map) ------------------ | Branch (1266:19): [True: 193k, False: 0] ------------------ 1267| 193k| { 1268| | // copy previous results: 1269| 193k| l_map[0] |= mask_init; 1270| 49.6M| for(unsigned int i = 0; i <= UCHAR_MAX; ++i) ------------------ | Branch (1270:43): [True: 49.4M, False: 193k] ------------------ 1271| 49.4M| { 1272| 49.4M| if(rep->_map[i] & mask_any) ------------------ | Branch (1272:25): [True: 6.88M, False: 42.6M] ------------------ 1273| 6.88M| l_map[i] |= mask; 1274| 49.4M| } 1275| 193k| } 1276| 193k| if(pnull) ------------------ | Branch (1276:19): [True: 193k, False: 0] ------------------ 1277| 193k| { 1278| 193k| if(rep->can_be_null & mask_any) ------------------ | Branch (1278:22): [True: 22.0k, False: 171k] ------------------ 1279| 22.0k| *pnull |= mask; 1280| 193k| } 1281| 193k| } 1282| 1.69k| else 1283| 1.69k| { 1284| | // we haven't created a startmap for this alternative yet 1285| | // so take the union of the two options: 1286| 1.69k| if(is_bad_repeat(state)) ------------------ | Branch (1286:19): [True: 0, False: 1.69k] ------------------ 1287| 0| { 1288| 0| set_all_masks(l_map, mask); 1289| 0| if(pnull) ------------------ | Branch (1289:22): [True: 0, False: 0] ------------------ 1290| 0| *pnull |= mask; 1291| 0| return; 1292| 0| } 1293| 1.69k| set_bad_repeat(state); 1294| 1.69k| create_startmap(state->next.p, l_map, pnull, mask); 1295| 1.69k| if((state->type == syntax_element_alt) ------------------ | Branch (1295:19): [True: 0, False: 1.69k] ------------------ 1296| 1.69k| || (static_cast(state)->min == 0) ------------------ | Branch (1296:22): [True: 1.69k, False: 0] ------------------ 1297| 1.69k| || (not_last_jump == 0)) ------------------ | Branch (1297:22): [True: 0, False: 0] ------------------ 1298| 1.69k| create_startmap(rep->alt.p, l_map, pnull, mask); 1299| 1.69k| } 1300| 195k| } 1301| 195k| return; 1302| 195k| case syntax_element_soft_buffer_end: ------------------ | Branch (1302:7): [True: 0, False: 486k] ------------------ 1303| | // match newline or null: 1304| 0| if(l_map) ------------------ | Branch (1304:13): [True: 0, False: 0] ------------------ 1305| 0| { 1306| 0| l_map[0] |= mask_init; 1307| 0| l_map[static_cast('\n')] |= mask; 1308| 0| l_map[static_cast('\r')] |= mask; 1309| 0| } 1310| 0| if(pnull) ------------------ | Branch (1310:13): [True: 0, False: 0] ------------------ 1311| 0| *pnull |= mask; 1312| 0| return; 1313| 16.9k| case syntax_element_endmark: ------------------ | Branch (1313:7): [True: 16.9k, False: 469k] ------------------ 1314| | // need to handle independent subs as a special case: 1315| 16.9k| if(static_cast(state)->index < 0) ------------------ | Branch (1315:13): [True: 0, False: 16.9k] ------------------ 1316| 0| { 1317| | // can be null, any character can match: 1318| 0| set_all_masks(l_map, mask); 1319| 0| if(pnull) ------------------ | Branch (1319:16): [True: 0, False: 0] ------------------ 1320| 0| *pnull |= mask; 1321| 0| return; 1322| 0| } 1323| 16.9k| else if(recursion_start && (recursion_sub != 0) && (recursion_sub == static_cast(state)->index)) ------------------ | Branch (1323:18): [True: 0, False: 16.9k] | Branch (1323:37): [True: 0, False: 0] | Branch (1323:61): [True: 0, False: 0] ------------------ 1324| 0| { 1325| | // recursion termination: 1326| 0| recursion_start = 0; 1327| 0| state = recursion_restart; 1328| 0| break; 1329| 0| } 1330| | 1331| | // 1332| | // Normally we just go to the next state... but if this sub-expression is 1333| | // the target of a recursion, then we might be ending a recursion, in which 1334| | // case we should check whatever follows that recursion, as well as whatever 1335| | // follows this state: 1336| | // 1337| 16.9k| if(m_pdata->m_has_recursions && static_cast(state)->index) ------------------ | Branch (1337:13): [True: 0, False: 16.9k] | Branch (1337:42): [True: 0, False: 0] ------------------ 1338| 0| { 1339| 0| bool ok = false; 1340| 0| re_syntax_base* p = m_pdata->m_first_state; 1341| 0| while(p) ------------------ | Branch (1341:19): [True: 0, False: 0] ------------------ 1342| 0| { 1343| 0| if(p->type == syntax_element_recurse) ------------------ | Branch (1343:19): [True: 0, False: 0] ------------------ 1344| 0| { 1345| 0| re_brace* p2 = static_cast(static_cast(p)->alt.p); 1346| 0| if((p2->type == syntax_element_startmark) && (p2->index == static_cast(state)->index)) ------------------ | Branch (1346:22): [True: 0, False: 0] | Branch (1346:64): [True: 0, False: 0] ------------------ 1347| 0| { 1348| 0| ok = true; 1349| 0| break; 1350| 0| } 1351| 0| } 1352| 0| p = p->next.p; 1353| 0| } 1354| 0| if(ok && ((m_recursion_checks[static_cast(state)->index] & 2u) == 0)) ------------------ | Branch (1354:16): [True: 0, False: 0] | Branch (1354:22): [True: 0, False: 0] ------------------ 1355| 0| { 1356| 0| m_recursion_checks[static_cast(state)->index] |= 2u; 1357| 0| create_startmap(p->next.p, l_map, pnull, mask); 1358| 0| } 1359| 0| } 1360| 16.9k| state = state->next.p; 1361| 16.9k| break; 1362| | 1363| 0| case syntax_element_commit: ------------------ | Branch (1363:7): [True: 0, False: 486k] ------------------ 1364| 0| set_all_masks(l_map, mask); 1365| | // Continue scanning so we can figure out whether we can be null: 1366| 0| state = state->next.p; 1367| 0| break; 1368| 35.6k| case syntax_element_startmark: ------------------ | Branch (1368:7): [True: 35.6k, False: 451k] ------------------ 1369| | // need to handle independent subs as a special case: 1370| 35.6k| if(static_cast(state)->index == -3) ------------------ | Branch (1370:13): [True: 0, False: 35.6k] ------------------ 1371| 0| { 1372| 0| state = state->next.p->next.p; 1373| 0| break; 1374| 0| } 1375| 35.6k| BOOST_REGEX_FALLTHROUGH; ------------------ | | 127| 35.6k|# define BOOST_REGEX_FALLTHROUGH BOOST_FALLTHROUGH | | ------------------ | | | | 125| 35.6k|# define BOOST_FALLTHROUGH [[clang::fallthrough]] | | ------------------ ------------------ 1376| 37.3k| default: ------------------ | Branch (1376:7): [True: 1.69k, False: 485k] ------------------ 1377| 37.3k| state = state->next.p; 1378| 486k| } 1379| 64.4k| ++not_last_jump; 1380| 64.4k| } 1381| 422k|} _ZN5boost13re_detail_50015recursion_saverC2EPNSt3__16vectorIhNS2_9allocatorIhEEEE: 1069| 422k| recursion_saver(std::vector* p) : saved_state(*p), state(p) {} _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE13set_all_masksEPhh: 1415| 6.78k|{ 1416| | // 1417| | // set mask in all of bits elements, 1418| | // if bits[0] has mask_init not set then we can 1419| | // optimise this to a call to memset: 1420| | // 1421| 6.78k| if(bits) ------------------ | Branch (1421:7): [True: 6.78k, False: 0] ------------------ 1422| 6.78k| { 1423| 6.78k| if(bits[0] == 0) ------------------ | Branch (1423:10): [True: 1.69k, False: 5.08k] ------------------ 1424| 1.69k| (std::memset)(bits, mask, 1u << CHAR_BIT); 1425| 5.08k| else 1426| 5.08k| { 1427| 1.30M| for(unsigned i = 0; i < (1u << CHAR_BIT); ++i) ------------------ | Branch (1427:30): [True: 1.30M, False: 5.08k] ------------------ 1428| 1.30M| bits[i] |= mask; 1429| 5.08k| } 1430| 6.78k| bits[0] |= mask_init; 1431| 6.78k| } 1432| 6.78k|} _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE13is_bad_repeatEPNS0_14re_syntax_baseE: 1436| 1.69k|{ 1437| 1.69k| switch(pt->type) 1438| 1.69k| { 1439| 1.69k| case syntax_element_rep: ------------------ | Branch (1439:4): [True: 1.69k, False: 0] ------------------ 1440| 1.69k| case syntax_element_dot_rep: ------------------ | Branch (1440:4): [True: 0, False: 1.69k] ------------------ 1441| 1.69k| case syntax_element_char_rep: ------------------ | Branch (1441:4): [True: 0, False: 1.69k] ------------------ 1442| 1.69k| case syntax_element_short_set_rep: ------------------ | Branch (1442:4): [True: 0, False: 1.69k] ------------------ 1443| 1.69k| case syntax_element_long_set_rep: ------------------ | Branch (1443:4): [True: 0, False: 1.69k] ------------------ 1444| 1.69k| { 1445| 1.69k| unsigned state_id = static_cast(pt)->state_id; 1446| 1.69k| if(state_id >= sizeof(m_bad_repeats) * CHAR_BIT) ------------------ | Branch (1446:13): [True: 0, False: 1.69k] ------------------ 1447| 0| return true; // run out of bits, assume we can't traverse this one. 1448| 1.69k| static const std::uintmax_t one = 1uL; 1449| 1.69k| return m_bad_repeats & (one << state_id); 1450| 1.69k| } 1451| 0| default: ------------------ | Branch (1451:4): [True: 0, False: 1.69k] ------------------ 1452| 0| return false; 1453| 1.69k| } 1454| 1.69k|} _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE14set_bad_repeatEPNS0_14re_syntax_baseE: 1458| 1.69k|{ 1459| 1.69k| switch(pt->type) 1460| 1.69k| { 1461| 1.69k| case syntax_element_rep: ------------------ | Branch (1461:4): [True: 1.69k, False: 0] ------------------ 1462| 1.69k| case syntax_element_dot_rep: ------------------ | Branch (1462:4): [True: 0, False: 1.69k] ------------------ 1463| 1.69k| case syntax_element_char_rep: ------------------ | Branch (1463:4): [True: 0, False: 1.69k] ------------------ 1464| 1.69k| case syntax_element_short_set_rep: ------------------ | Branch (1464:4): [True: 0, False: 1.69k] ------------------ 1465| 1.69k| case syntax_element_long_set_rep: ------------------ | Branch (1465:4): [True: 0, False: 1.69k] ------------------ 1466| 1.69k| { 1467| 1.69k| unsigned state_id = static_cast(pt)->state_id; 1468| 1.69k| static const std::uintmax_t one = 1uL; 1469| 1.69k| if(state_id <= sizeof(m_bad_repeats) * CHAR_BIT) ------------------ | Branch (1469:13): [True: 1.69k, False: 0] ------------------ 1470| 1.69k| m_bad_repeats |= (one << state_id); 1471| 1.69k| } 1472| 1.69k| break; 1473| 0| default: ------------------ | Branch (1473:4): [True: 0, False: 1.69k] ------------------ 1474| 0| break; 1475| 1.69k| } 1476| 1.69k|} _ZN5boost13re_detail_50015recursion_saverD2Ev: 1071| 422k| { 1072| 422k| state->swap(saved_state); 1073| 422k| } _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE16get_restart_typeEPNS0_14re_syntax_baseE: 1385| 3.39k|{ 1386| | // 1387| | // find out how the machine starts, so we can optimise the search: 1388| | // 1389| 6.78k| while(state) ------------------ | Branch (1389:10): [True: 3.39k, False: 3.39k] ------------------ 1390| 3.39k| { 1391| 3.39k| switch(state->type) 1392| 3.39k| { 1393| 0| case syntax_element_startmark: ------------------ | Branch (1393:7): [True: 0, False: 3.39k] ------------------ 1394| 0| case syntax_element_endmark: ------------------ | Branch (1394:7): [True: 0, False: 3.39k] ------------------ 1395| 0| state = state->next.p; 1396| 0| continue; 1397| 0| case syntax_element_start_line: ------------------ | Branch (1397:7): [True: 0, False: 3.39k] ------------------ 1398| 0| return regbase::restart_line; 1399| 0| case syntax_element_word_start: ------------------ | Branch (1399:7): [True: 0, False: 3.39k] ------------------ 1400| 0| return regbase::restart_word; 1401| 0| case syntax_element_buffer_start: ------------------ | Branch (1401:7): [True: 0, False: 3.39k] ------------------ 1402| 0| return regbase::restart_buf; 1403| 0| case syntax_element_restart_continue: ------------------ | Branch (1403:7): [True: 0, False: 3.39k] ------------------ 1404| 0| return regbase::restart_continue; 1405| 3.39k| default: ------------------ | Branch (1405:7): [True: 3.39k, False: 0] ------------------ 1406| 3.39k| state = 0; 1407| 3.39k| continue; 1408| 3.39k| } 1409| 3.39k| } 1410| 3.39k| return regbase::restart_any; 1411| 3.39k|} _ZN5boost13re_detail_50019basic_regex_creatorIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE20probe_leading_repeatEPNS0_14re_syntax_baseE: 1509| 3.39k|{ 1510| | // enumerate our states, and see if we have a leading repeat 1511| | // for which failed search restarts can be optimized; 1512| 3.39k| do 1513| 3.39k| { 1514| 3.39k| switch(state->type) 1515| 3.39k| { 1516| 0| case syntax_element_startmark: ------------------ | Branch (1516:7): [True: 0, False: 3.39k] ------------------ 1517| 0| if(static_cast(state)->index >= 0) ------------------ | Branch (1517:13): [True: 0, False: 0] ------------------ 1518| 0| { 1519| 0| state = state->next.p; 1520| 0| continue; 1521| 0| } 1522| |#ifdef BOOST_REGEX_MSVC 1523| |# pragma warning(push) 1524| |#pragma warning(disable:6011) 1525| |#endif 1526| 0| if((static_cast(state)->index == -1) ------------------ | Branch (1526:13): [True: 0, False: 0] ------------------ 1527| 0| || (static_cast(state)->index == -2)) ------------------ | Branch (1527:16): [True: 0, False: 0] ------------------ 1528| 0| { 1529| | // skip past the zero width assertion: 1530| 0| state = static_cast(state->next.p)->alt.p->next.p; 1531| 0| continue; 1532| 0| } 1533| |#ifdef BOOST_REGEX_MSVC 1534| |# pragma warning(pop) 1535| |#endif 1536| 0| if(static_cast(state)->index == -3) ------------------ | Branch (1536:13): [True: 0, False: 0] ------------------ 1537| 0| { 1538| | // Have to skip the leading jump state: 1539| 0| state = state->next.p->next.p; 1540| 0| continue; 1541| 0| } 1542| 0| return; 1543| 0| case syntax_element_endmark: ------------------ | Branch (1543:7): [True: 0, False: 3.39k] ------------------ 1544| 0| case syntax_element_start_line: ------------------ | Branch (1544:7): [True: 0, False: 3.39k] ------------------ 1545| 0| case syntax_element_end_line: ------------------ | Branch (1545:7): [True: 0, False: 3.39k] ------------------ 1546| 0| case syntax_element_word_boundary: ------------------ | Branch (1546:7): [True: 0, False: 3.39k] ------------------ 1547| 0| case syntax_element_within_word: ------------------ | Branch (1547:7): [True: 0, False: 3.39k] ------------------ 1548| 0| case syntax_element_word_start: ------------------ | Branch (1548:7): [True: 0, False: 3.39k] ------------------ 1549| 0| case syntax_element_word_end: ------------------ | Branch (1549:7): [True: 0, False: 3.39k] ------------------ 1550| 0| case syntax_element_buffer_start: ------------------ | Branch (1550:7): [True: 0, False: 3.39k] ------------------ 1551| 0| case syntax_element_buffer_end: ------------------ | Branch (1551:7): [True: 0, False: 3.39k] ------------------ 1552| 0| case syntax_element_restart_continue: ------------------ | Branch (1552:7): [True: 0, False: 3.39k] ------------------ 1553| 0| state = state->next.p; 1554| 0| break; 1555| 0| case syntax_element_dot_rep: ------------------ | Branch (1555:7): [True: 0, False: 3.39k] ------------------ 1556| 0| case syntax_element_char_rep: ------------------ | Branch (1556:7): [True: 0, False: 3.39k] ------------------ 1557| 0| case syntax_element_short_set_rep: ------------------ | Branch (1557:7): [True: 0, False: 3.39k] ------------------ 1558| 0| case syntax_element_long_set_rep: ------------------ | Branch (1558:7): [True: 0, False: 3.39k] ------------------ 1559| 0| if(this->m_has_backrefs == 0) ------------------ | Branch (1559:13): [True: 0, False: 0] ------------------ 1560| 0| static_cast(state)->leading = true; 1561| 0| BOOST_REGEX_FALLTHROUGH; ------------------ | | 127| 0|# define BOOST_REGEX_FALLTHROUGH BOOST_FALLTHROUGH | | ------------------ | | | | 125| 0|# define BOOST_FALLTHROUGH [[clang::fallthrough]] | | ------------------ ------------------ 1562| 3.39k| default: ------------------ | Branch (1562:7): [True: 3.39k, False: 0] ------------------ 1563| 3.39k| return; 1564| 3.39k| } 1565| 3.39k| }while(state); ------------------ | Branch (1565:11): [True: 0, False: 0] ------------------ 1566| 3.39k|} _ZN5boost13re_detail_50018basic_regex_parserIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEC2EPNS0_10regex_dataIcS5_EE: 117| 3.39k| : basic_regex_creator(data), m_parser_proc(), m_base(0), m_end(0), m_position(0), 118| 3.39k| m_mark_count(0), m_mark_reset(-1), m_max_mark(0), m_paren_start(0), m_alt_insert_point(0), m_has_case_change(false), m_recursion_count(0), m_max_backref(0) 119| 3.39k|{ 120| 3.39k|} _ZN5boost13re_detail_50018basic_regex_parserIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE5parseEPKcS8_j: 124| 3.39k|{ 125| | // pass l_flags on to base class: 126| 3.39k| this->init(l_flags); 127| | // set up pointers: 128| 3.39k| m_position = m_base = p1; 129| 3.39k| m_end = p2; 130| | // empty strings are errors: 131| 3.39k| if((p1 == p2) && ------------------ | Branch (131:7): [True: 0, False: 3.39k] ------------------ 132| 3.39k| ( 133| 0| ((l_flags & regbase::main_option_type) != regbase::perl_syntax_group) ------------------ | Branch (133:10): [True: 0, False: 0] ------------------ 134| 0| || (l_flags & regbase::no_empty_expressions) ------------------ | Branch (134:13): [True: 0, False: 0] ------------------ 135| 0| ) 136| 3.39k| ) 137| 0| { 138| 0| fail(regex_constants::error_empty, 0); 139| 0| return; 140| 0| } 141| | // select which parser to use: 142| 3.39k| switch(l_flags & regbase::main_option_type) 143| 3.39k| { 144| 3.39k| case regbase::perl_syntax_group: ------------------ | Branch (144:4): [True: 3.39k, False: 0] ------------------ 145| 3.39k| { 146| 3.39k| m_parser_proc = &basic_regex_parser::parse_extended; 147| | // 148| | // Add a leading paren with index zero to give recursions a target: 149| | // 150| 3.39k| re_brace* br = static_cast(this->append_state(syntax_element_startmark, sizeof(re_brace))); 151| 3.39k| br->index = 0; 152| 3.39k| br->icase = this->flags() & regbase::icase; 153| 3.39k| break; 154| 0| } 155| 0| case regbase::basic_syntax_group: ------------------ | Branch (155:4): [True: 0, False: 3.39k] ------------------ 156| 0| m_parser_proc = &basic_regex_parser::parse_basic; 157| 0| break; 158| 0| case regbase::literal: ------------------ | Branch (158:4): [True: 0, False: 3.39k] ------------------ 159| 0| m_parser_proc = &basic_regex_parser::parse_literal; 160| 0| break; 161| 0| default: ------------------ | Branch (161:4): [True: 0, False: 3.39k] ------------------ 162| | // Oops, someone has managed to set more than one of the main option flags, 163| | // so this must be an error: 164| 0| fail(regex_constants::error_unknown, 0, "An invalid combination of regular expression syntax flags was used."); 165| 0| return; 166| 3.39k| } 167| | 168| | // parse all our characters: 169| 3.39k| bool result = parse_all(); 170| | // 171| | // Unwind our alternatives: 172| | // 173| 3.39k| unwind_alts(-1); 174| | // reset l_flags as a global scope (?imsx) may have altered them: 175| 3.39k| this->flags(l_flags); 176| | // if we haven't gobbled up all the characters then we must 177| | // have had an unexpected ')' : 178| 3.39k| if(!result) ------------------ | Branch (178:7): [True: 0, False: 3.39k] ------------------ 179| 0| { 180| 0| fail(regex_constants::error_paren, std::distance(m_base, m_position), "Found a closing ) with no corresponding opening parenthesis."); 181| 0| return; 182| 0| } 183| | // if an error has been set then give up now: 184| 3.39k| if(this->m_pdata->m_status) ------------------ | Branch (184:7): [True: 0, False: 3.39k] ------------------ 185| 0| return; 186| | // fill in our sub-expression count: 187| 3.39k| this->m_pdata->m_mark_count = 1u + (std::size_t)m_mark_count; 188| | // 189| | // Check we don't have backreferences to sub-expressions which don't exist: 190| | // 191| 3.39k| if (m_max_backref > m_mark_count) ------------------ | Branch (191:8): [True: 0, False: 3.39k] ------------------ 192| 0| { 193| 0| fail(regex_constants::error_backref, std::distance(m_base, m_position), "Found a backreference to a non-existant sub-expression."); 194| 0| } 195| 3.39k| this->finalize(p1, p2); 196| 3.39k|} _ZN5boost13re_detail_50018basic_regex_parserIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE14parse_extendedEv: 328| 1.31M|{ 329| 1.31M| bool result = true; 330| 1.31M| switch(this->m_traits.syntax_type(*m_position)) 331| 1.31M| { 332| 32.2k| case regex_constants::syntax_open_mark: ------------------ | Branch (332:4): [True: 32.2k, False: 1.27M] ------------------ 333| 32.2k| return parse_open_paren(); 334| 32.2k| case regex_constants::syntax_close_mark: ------------------ | Branch (334:4): [True: 32.2k, False: 1.27M] ------------------ 335| 32.2k| return false; 336| 18.6k| case regex_constants::syntax_escape: ------------------ | Branch (336:4): [True: 18.6k, False: 1.29M] ------------------ 337| 18.6k| return parse_extended_escape(); 338| 5.08k| case regex_constants::syntax_dot: ------------------ | Branch (338:4): [True: 5.08k, False: 1.30M] ------------------ 339| 5.08k| return parse_match_any(); 340| 1.69k| case regex_constants::syntax_caret: ------------------ | Branch (340:4): [True: 1.69k, False: 1.30M] ------------------ 341| 1.69k| ++m_position; 342| 1.69k| this->append_state( 343| 1.69k| (this->flags() & regex_constants::no_mod_m ? syntax_element_buffer_start : syntax_element_start_line)); ------------------ | Branch (343:11): [True: 0, False: 1.69k] ------------------ 344| 1.69k| break; 345| 0| case regex_constants::syntax_dollar: ------------------ | Branch (345:4): [True: 0, False: 1.31M] ------------------ 346| 0| ++m_position; 347| 0| this->append_state( 348| 0| (this->flags() & regex_constants::no_mod_m ? syntax_element_buffer_end : syntax_element_end_line)); ------------------ | Branch (348:11): [True: 0, False: 0] ------------------ 349| 0| break; 350| 13.5k| case regex_constants::syntax_star: ------------------ | Branch (350:4): [True: 13.5k, False: 1.29M] ------------------ 351| 13.5k| if(m_position == this->m_base) ------------------ | Branch (351:10): [True: 0, False: 13.5k] ------------------ 352| 0| { 353| 0| fail(regex_constants::error_badrepeat, 0, "The repeat operator \"*\" cannot start a regular expression."); 354| 0| return false; 355| 0| } 356| 13.5k| ++m_position; 357| 13.5k| return parse_repeat(); 358| 10.1k| case regex_constants::syntax_question: ------------------ | Branch (358:4): [True: 10.1k, False: 1.30M] ------------------ 359| 10.1k| if(m_position == this->m_base) ------------------ | Branch (359:10): [True: 0, False: 10.1k] ------------------ 360| 0| { 361| 0| fail(regex_constants::error_badrepeat, 0, "The repeat operator \"?\" cannot start a regular expression."); 362| 0| return false; 363| 0| } 364| 10.1k| ++m_position; 365| 10.1k| return parse_repeat(0,1); 366| 5.08k| case regex_constants::syntax_plus: ------------------ | Branch (366:4): [True: 5.08k, False: 1.30M] ------------------ 367| 5.08k| if(m_position == this->m_base) ------------------ | Branch (367:10): [True: 0, False: 5.08k] ------------------ 368| 0| { 369| 0| fail(regex_constants::error_badrepeat, 0, "The repeat operator \"+\" cannot start a regular expression."); 370| 0| return false; 371| 0| } 372| 5.08k| ++m_position; 373| 5.08k| return parse_repeat(1); 374| 0| case regex_constants::syntax_open_brace: ------------------ | Branch (374:4): [True: 0, False: 1.31M] ------------------ 375| 0| ++m_position; 376| 0| return parse_repeat_range(false); 377| 0| case regex_constants::syntax_close_brace: ------------------ | Branch (377:4): [True: 0, False: 1.31M] ------------------ 378| 0| if((this->flags() & regbase::no_perl_ex) == regbase::no_perl_ex) ------------------ | Branch (378:10): [True: 0, False: 0] ------------------ 379| 0| { 380| 0| fail(regex_constants::error_brace, this->m_position - this->m_base, "Found a closing repetition operator } with no corresponding {."); 381| 0| return false; 382| 0| } 383| 0| result = parse_literal(); 384| 0| break; 385| 176k| case regex_constants::syntax_or: ------------------ | Branch (385:4): [True: 176k, False: 1.13M] ------------------ 386| 176k| return parse_alt(); 387| 23.7k| case regex_constants::syntax_open_set: ------------------ | Branch (387:4): [True: 23.7k, False: 1.28M] ------------------ 388| 23.7k| return parse_set(); 389| 0| case regex_constants::syntax_newline: ------------------ | Branch (389:4): [True: 0, False: 1.31M] ------------------ 390| 0| if(this->flags() & regbase::newline_alt) ------------------ | Branch (390:10): [True: 0, False: 0] ------------------ 391| 0| return parse_alt(); 392| 0| else 393| 0| return parse_literal(); 394| 1.69k| case regex_constants::syntax_hash: ------------------ | Branch (394:4): [True: 1.69k, False: 1.30M] ------------------ 395| | // 396| | // If we have a mod_x flag set, then skip until 397| | // we get to a newline character: 398| | // 399| 1.69k| if((this->flags() ------------------ | Branch (399:10): [True: 0, False: 1.69k] ------------------ 400| 1.69k| & (regbase::no_perl_ex|regbase::mod_x)) 401| 1.69k| == regbase::mod_x) 402| 0| { 403| 0| while((m_position != m_end) && !is_separator(*m_position++)){} ------------------ | Branch (403:16): [True: 0, False: 0] | Branch (403:41): [True: 0, False: 0] ------------------ 404| 0| return true; 405| 0| } 406| 1.69k| BOOST_REGEX_FALLTHROUGH; ------------------ | | 127| 1.69k|# define BOOST_REGEX_FALLTHROUGH BOOST_FALLTHROUGH | | ------------------ | | | | 125| 1.69k|# define BOOST_FALLTHROUGH [[clang::fallthrough]] | | ------------------ ------------------ 407| 992k| default: ------------------ | Branch (407:4): [True: 990k, False: 320k] ------------------ 408| 992k| result = parse_literal(); 409| 992k| break; 410| 1.31M| } 411| 993k| return result; 412| 1.31M|} _ZN5boost13re_detail_50018basic_regex_parserIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE16parse_open_parenEv: 437| 32.2k|{ 438| | // 439| | // skip the '(' and error check: 440| | // 441| 32.2k| if(++m_position == m_end) ------------------ | Branch (441:7): [True: 0, False: 32.2k] ------------------ 442| 0| { 443| 0| fail(regex_constants::error_paren, m_position - m_base); 444| 0| return false; 445| 0| } 446| | // 447| | // begin by checking for a perl-style (?...) extension: 448| | // 449| 32.2k| if( 450| 32.2k| ((this->flags() & (regbase::main_option_type | regbase::no_perl_ex)) == 0) ------------------ | Branch (450:10): [True: 32.2k, False: 0] ------------------ 451| 32.2k| || ((this->flags() & (regbase::main_option_type | regbase::emacs_ex)) == (regbase::basic_syntax_group|regbase::emacs_ex)) ------------------ | Branch (451:13): [True: 0, False: 0] ------------------ 452| 32.2k| ) 453| 32.2k| { 454| 32.2k| if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_question) ------------------ | Branch (454:10): [True: 18.6k, False: 13.5k] ------------------ 455| 18.6k| return parse_perl_extension(); 456| 13.5k| if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_star) ------------------ | Branch (456:10): [True: 0, False: 13.5k] ------------------ 457| 0| return parse_perl_verb(); 458| 13.5k| } 459| | // 460| | // update our mark count, and append the required state: 461| | // 462| 13.5k| unsigned markid = 0; 463| 13.5k| if(0 == (this->flags() & regbase::nosubs)) ------------------ | Branch (463:7): [True: 13.5k, False: 0] ------------------ 464| 13.5k| { 465| 13.5k| markid = ++m_mark_count; 466| 13.5k| if(this->flags() & regbase::save_subexpression_location) ------------------ | Branch (466:10): [True: 0, False: 13.5k] ------------------ 467| 0| this->m_pdata->m_subs.push_back(std::pair(std::distance(m_base, m_position) - 1, 0)); 468| 13.5k| } 469| 13.5k| re_brace* pb = static_cast(this->append_state(syntax_element_startmark, sizeof(re_brace))); 470| 13.5k| pb->index = markid; 471| 13.5k| pb->icase = this->flags() & regbase::icase; 472| 13.5k| std::ptrdiff_t last_paren_start = this->getoffset(pb); 473| | // back up insertion point for alternations, and set new point: 474| 13.5k| std::ptrdiff_t last_alt_point = m_alt_insert_point; 475| 13.5k| this->m_pdata->m_data.align(); 476| 13.5k| m_alt_insert_point = this->m_pdata->m_data.size(); 477| | // 478| | // back up the current flags in case we have a nested (?imsx) group: 479| | // 480| 13.5k| regex_constants::syntax_option_type opts = this->flags(); 481| 13.5k| bool old_case_change = m_has_case_change; 482| 13.5k| m_has_case_change = false; // no changes to this scope as yet... 483| | // 484| | // Back up branch reset data in case we have a nested (?|...) 485| | // 486| 13.5k| int mark_reset = m_mark_reset; 487| 13.5k| m_mark_reset = -1; 488| | // 489| | // now recursively add more states, this will terminate when we get to a 490| | // matching ')' : 491| | // 492| 13.5k| parse_all(); 493| | // 494| | // Unwind pushed alternatives: 495| | // 496| 13.5k| if(0 == unwind_alts(last_paren_start)) ------------------ | Branch (496:7): [True: 0, False: 13.5k] ------------------ 497| 0| return false; 498| | // 499| | // restore flags: 500| | // 501| 13.5k| if(m_has_case_change) ------------------ | Branch (501:7): [True: 0, False: 13.5k] ------------------ 502| 0| { 503| | // the case has changed in one or more of the alternatives 504| | // within the scoped (...) block: we have to add a state 505| | // to reset the case sensitivity: 506| 0| static_cast( 507| 0| this->append_state(syntax_element_toggle_case, sizeof(re_case)) 508| 0| )->icase = opts & regbase::icase; 509| 0| } 510| 13.5k| this->flags(opts); 511| 13.5k| m_has_case_change = old_case_change; 512| | // 513| | // restore branch reset: 514| | // 515| 13.5k| m_mark_reset = mark_reset; 516| | // 517| | // we either have a ')' or we have run out of characters prematurely: 518| | // 519| 13.5k| if(m_position == m_end) ------------------ | Branch (519:7): [True: 0, False: 13.5k] ------------------ 520| 0| { 521| 0| this->fail(regex_constants::error_paren, std::distance(m_base, m_end)); 522| 0| return false; 523| 0| } 524| 13.5k| if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark) ------------------ | Branch (524:7): [True: 0, False: 13.5k] ------------------ 525| 0| return false; 526| 13.5k| if(markid && (this->flags() & regbase::save_subexpression_location)) ------------------ | Branch (526:7): [True: 13.5k, False: 0] | Branch (526:17): [True: 0, False: 13.5k] ------------------ 527| 0| this->m_pdata->m_subs.at(markid - 1).second = std::distance(m_base, m_position); 528| 13.5k| ++m_position; 529| | // 530| | // append closing parenthesis state: 531| | // 532| 13.5k| pb = static_cast(this->append_state(syntax_element_endmark, sizeof(re_brace))); 533| 13.5k| pb->index = markid; 534| 13.5k| pb->icase = this->flags() & regbase::icase; 535| 13.5k| this->m_paren_start = last_paren_start; 536| | // 537| | // restore the alternate insertion point: 538| | // 539| 13.5k| this->m_alt_insert_point = last_alt_point; 540| | 541| 13.5k| return true; 542| 13.5k|} _ZN5boost13re_detail_50018basic_regex_parserIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE20parse_perl_extensionEv: 2017| 18.6k|{ 2018| 18.6k| if(++m_position == m_end) ------------------ | Branch (2018:7): [True: 0, False: 18.6k] ------------------ 2019| 0| { 2020| | // Rewind to start of (? sequence: 2021| 0| --m_position; 2022| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2022:13): [True: 0, False: 0] ------------------ 2023| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2024| 0| return false; 2025| 0| } 2026| | // 2027| | // treat comments as a special case, as these 2028| | // are the only ones that don't start with a leading 2029| | // startmark state: 2030| | // 2031| 18.6k| if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_hash) ------------------ | Branch (2031:7): [True: 0, False: 18.6k] ------------------ 2032| 0| { 2033| 0| while((m_position != m_end) ------------------ | Branch (2033:13): [True: 0, False: 0] ------------------ 2034| 0| && (this->m_traits.syntax_type(*m_position++) != regex_constants::syntax_close_mark)) ------------------ | Branch (2034:13): [True: 0, False: 0] ------------------ 2035| 0| {} 2036| 0| return true; 2037| 0| } 2038| | // 2039| | // backup some state, and prepare the way: 2040| | // 2041| 18.6k| int markid = 0; 2042| 18.6k| std::ptrdiff_t jump_offset = 0; 2043| 18.6k| re_brace* pb = static_cast(this->append_state(syntax_element_startmark, sizeof(re_brace))); 2044| 18.6k| pb->icase = this->flags() & regbase::icase; 2045| 18.6k| std::ptrdiff_t last_paren_start = this->getoffset(pb); 2046| | // back up insertion point for alternations, and set new point: 2047| 18.6k| std::ptrdiff_t last_alt_point = m_alt_insert_point; 2048| 18.6k| this->m_pdata->m_data.align(); 2049| 18.6k| m_alt_insert_point = this->m_pdata->m_data.size(); 2050| 18.6k| std::ptrdiff_t expected_alt_point = m_alt_insert_point; 2051| 18.6k| bool restore_flags = true; 2052| 18.6k| regex_constants::syntax_option_type old_flags = this->flags(); 2053| 18.6k| bool old_case_change = m_has_case_change; 2054| 18.6k| m_has_case_change = false; 2055| 18.6k| charT name_delim; 2056| 18.6k| int mark_reset = m_mark_reset; 2057| 18.6k| int max_mark = m_max_mark; 2058| 18.6k| m_mark_reset = -1; 2059| 18.6k| m_max_mark = m_mark_count; 2060| 18.6k| std::intmax_t v; 2061| | // 2062| | // select the actual extension used: 2063| | // 2064| 18.6k| switch(this->m_traits.syntax_type(*m_position)) 2065| 18.6k| { 2066| 0| case regex_constants::syntax_or: ------------------ | Branch (2066:4): [True: 0, False: 18.6k] ------------------ 2067| 0| m_mark_reset = m_mark_count; 2068| 0| BOOST_REGEX_FALLTHROUGH; ------------------ | | 127| 0|# define BOOST_REGEX_FALLTHROUGH BOOST_FALLTHROUGH | | ------------------ | | | | 125| 0|# define BOOST_FALLTHROUGH [[clang::fallthrough]] | | ------------------ ------------------ 2069| 18.6k| case regex_constants::syntax_colon: ------------------ | Branch (2069:4): [True: 18.6k, False: 0] ------------------ 2070| | // 2071| | // a non-capturing mark: 2072| | // 2073| 18.6k| pb->index = markid = 0; 2074| 18.6k| ++m_position; 2075| 18.6k| break; 2076| 0| case regex_constants::syntax_digit: ------------------ | Branch (2076:4): [True: 0, False: 18.6k] ------------------ 2077| 0| { 2078| | // 2079| | // a recursive subexpression: 2080| | // 2081| 0| v = this->m_traits.toi(m_position, m_end, 10); 2082| 0| if((v < 0) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark)) ------------------ | Branch (2082:10): [True: 0, False: 0] | Branch (2082:21): [True: 0, False: 0] ------------------ 2083| 0| { 2084| | // Rewind to start of (? sequence: 2085| 0| --m_position; 2086| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2086:16): [True: 0, False: 0] ------------------ 2087| 0| fail(regex_constants::error_perl_extension, m_position - m_base, "The recursive sub-expression refers to an invalid marking group, or is unterminated."); 2088| 0| return false; 2089| 0| } 2090| 0|insert_recursion: 2091| 0| pb->index = markid = 0; 2092| 0| re_recurse* pr = static_cast(this->append_state(syntax_element_recurse, sizeof(re_recurse))); 2093| 0| pr->alt.i = (std::ptrdiff_t)v; 2094| 0| pr->state_id = 0; 2095| 0| static_cast( 2096| 0| this->append_state(syntax_element_toggle_case, sizeof(re_case)) 2097| 0| )->icase = this->flags() & regbase::icase; 2098| 0| break; 2099| 0| } 2100| 0| case regex_constants::syntax_plus: ------------------ | Branch (2100:4): [True: 0, False: 18.6k] ------------------ 2101| | // 2102| | // A forward-relative recursive subexpression: 2103| | // 2104| 0| ++m_position; 2105| 0| v = this->m_traits.toi(m_position, m_end, 10); 2106| 0| if((v <= 0) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark)) ------------------ | Branch (2106:10): [True: 0, False: 0] | Branch (2106:22): [True: 0, False: 0] ------------------ 2107| 0| { 2108| | // Rewind to start of (? sequence: 2109| 0| --m_position; 2110| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2110:16): [True: 0, False: 0] ------------------ 2111| 0| fail(regex_constants::error_perl_extension, m_position - m_base, "An invalid or unterminated recursive sub-expression."); 2112| 0| return false; 2113| 0| } 2114| 0| if ((std::numeric_limits::max)() - m_mark_count < v) ------------------ | Branch (2114:11): [True: 0, False: 0] ------------------ 2115| 0| { 2116| 0| fail(regex_constants::error_perl_extension, m_position - m_base, "An invalid or unterminated recursive sub-expression."); 2117| 0| return false; 2118| 0| } 2119| 0| v += m_mark_count; 2120| 0| goto insert_recursion; 2121| 0| case regex_constants::syntax_dash: ------------------ | Branch (2121:4): [True: 0, False: 18.6k] ------------------ 2122| | // 2123| | // Possibly a backward-relative recursive subexpression: 2124| | // 2125| 0| ++m_position; 2126| 0| v = this->m_traits.toi(m_position, m_end, 10); 2127| 0| if(v <= 0) ------------------ | Branch (2127:10): [True: 0, False: 0] ------------------ 2128| 0| { 2129| 0| --m_position; 2130| | // Oops not a relative recursion at all, but a (?-imsx) group: 2131| 0| goto option_group_jump; 2132| 0| } 2133| 0| v = static_cast(m_mark_count) + 1 - v; 2134| 0| if(v <= 0) ------------------ | Branch (2134:10): [True: 0, False: 0] ------------------ 2135| 0| { 2136| | // Rewind to start of (? sequence: 2137| 0| --m_position; 2138| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2138:16): [True: 0, False: 0] ------------------ 2139| 0| fail(regex_constants::error_perl_extension, m_position - m_base, "An invalid or unterminated recursive sub-expression."); 2140| 0| return false; 2141| 0| } 2142| 0| goto insert_recursion; 2143| 0| case regex_constants::syntax_equal: ------------------ | Branch (2143:4): [True: 0, False: 18.6k] ------------------ 2144| 0| pb->index = markid = -1; 2145| 0| ++m_position; 2146| 0| jump_offset = this->getoffset(this->append_state(syntax_element_jump, sizeof(re_jump))); 2147| 0| this->m_pdata->m_data.align(); 2148| 0| m_alt_insert_point = this->m_pdata->m_data.size(); 2149| 0| break; 2150| 0| case regex_constants::syntax_not: ------------------ | Branch (2150:4): [True: 0, False: 18.6k] ------------------ 2151| 0| pb->index = markid = -2; 2152| 0| ++m_position; 2153| 0| jump_offset = this->getoffset(this->append_state(syntax_element_jump, sizeof(re_jump))); 2154| 0| this->m_pdata->m_data.align(); 2155| 0| m_alt_insert_point = this->m_pdata->m_data.size(); 2156| 0| break; 2157| 0| case regex_constants::escape_type_left_word: ------------------ | Branch (2157:4): [True: 0, False: 18.6k] ------------------ 2158| 0| { 2159| | // a lookbehind assertion: 2160| 0| if(++m_position == m_end) ------------------ | Branch (2160:13): [True: 0, False: 0] ------------------ 2161| 0| { 2162| | // Rewind to start of (? sequence: 2163| 0| --m_position; 2164| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2164:19): [True: 0, False: 0] ------------------ 2165| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2166| 0| return false; 2167| 0| } 2168| 0| regex_constants::syntax_type t = this->m_traits.syntax_type(*m_position); 2169| 0| if(t == regex_constants::syntax_not) ------------------ | Branch (2169:13): [True: 0, False: 0] ------------------ 2170| 0| pb->index = markid = -2; 2171| 0| else if(t == regex_constants::syntax_equal) ------------------ | Branch (2171:18): [True: 0, False: 0] ------------------ 2172| 0| pb->index = markid = -1; 2173| 0| else 2174| 0| { 2175| | // Probably a named capture which also starts (?< : 2176| 0| name_delim = '>'; 2177| 0| --m_position; 2178| 0| goto named_capture_jump; 2179| 0| } 2180| 0| ++m_position; 2181| 0| jump_offset = this->getoffset(this->append_state(syntax_element_jump, sizeof(re_jump))); 2182| 0| this->append_state(syntax_element_backstep, sizeof(re_brace)); 2183| 0| this->m_pdata->m_data.align(); 2184| 0| m_alt_insert_point = this->m_pdata->m_data.size(); 2185| 0| break; 2186| 0| } 2187| 0| case regex_constants::escape_type_right_word: ------------------ | Branch (2187:4): [True: 0, False: 18.6k] ------------------ 2188| | // 2189| | // an independent sub-expression: 2190| | // 2191| 0| pb->index = markid = -3; 2192| 0| ++m_position; 2193| 0| jump_offset = this->getoffset(this->append_state(syntax_element_jump, sizeof(re_jump))); 2194| 0| this->m_pdata->m_data.align(); 2195| 0| m_alt_insert_point = this->m_pdata->m_data.size(); 2196| 0| break; 2197| 0| case regex_constants::syntax_open_mark: ------------------ | Branch (2197:4): [True: 0, False: 18.6k] ------------------ 2198| 0| { 2199| | // a conditional expression: 2200| 0| pb->index = markid = -4; 2201| 0| if(++m_position == m_end) ------------------ | Branch (2201:10): [True: 0, False: 0] ------------------ 2202| 0| { 2203| | // Rewind to start of (? sequence: 2204| 0| --m_position; 2205| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2205:16): [True: 0, False: 0] ------------------ 2206| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2207| 0| return false; 2208| 0| } 2209| 0| v = this->m_traits.toi(m_position, m_end, 10); 2210| 0| if(m_position == m_end) ------------------ | Branch (2210:10): [True: 0, False: 0] ------------------ 2211| 0| { 2212| | // Rewind to start of (? sequence: 2213| 0| --m_position; 2214| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2214:16): [True: 0, False: 0] ------------------ 2215| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2216| 0| return false; 2217| 0| } 2218| 0| if(*m_position == charT('R')) ------------------ | Branch (2218:10): [True: 0, False: 0] ------------------ 2219| 0| { 2220| 0| if(++m_position == m_end) ------------------ | Branch (2220:13): [True: 0, False: 0] ------------------ 2221| 0| { 2222| | // Rewind to start of (? sequence: 2223| 0| --m_position; 2224| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2224:19): [True: 0, False: 0] ------------------ 2225| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2226| 0| return false; 2227| 0| } 2228| 0| if(*m_position == charT('&')) ------------------ | Branch (2228:13): [True: 0, False: 0] ------------------ 2229| 0| { 2230| 0| const charT* base = ++m_position; 2231| 0| while((m_position != m_end) && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark)) ------------------ | Branch (2231:19): [True: 0, False: 0] | Branch (2231:44): [True: 0, False: 0] ------------------ 2232| 0| ++m_position; 2233| 0| if(m_position == m_end) ------------------ | Branch (2233:16): [True: 0, False: 0] ------------------ 2234| 0| { 2235| | // Rewind to start of (? sequence: 2236| 0| --m_position; 2237| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2237:22): [True: 0, False: 0] ------------------ 2238| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2239| 0| return false; 2240| 0| } 2241| 0| v = -static_cast(hash_value_from_capture_name(base, m_position)); 2242| 0| } 2243| 0| else 2244| 0| { 2245| 0| v = -this->m_traits.toi(m_position, m_end, 10); 2246| 0| } 2247| 0| re_brace* br = static_cast(this->append_state(syntax_element_assert_backref, sizeof(re_brace))); 2248| 0| br->index = v < 0 ? (int)(v - 1) : 0; ------------------ | Branch (2248:22): [True: 0, False: 0] ------------------ 2249| 0| if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark) ------------------ | Branch (2249:13): [True: 0, False: 0] ------------------ 2250| 0| { 2251| | // Rewind to start of (? sequence: 2252| 0| --m_position; 2253| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2253:19): [True: 0, False: 0] ------------------ 2254| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2255| 0| return false; 2256| 0| } 2257| 0| if(++m_position == m_end) ------------------ | Branch (2257:13): [True: 0, False: 0] ------------------ 2258| 0| { 2259| | // Rewind to start of (? sequence: 2260| 0| --m_position; 2261| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2261:19): [True: 0, False: 0] ------------------ 2262| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2263| 0| return false; 2264| 0| } 2265| 0| } 2266| 0| else if((*m_position == charT('\'')) || (*m_position == charT('<'))) ------------------ | Branch (2266:15): [True: 0, False: 0] | Branch (2266:47): [True: 0, False: 0] ------------------ 2267| 0| { 2268| 0| const charT* base = ++m_position; 2269| 0| while((m_position != m_end) && (*m_position != charT('>')) && (*m_position != charT('\''))) ------------------ | Branch (2269:16): [True: 0, False: 0] | Branch (2269:41): [True: 0, False: 0] | Branch (2269:72): [True: 0, False: 0] ------------------ 2270| 0| ++m_position; 2271| 0| if(m_position == m_end) ------------------ | Branch (2271:13): [True: 0, False: 0] ------------------ 2272| 0| { 2273| | // Rewind to start of (? sequence: 2274| 0| --m_position; 2275| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2275:19): [True: 0, False: 0] ------------------ 2276| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2277| 0| return false; 2278| 0| } 2279| 0| v = static_cast(hash_value_from_capture_name(base, m_position)); 2280| 0| re_brace* br = static_cast(this->append_state(syntax_element_assert_backref, sizeof(re_brace))); 2281| 0| br->index = (int)v; 2282| 0| if(((*m_position != charT('>')) && (*m_position != charT('\''))) || (++m_position == m_end)) ------------------ | Branch (2282:14): [True: 0, False: 0] | Branch (2282:45): [True: 0, False: 0] | Branch (2282:78): [True: 0, False: 0] ------------------ 2283| 0| { 2284| | // Rewind to start of (? sequence: 2285| 0| --m_position; 2286| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2286:19): [True: 0, False: 0] ------------------ 2287| 0| fail(regex_constants::error_perl_extension, m_position - m_base, "Unterminated named capture."); 2288| 0| return false; 2289| 0| } 2290| 0| if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark) ------------------ | Branch (2290:13): [True: 0, False: 0] ------------------ 2291| 0| { 2292| | // Rewind to start of (? sequence: 2293| 0| --m_position; 2294| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2294:19): [True: 0, False: 0] ------------------ 2295| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2296| 0| return false; 2297| 0| } 2298| 0| if(++m_position == m_end) ------------------ | Branch (2298:13): [True: 0, False: 0] ------------------ 2299| 0| { 2300| | // Rewind to start of (? sequence: 2301| 0| --m_position; 2302| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2302:19): [True: 0, False: 0] ------------------ 2303| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2304| 0| return false; 2305| 0| } 2306| 0| } 2307| 0| else if(*m_position == charT('D')) ------------------ | Branch (2307:15): [True: 0, False: 0] ------------------ 2308| 0| { 2309| 0| const char* def = "DEFINE"; 2310| 0| while(*def && (m_position != m_end) && (*m_position == charT(*def))) ------------------ | Branch (2310:16): [True: 0, False: 0] | Branch (2310:24): [True: 0, False: 0] | Branch (2310:49): [True: 0, False: 0] ------------------ 2311| 0| ++m_position, ++def; 2312| 0| if((m_position == m_end) || *def) ------------------ | Branch (2312:13): [True: 0, False: 0] | Branch (2312:38): [True: 0, False: 0] ------------------ 2313| 0| { 2314| | // Rewind to start of (? sequence: 2315| 0| --m_position; 2316| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2316:19): [True: 0, False: 0] ------------------ 2317| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2318| 0| return false; 2319| 0| } 2320| 0| re_brace* br = static_cast(this->append_state(syntax_element_assert_backref, sizeof(re_brace))); 2321| 0| br->index = 9999; // special magic value! 2322| 0| if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark) ------------------ | Branch (2322:13): [True: 0, False: 0] ------------------ 2323| 0| { 2324| | // Rewind to start of (? sequence: 2325| 0| --m_position; 2326| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2326:19): [True: 0, False: 0] ------------------ 2327| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2328| 0| return false; 2329| 0| } 2330| 0| if(++m_position == m_end) ------------------ | Branch (2330:13): [True: 0, False: 0] ------------------ 2331| 0| { 2332| | // Rewind to start of (? sequence: 2333| 0| --m_position; 2334| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2334:19): [True: 0, False: 0] ------------------ 2335| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2336| 0| return false; 2337| 0| } 2338| 0| } 2339| 0| else if(v > 0) ------------------ | Branch (2339:15): [True: 0, False: 0] ------------------ 2340| 0| { 2341| 0| re_brace* br = static_cast(this->append_state(syntax_element_assert_backref, sizeof(re_brace))); 2342| 0| br->index = (int)v; 2343| 0| if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark) ------------------ | Branch (2343:13): [True: 0, False: 0] ------------------ 2344| 0| { 2345| | // Rewind to start of (? sequence: 2346| 0| --m_position; 2347| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2347:19): [True: 0, False: 0] ------------------ 2348| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2349| 0| return false; 2350| 0| } 2351| 0| if(++m_position == m_end) ------------------ | Branch (2351:13): [True: 0, False: 0] ------------------ 2352| 0| { 2353| | // Rewind to start of (? sequence: 2354| 0| --m_position; 2355| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2355:19): [True: 0, False: 0] ------------------ 2356| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2357| 0| return false; 2358| 0| } 2359| 0| } 2360| 0| else 2361| 0| { 2362| | // verify that we have a lookahead or lookbehind assert: 2363| 0| if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_question) ------------------ | Branch (2363:13): [True: 0, False: 0] ------------------ 2364| 0| { 2365| | // Rewind to start of (? sequence: 2366| 0| --m_position; 2367| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2367:19): [True: 0, False: 0] ------------------ 2368| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2369| 0| return false; 2370| 0| } 2371| 0| if(++m_position == m_end) ------------------ | Branch (2371:13): [True: 0, False: 0] ------------------ 2372| 0| { 2373| | // Rewind to start of (? sequence: 2374| 0| --m_position; 2375| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2375:19): [True: 0, False: 0] ------------------ 2376| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2377| 0| return false; 2378| 0| } 2379| 0| if(this->m_traits.syntax_type(*m_position) == regex_constants::escape_type_left_word) ------------------ | Branch (2379:13): [True: 0, False: 0] ------------------ 2380| 0| { 2381| 0| if(++m_position == m_end) ------------------ | Branch (2381:16): [True: 0, False: 0] ------------------ 2382| 0| { 2383| | // Rewind to start of (? sequence: 2384| 0| --m_position; 2385| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2385:22): [True: 0, False: 0] ------------------ 2386| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2387| 0| return false; 2388| 0| } 2389| 0| if((this->m_traits.syntax_type(*m_position) != regex_constants::syntax_equal) ------------------ | Branch (2389:16): [True: 0, False: 0] ------------------ 2390| 0| && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_not)) ------------------ | Branch (2390:19): [True: 0, False: 0] ------------------ 2391| 0| { 2392| | // Rewind to start of (? sequence: 2393| 0| --m_position; 2394| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2394:22): [True: 0, False: 0] ------------------ 2395| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2396| 0| return false; 2397| 0| } 2398| 0| m_position -= 3; 2399| 0| } 2400| 0| else 2401| 0| { 2402| 0| if((this->m_traits.syntax_type(*m_position) != regex_constants::syntax_equal) ------------------ | Branch (2402:16): [True: 0, False: 0] ------------------ 2403| 0| && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_not)) ------------------ | Branch (2403:19): [True: 0, False: 0] ------------------ 2404| 0| { 2405| | // Rewind to start of (? sequence: 2406| 0| --m_position; 2407| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2407:22): [True: 0, False: 0] ------------------ 2408| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2409| 0| return false; 2410| 0| } 2411| 0| m_position -= 2; 2412| 0| } 2413| 0| } 2414| 0| break; 2415| 0| } 2416| 0| case regex_constants::syntax_close_mark: ------------------ | Branch (2416:4): [True: 0, False: 18.6k] ------------------ 2417| | // Rewind to start of (? sequence: 2418| 0| --m_position; 2419| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2419:13): [True: 0, False: 0] ------------------ 2420| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2421| 0| return false; 2422| 0| case regex_constants::escape_type_end_buffer: ------------------ | Branch (2422:4): [True: 0, False: 18.6k] ------------------ 2423| 0| { 2424| 0| name_delim = *m_position; 2425| 0|named_capture_jump: 2426| 0| markid = 0; 2427| 0| if(0 == (this->flags() & regbase::nosubs)) ------------------ | Branch (2427:10): [True: 0, False: 0] ------------------ 2428| 0| { 2429| 0| markid = ++m_mark_count; 2430| 0| if(this->flags() & regbase::save_subexpression_location) ------------------ | Branch (2430:13): [True: 0, False: 0] ------------------ 2431| 0| this->m_pdata->m_subs.push_back(std::pair(std::distance(m_base, m_position) - 2, 0)); 2432| 0| } 2433| 0| pb->index = markid; 2434| 0| const charT* base = ++m_position; 2435| 0| if(m_position == m_end) ------------------ | Branch (2435:10): [True: 0, False: 0] ------------------ 2436| 0| { 2437| | // Rewind to start of (? sequence: 2438| 0| --m_position; 2439| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2439:16): [True: 0, False: 0] ------------------ 2440| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2441| 0| return false; 2442| 0| } 2443| 0| while((m_position != m_end) && (*m_position != name_delim)) ------------------ | Branch (2443:13): [True: 0, False: 0] | Branch (2443:38): [True: 0, False: 0] ------------------ 2444| 0| ++m_position; 2445| 0| if(m_position == m_end) ------------------ | Branch (2445:10): [True: 0, False: 0] ------------------ 2446| 0| { 2447| | // Rewind to start of (? sequence: 2448| 0| --m_position; 2449| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2449:16): [True: 0, False: 0] ------------------ 2450| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2451| 0| return false; 2452| 0| } 2453| 0| this->m_pdata->set_name(base, m_position, markid); 2454| 0| ++m_position; 2455| 0| break; 2456| 0| } 2457| 0| default: ------------------ | Branch (2457:4): [True: 0, False: 18.6k] ------------------ 2458| 0| if(*m_position == charT('R')) ------------------ | Branch (2458:10): [True: 0, False: 0] ------------------ 2459| 0| { 2460| 0| ++m_position; 2461| 0| v = 0; 2462| 0| if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark) ------------------ | Branch (2462:13): [True: 0, False: 0] ------------------ 2463| 0| { 2464| | // Rewind to start of (? sequence: 2465| 0| --m_position; 2466| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2466:19): [True: 0, False: 0] ------------------ 2467| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2468| 0| return false; 2469| 0| } 2470| 0| goto insert_recursion; 2471| 0| } 2472| 0| if(*m_position == charT('&')) ------------------ | Branch (2472:10): [True: 0, False: 0] ------------------ 2473| 0| { 2474| 0| ++m_position; 2475| 0| const charT* base = m_position; 2476| 0| while((m_position != m_end) && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark)) ------------------ | Branch (2476:16): [True: 0, False: 0] | Branch (2476:41): [True: 0, False: 0] ------------------ 2477| 0| ++m_position; 2478| 0| if(m_position == m_end) ------------------ | Branch (2478:13): [True: 0, False: 0] ------------------ 2479| 0| { 2480| | // Rewind to start of (? sequence: 2481| 0| --m_position; 2482| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2482:19): [True: 0, False: 0] ------------------ 2483| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2484| 0| return false; 2485| 0| } 2486| 0| v = static_cast(hash_value_from_capture_name(base, m_position)); 2487| 0| goto insert_recursion; 2488| 0| } 2489| 0| if(*m_position == charT('P')) ------------------ | Branch (2489:10): [True: 0, False: 0] ------------------ 2490| 0| { 2491| 0| ++m_position; 2492| 0| if(m_position == m_end) ------------------ | Branch (2492:13): [True: 0, False: 0] ------------------ 2493| 0| { 2494| | // Rewind to start of (? sequence: 2495| 0| --m_position; 2496| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2496:19): [True: 0, False: 0] ------------------ 2497| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2498| 0| return false; 2499| 0| } 2500| 0| if(*m_position == charT('>')) ------------------ | Branch (2500:13): [True: 0, False: 0] ------------------ 2501| 0| { 2502| 0| ++m_position; 2503| 0| const charT* base = m_position; 2504| 0| while((m_position != m_end) && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark)) ------------------ | Branch (2504:19): [True: 0, False: 0] | Branch (2504:44): [True: 0, False: 0] ------------------ 2505| 0| ++m_position; 2506| 0| if(m_position == m_end) ------------------ | Branch (2506:16): [True: 0, False: 0] ------------------ 2507| 0| { 2508| | // Rewind to start of (? sequence: 2509| 0| --m_position; 2510| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2510:22): [True: 0, False: 0] ------------------ 2511| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2512| 0| return false; 2513| 0| } 2514| 0| v = static_cast(hash_value_from_capture_name(base, m_position)); 2515| 0| goto insert_recursion; 2516| 0| } 2517| 0| } 2518| | // 2519| | // lets assume that we have a (?imsx) group and try and parse it: 2520| | // 2521| 0|option_group_jump: 2522| 0| regex_constants::syntax_option_type opts = parse_options(); 2523| 0| if(m_position == m_end) ------------------ | Branch (2523:10): [True: 0, False: 0] ------------------ 2524| 0| { 2525| | // Rewind to start of (? sequence: 2526| 0| --m_position; 2527| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2527:16): [True: 0, False: 0] ------------------ 2528| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2529| 0| return false; 2530| 0| } 2531| | // make a note of whether we have a case change: 2532| 0| m_has_case_change = ((opts & regbase::icase) != (this->flags() & regbase::icase)); 2533| 0| pb->index = markid = 0; 2534| 0| if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark) ------------------ | Branch (2534:10): [True: 0, False: 0] ------------------ 2535| 0| { 2536| | // update flags and carry on as normal: 2537| 0| this->flags(opts); 2538| 0| restore_flags = false; 2539| 0| old_case_change |= m_has_case_change; // defer end of scope by one ')' 2540| 0| } 2541| 0| else if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_colon) ------------------ | Branch (2541:15): [True: 0, False: 0] ------------------ 2542| 0| { 2543| | // update flags and carry on until the matching ')' is found: 2544| 0| this->flags(opts); 2545| 0| ++m_position; 2546| 0| } 2547| 0| else 2548| 0| { 2549| | // Rewind to start of (? sequence: 2550| 0| --m_position; 2551| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2551:16): [True: 0, False: 0] ------------------ 2552| 0| fail(regex_constants::error_perl_extension, m_position - m_base); 2553| 0| return false; 2554| 0| } 2555| | 2556| | // finally append a case change state if we need it: 2557| 0| if(m_has_case_change) ------------------ | Branch (2557:10): [True: 0, False: 0] ------------------ 2558| 0| { 2559| 0| static_cast( 2560| 0| this->append_state(syntax_element_toggle_case, sizeof(re_case)) 2561| 0| )->icase = opts & regbase::icase; 2562| 0| } 2563| | 2564| 18.6k| } 2565| | // 2566| | // now recursively add more states, this will terminate when we get to a 2567| | // matching ')' : 2568| | // 2569| 18.6k| parse_all(); 2570| | // 2571| | // Unwind alternatives: 2572| | // 2573| 18.6k| if(0 == unwind_alts(last_paren_start)) ------------------ | Branch (2573:7): [True: 0, False: 18.6k] ------------------ 2574| 0| { 2575| | // Rewind to start of (? sequence: 2576| 0| --m_position; 2577| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2577:13): [True: 0, False: 0] ------------------ 2578| 0| fail(regex_constants::error_perl_extension, m_position - m_base, "Invalid alternation operators within (?...) block."); 2579| 0| return false; 2580| 0| } 2581| | // 2582| | // we either have a ')' or we have run out of characters prematurely: 2583| | // 2584| 18.6k| if(m_position == m_end) ------------------ | Branch (2584:7): [True: 0, False: 18.6k] ------------------ 2585| 0| { 2586| | // Rewind to start of (? sequence: 2587| 0| --m_position; 2588| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2588:13): [True: 0, False: 0] ------------------ 2589| 0| this->fail(regex_constants::error_paren, std::distance(m_base, m_end)); 2590| 0| return false; 2591| 0| } 2592| 18.6k| BOOST_REGEX_ASSERT(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark); ------------------ | | 58| 18.6k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 18.6k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 2593| 18.6k| ++m_position; 2594| | // 2595| | // restore the flags: 2596| | // 2597| 18.6k| if(restore_flags) ------------------ | Branch (2597:7): [True: 18.6k, False: 0] ------------------ 2598| 18.6k| { 2599| | // append a case change state if we need it: 2600| 18.6k| if(m_has_case_change) ------------------ | Branch (2600:10): [True: 0, False: 18.6k] ------------------ 2601| 0| { 2602| 0| static_cast( 2603| 0| this->append_state(syntax_element_toggle_case, sizeof(re_case)) 2604| 0| )->icase = old_flags & regbase::icase; 2605| 0| } 2606| 18.6k| this->flags(old_flags); 2607| 18.6k| } 2608| | // 2609| | // set up the jump pointer if we have one: 2610| | // 2611| 18.6k| if(jump_offset) ------------------ | Branch (2611:7): [True: 0, False: 18.6k] ------------------ 2612| 0| { 2613| 0| this->m_pdata->m_data.align(); 2614| 0| re_jump* jmp = static_cast(this->getaddress(jump_offset)); 2615| 0| jmp->alt.i = this->m_pdata->m_data.size() - this->getoffset(jmp); 2616| 0| if((this->m_last_state == jmp) && (markid != -2)) ------------------ | Branch (2616:10): [True: 0, False: 0] | Branch (2616:41): [True: 0, False: 0] ------------------ 2617| 0| { 2618| | // Oops... we didn't have anything inside the assertion. 2619| | // Note we don't get here for negated forward lookahead as (?!) 2620| | // does have some uses. 2621| | // Rewind to start of (? sequence: 2622| 0| --m_position; 2623| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2623:16): [True: 0, False: 0] ------------------ 2624| 0| fail(regex_constants::error_perl_extension, m_position - m_base, "Invalid or empty zero width assertion."); 2625| 0| return false; 2626| 0| } 2627| 0| } 2628| | // 2629| | // verify that if this is conditional expression, that we do have 2630| | // an alternative, if not add one: 2631| | // 2632| 18.6k| if(markid == -4) ------------------ | Branch (2632:7): [True: 0, False: 18.6k] ------------------ 2633| 0| { 2634| 0| re_syntax_base* b = this->getaddress(expected_alt_point); 2635| | // Make sure we have exactly one alternative following this state: 2636| 0| if(b->type != syntax_element_alt) ------------------ | Branch (2636:10): [True: 0, False: 0] ------------------ 2637| 0| { 2638| 0| re_alt* alt = static_cast(this->insert_state(expected_alt_point, syntax_element_alt, sizeof(re_alt))); 2639| 0| alt->alt.i = this->m_pdata->m_data.size() - this->getoffset(alt); 2640| 0| } 2641| 0| else if(((std::ptrdiff_t)this->m_pdata->m_data.size() > (static_cast(b)->alt.i + this->getoffset(b))) && (static_cast(b)->alt.i > 0) && this->getaddress(static_cast(b)->alt.i, b)->type == syntax_element_alt) ------------------ | Branch (2641:15): [True: 0, False: 0] | Branch (2641:121): [True: 0, False: 0] | Branch (2641:161): [True: 0, False: 0] ------------------ 2642| 0| { 2643| | // Can't have seen more than one alternative: 2644| | // Rewind to start of (? sequence: 2645| 0| --m_position; 2646| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2646:16): [True: 0, False: 0] ------------------ 2647| 0| fail(regex_constants::error_bad_pattern, m_position - m_base, "More than one alternation operator | was encountered inside a conditional expression."); 2648| 0| return false; 2649| 0| } 2650| 0| else 2651| 0| { 2652| | // We must *not* have seen an alternative inside a (DEFINE) block: 2653| 0| b = this->getaddress(b->next.i, b); 2654| 0| if((b->type == syntax_element_assert_backref) && (static_cast(b)->index == 9999)) ------------------ | Branch (2654:13): [True: 0, False: 0] | Branch (2654:59): [True: 0, False: 0] ------------------ 2655| 0| { 2656| | // Rewind to start of (? sequence: 2657| 0| --m_position; 2658| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2658:19): [True: 0, False: 0] ------------------ 2659| 0| fail(regex_constants::error_bad_pattern, m_position - m_base, "Alternation operators are not allowed inside a DEFINE block."); 2660| 0| return false; 2661| 0| } 2662| 0| } 2663| | // check for invalid repetition of next state: 2664| 0| b = this->getaddress(expected_alt_point); 2665| 0| b = this->getaddress(static_cast(b)->next.i, b); 2666| 0| if((b->type != syntax_element_assert_backref) ------------------ | Branch (2666:10): [True: 0, False: 0] ------------------ 2667| 0| && (b->type != syntax_element_startmark)) ------------------ | Branch (2667:13): [True: 0, False: 0] ------------------ 2668| 0| { 2669| | // Rewind to start of (? sequence: 2670| 0| --m_position; 2671| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; ------------------ | Branch (2671:16): [True: 0, False: 0] ------------------ 2672| 0| fail(regex_constants::error_badrepeat, m_position - m_base, "A repetition operator cannot be applied to a zero-width assertion."); 2673| 0| return false; 2674| 0| } 2675| 0| } 2676| | // 2677| | // append closing parenthesis state: 2678| | // 2679| 18.6k| pb = static_cast(this->append_state(syntax_element_endmark, sizeof(re_brace))); 2680| 18.6k| pb->index = markid; 2681| 18.6k| pb->icase = this->flags() & regbase::icase; 2682| 18.6k| this->m_paren_start = last_paren_start; 2683| | // 2684| | // restore the alternate insertion point: 2685| | // 2686| 18.6k| this->m_alt_insert_point = last_alt_point; 2687| | // 2688| | // and the case change data: 2689| | // 2690| 18.6k| m_has_case_change = old_case_change; 2691| | // 2692| | // And the mark_reset data: 2693| | // 2694| 18.6k| if(m_max_mark > m_mark_count) ------------------ | Branch (2694:7): [True: 0, False: 18.6k] ------------------ 2695| 0| { 2696| 0| m_mark_count = m_max_mark; 2697| 0| } 2698| 18.6k| m_mark_reset = mark_reset; 2699| 18.6k| m_max_mark = max_mark; 2700| | 2701| | 2702| 18.6k| if(markid > 0) ------------------ | Branch (2702:7): [True: 0, False: 18.6k] ------------------ 2703| 0| { 2704| 0| if(this->flags() & regbase::save_subexpression_location) ------------------ | Branch (2704:10): [True: 0, False: 0] ------------------ 2705| 0| this->m_pdata->m_subs.at((std::size_t)markid - 1).second = std::distance(m_base, m_position) - 1; 2706| 0| } 2707| 18.6k| return true; 2708| 18.6k|} _ZN5boost13re_detail_50018basic_regex_parserIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE21parse_extended_escapeEv: 692| 18.6k|{ 693| 18.6k| ++m_position; 694| 18.6k| if(m_position == m_end) ------------------ | Branch (694:7): [True: 0, False: 18.6k] ------------------ 695| 0| { 696| 0| fail(regex_constants::error_escape, m_position - m_base, "Incomplete escape sequence found."); 697| 0| return false; 698| 0| } 699| 18.6k| bool negate = false; // in case this is a character class escape: \w \d etc 700| 18.6k| switch(this->m_traits.escape_syntax_type(*m_position)) 701| 18.6k| { 702| 0| case regex_constants::escape_type_not_class: ------------------ | Branch (702:4): [True: 0, False: 18.6k] ------------------ 703| 0| negate = true; 704| 0| BOOST_REGEX_FALLTHROUGH; ------------------ | | 127| 0|# define BOOST_REGEX_FALLTHROUGH BOOST_FALLTHROUGH | | ------------------ | | | | 125| 0|# define BOOST_FALLTHROUGH [[clang::fallthrough]] | | ------------------ ------------------ 705| 0| case regex_constants::escape_type_class: ------------------ | Branch (705:4): [True: 0, False: 18.6k] ------------------ 706| 0| { 707| 0|escape_type_class_jump: 708| 0| typedef typename traits::char_class_type m_type; 709| 0| m_type m = this->m_traits.lookup_classname(m_position, m_position+1); 710| 0| if(m != 0) ------------------ | Branch (710:13): [True: 0, False: 0] ------------------ 711| 0| { 712| 0| basic_char_set char_set; 713| 0| if(negate) ------------------ | Branch (713:16): [True: 0, False: 0] ------------------ 714| 0| char_set.negate(); 715| 0| char_set.add_class(m); 716| 0| if(0 == this->append_set(char_set)) ------------------ | Branch (716:16): [True: 0, False: 0] ------------------ 717| 0| { 718| 0| fail(regex_constants::error_ctype, m_position - m_base); 719| 0| return false; 720| 0| } 721| 0| ++m_position; 722| 0| return true; 723| 0| } 724| | // 725| | // not a class, just a regular unknown escape: 726| | // 727| 0| this->append_literal(unescape_character()); 728| 0| break; 729| 0| } 730| 0| case regex_constants::syntax_digit: ------------------ | Branch (730:4): [True: 0, False: 18.6k] ------------------ 731| 0| return parse_backref(); 732| 3.39k| case regex_constants::escape_type_left_word: ------------------ | Branch (732:4): [True: 3.39k, False: 15.2k] ------------------ 733| 3.39k| ++m_position; 734| 3.39k| this->append_state(syntax_element_word_start); 735| 3.39k| break; 736| 3.39k| case regex_constants::escape_type_right_word: ------------------ | Branch (736:4): [True: 3.39k, False: 15.2k] ------------------ 737| 3.39k| ++m_position; 738| 3.39k| this->append_state(syntax_element_word_end); 739| 3.39k| break; 740| 0| case regex_constants::escape_type_start_buffer: ------------------ | Branch (740:4): [True: 0, False: 18.6k] ------------------ 741| 0| ++m_position; 742| 0| this->append_state(syntax_element_buffer_start); 743| 0| break; 744| 0| case regex_constants::escape_type_end_buffer: ------------------ | Branch (744:4): [True: 0, False: 18.6k] ------------------ 745| 0| ++m_position; 746| 0| this->append_state(syntax_element_buffer_end); 747| 0| break; 748| 0| case regex_constants::escape_type_word_assert: ------------------ | Branch (748:4): [True: 0, False: 18.6k] ------------------ 749| 0| ++m_position; 750| 0| this->append_state(syntax_element_word_boundary); 751| 0| break; 752| 0| case regex_constants::escape_type_not_word_assert: ------------------ | Branch (752:4): [True: 0, False: 18.6k] ------------------ 753| 0| ++m_position; 754| 0| this->append_state(syntax_element_within_word); 755| 0| break; 756| 0| case regex_constants::escape_type_Z: ------------------ | Branch (756:4): [True: 0, False: 18.6k] ------------------ 757| 0| ++m_position; 758| 0| this->append_state(syntax_element_soft_buffer_end); 759| 0| break; 760| 0| case regex_constants::escape_type_Q: ------------------ | Branch (760:4): [True: 0, False: 18.6k] ------------------ 761| 0| return parse_QE(); 762| 0| case regex_constants::escape_type_C: ------------------ | Branch (762:4): [True: 0, False: 18.6k] ------------------ 763| 0| return parse_match_any(); 764| 0| case regex_constants::escape_type_X: ------------------ | Branch (764:4): [True: 0, False: 18.6k] ------------------ 765| 0| ++m_position; 766| 0| this->append_state(syntax_element_combining); 767| 0| break; 768| 0| case regex_constants::escape_type_G: ------------------ | Branch (768:4): [True: 0, False: 18.6k] ------------------ 769| 0| ++m_position; 770| 0| this->append_state(syntax_element_restart_continue); 771| 0| break; 772| 0| case regex_constants::escape_type_not_property: ------------------ | Branch (772:4): [True: 0, False: 18.6k] ------------------ 773| 0| negate = true; 774| 0| BOOST_REGEX_FALLTHROUGH; ------------------ | | 127| 0|# define BOOST_REGEX_FALLTHROUGH BOOST_FALLTHROUGH | | ------------------ | | | | 125| 0|# define BOOST_FALLTHROUGH [[clang::fallthrough]] | | ------------------ ------------------ 775| 0| case regex_constants::escape_type_property: ------------------ | Branch (775:4): [True: 0, False: 18.6k] ------------------ 776| 0| { 777| 0| ++m_position; 778| 0| char_class_type m; 779| 0| if(m_position == m_end) ------------------ | Branch (779:13): [True: 0, False: 0] ------------------ 780| 0| { 781| 0| fail(regex_constants::error_escape, m_position - m_base, "Incomplete property escape found."); 782| 0| return false; 783| 0| } 784| | // maybe have \p{ddd} 785| 0| if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_open_brace) ------------------ | Branch (785:13): [True: 0, False: 0] ------------------ 786| 0| { 787| 0| const charT* base = m_position; 788| | // skip forward until we find enclosing brace: 789| 0| while((m_position != m_end) && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_brace)) ------------------ | Branch (789:19): [True: 0, False: 0] | Branch (789:44): [True: 0, False: 0] ------------------ 790| 0| ++m_position; 791| 0| if(m_position == m_end) ------------------ | Branch (791:16): [True: 0, False: 0] ------------------ 792| 0| { 793| 0| fail(regex_constants::error_escape, m_position - m_base, "Closing } missing from property escape sequence."); 794| 0| return false; 795| 0| } 796| 0| m = this->m_traits.lookup_classname(++base, m_position++); 797| 0| } 798| 0| else 799| 0| { 800| 0| m = this->m_traits.lookup_classname(m_position, m_position+1); 801| 0| ++m_position; 802| 0| } 803| 0| if(m != 0) ------------------ | Branch (803:13): [True: 0, False: 0] ------------------ 804| 0| { 805| 0| basic_char_set char_set; 806| 0| if(negate) ------------------ | Branch (806:16): [True: 0, False: 0] ------------------ 807| 0| char_set.negate(); 808| 0| char_set.add_class(m); 809| 0| if(0 == this->append_set(char_set)) ------------------ | Branch (809:16): [True: 0, False: 0] ------------------ 810| 0| { 811| 0| fail(regex_constants::error_ctype, m_position - m_base); 812| 0| return false; 813| 0| } 814| 0| return true; 815| 0| } 816| 0| fail(regex_constants::error_ctype, m_position - m_base, "Escape sequence was neither a valid property nor a valid character class name."); 817| 0| return false; 818| 0| } 819| 0| case regex_constants::escape_type_reset_start_mark: ------------------ | Branch (819:4): [True: 0, False: 18.6k] ------------------ 820| 0| if(0 == (this->flags() & (regbase::main_option_type | regbase::no_perl_ex))) ------------------ | Branch (820:10): [True: 0, False: 0] ------------------ 821| 0| { 822| 0| re_brace* pb = static_cast(this->append_state(syntax_element_startmark, sizeof(re_brace))); 823| 0| pb->index = -5; 824| 0| pb->icase = this->flags() & regbase::icase; 825| 0| this->m_pdata->m_data.align(); 826| 0| ++m_position; 827| 0| return true; 828| 0| } 829| 0| goto escape_type_class_jump; 830| 0| case regex_constants::escape_type_line_ending: ------------------ | Branch (830:4): [True: 0, False: 18.6k] ------------------ 831| 0| if(0 == (this->flags() & (regbase::main_option_type | regbase::no_perl_ex))) ------------------ | Branch (831:10): [True: 0, False: 0] ------------------ 832| 0| { 833| 0| const charT* e = get_escape_R_string(); 834| 0| const charT* old_position = m_position; 835| 0| const charT* old_end = m_end; 836| 0| const charT* old_base = m_base; 837| 0| m_position = e; 838| 0| m_base = e; 839| 0| m_end = e + traits::length(e); 840| 0| bool r = parse_all(); 841| 0| m_position = ++old_position; 842| 0| m_end = old_end; 843| 0| m_base = old_base; 844| 0| return r; 845| 0| } 846| 0| goto escape_type_class_jump; 847| 0| case regex_constants::escape_type_extended_backref: ------------------ | Branch (847:4): [True: 0, False: 18.6k] ------------------ 848| 0| if(0 == (this->flags() & (regbase::main_option_type | regbase::no_perl_ex))) ------------------ | Branch (848:10): [True: 0, False: 0] ------------------ 849| 0| { 850| 0| bool have_brace = false; 851| 0| bool negative = false; 852| 0| static const char incomplete_message[] = "Incomplete \\g escape found."; 853| 0| if(++m_position == m_end) ------------------ | Branch (853:13): [True: 0, False: 0] ------------------ 854| 0| { 855| 0| fail(regex_constants::error_escape, m_position - m_base, incomplete_message); 856| 0| return false; 857| 0| } 858| | // maybe have \g{ddd} 859| 0| regex_constants::syntax_type syn = this->m_traits.syntax_type(*m_position); 860| 0| regex_constants::syntax_type syn_end = 0; 861| 0| if((syn == regex_constants::syntax_open_brace) ------------------ | Branch (861:13): [True: 0, False: 0] ------------------ 862| 0| || (syn == regex_constants::escape_type_left_word) ------------------ | Branch (862:16): [True: 0, False: 0] ------------------ 863| 0| || (syn == regex_constants::escape_type_end_buffer)) ------------------ | Branch (863:16): [True: 0, False: 0] ------------------ 864| 0| { 865| 0| if(++m_position == m_end) ------------------ | Branch (865:16): [True: 0, False: 0] ------------------ 866| 0| { 867| 0| fail(regex_constants::error_escape, m_position - m_base, incomplete_message); 868| 0| return false; 869| 0| } 870| 0| have_brace = true; 871| 0| switch(syn) 872| 0| { 873| 0| case regex_constants::syntax_open_brace: ------------------ | Branch (873:13): [True: 0, False: 0] ------------------ 874| 0| syn_end = regex_constants::syntax_close_brace; 875| 0| break; 876| 0| case regex_constants::escape_type_left_word: ------------------ | Branch (876:13): [True: 0, False: 0] ------------------ 877| 0| syn_end = regex_constants::escape_type_right_word; 878| 0| break; 879| 0| default: ------------------ | Branch (879:13): [True: 0, False: 0] ------------------ 880| 0| syn_end = regex_constants::escape_type_end_buffer; 881| 0| break; 882| 0| } 883| 0| } 884| 0| negative = (*m_position == static_cast('-')); 885| 0| if((negative) && (++m_position == m_end)) ------------------ | Branch (885:13): [True: 0, False: 0] | Branch (885:27): [True: 0, False: 0] ------------------ 886| 0| { 887| 0| fail(regex_constants::error_escape, m_position - m_base, incomplete_message); 888| 0| return false; 889| 0| } 890| 0| const charT* pc = m_position; 891| 0| std::intmax_t i = this->m_traits.toi(pc, m_end, 10); 892| 0| if((i < 0) && syn_end) ------------------ | Branch (892:13): [True: 0, False: 0] | Branch (892:24): [True: 0, False: 0] ------------------ 893| 0| { 894| | // Check for a named capture, get the leftmost one if there is more than one: 895| 0| const charT* base = m_position; 896| 0| while((m_position != m_end) && (this->m_traits.syntax_type(*m_position) != syn_end)) ------------------ | Branch (896:19): [True: 0, False: 0] | Branch (896:44): [True: 0, False: 0] ------------------ 897| 0| { 898| 0| ++m_position; 899| 0| } 900| 0| i = hash_value_from_capture_name(base, m_position); 901| 0| pc = m_position; 902| 0| } 903| 0| if(negative) ------------------ | Branch (903:13): [True: 0, False: 0] ------------------ 904| 0| i = 1 + (static_cast(m_mark_count) - i); 905| 0| if(((i < hash_value_mask) && (i > 0)) || ((i >= hash_value_mask) && (this->m_pdata->get_id((int)i) > 0))) ------------------ | Branch (905:14): [True: 0, False: 0] | Branch (905:39): [True: 0, False: 0] | Branch (905:52): [True: 0, False: 0] | Branch (905:78): [True: 0, False: 0] ------------------ 906| 0| { 907| 0| m_position = pc; 908| 0| re_brace* pb = static_cast(this->append_state(syntax_element_backref, sizeof(re_brace))); 909| 0| pb->index = (int)i; 910| 0| pb->icase = this->flags() & regbase::icase; 911| 0| if ((i > m_max_backref) && (i < hash_value_mask)) ------------------ | Branch (911:17): [True: 0, False: 0] | Branch (911:40): [True: 0, False: 0] ------------------ 912| 0| m_max_backref = i; 913| 0| } 914| 0| else 915| 0| { 916| 0| fail(regex_constants::error_backref, m_position - m_base); 917| 0| return false; 918| 0| } 919| 0| m_position = pc; 920| 0| if(have_brace) ------------------ | Branch (920:13): [True: 0, False: 0] ------------------ 921| 0| { 922| 0| if((m_position == m_end) || (this->m_traits.syntax_type(*m_position) != syn_end)) ------------------ | Branch (922:16): [True: 0, False: 0] | Branch (922:41): [True: 0, False: 0] ------------------ 923| 0| { 924| 0| fail(regex_constants::error_escape, m_position - m_base, incomplete_message); 925| 0| return false; 926| 0| } 927| 0| ++m_position; 928| 0| } 929| 0| return true; 930| 0| } 931| 0| goto escape_type_class_jump; 932| 0| case regex_constants::escape_type_control_v: ------------------ | Branch (932:4): [True: 0, False: 18.6k] ------------------ 933| 0| if(0 == (this->flags() & (regbase::main_option_type | regbase::no_perl_ex))) ------------------ | Branch (933:10): [True: 0, False: 0] ------------------ 934| 0| goto escape_type_class_jump; 935| 0| BOOST_REGEX_FALLTHROUGH; ------------------ | | 127| 0|# define BOOST_REGEX_FALLTHROUGH BOOST_FALLTHROUGH | | ------------------ | | | | 125| 0|# define BOOST_FALLTHROUGH [[clang::fallthrough]] | | ------------------ ------------------ 936| 11.8k| default: ------------------ | Branch (936:4): [True: 11.8k, False: 6.78k] ------------------ 937| 11.8k| this->append_literal(unescape_character()); 938| 11.8k| break; 939| 18.6k| } 940| 18.6k| return true; 941| 18.6k|} _ZN5boost13re_detail_50018basic_regex_parserIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE18unescape_characterEv: 1744| 23.7k|{ 1745| |#ifdef BOOST_REGEX_MSVC 1746| |#pragma warning(push) 1747| |#pragma warning(disable:4127) 1748| |#endif 1749| 23.7k| charT result(0); 1750| 23.7k| if(m_position == m_end) ------------------ | Branch (1750:7): [True: 0, False: 23.7k] ------------------ 1751| 0| { 1752| 0| fail(regex_constants::error_escape, m_position - m_base, "Escape sequence terminated prematurely."); 1753| 0| return false; 1754| 0| } 1755| 23.7k| switch(this->m_traits.escape_syntax_type(*m_position)) 1756| 23.7k| { 1757| 0| case regex_constants::escape_type_control_a: ------------------ | Branch (1757:4): [True: 0, False: 23.7k] ------------------ 1758| 0| result = charT('\a'); 1759| 0| break; 1760| 0| case regex_constants::escape_type_e: ------------------ | Branch (1760:4): [True: 0, False: 23.7k] ------------------ 1761| 0| result = charT(27); 1762| 0| break; 1763| 0| case regex_constants::escape_type_control_f: ------------------ | Branch (1763:4): [True: 0, False: 23.7k] ------------------ 1764| 0| result = charT('\f'); 1765| 0| break; 1766| 6.78k| case regex_constants::escape_type_control_n: ------------------ | Branch (1766:4): [True: 6.78k, False: 16.9k] ------------------ 1767| 6.78k| result = charT('\n'); 1768| 6.78k| break; 1769| 1.69k| case regex_constants::escape_type_control_r: ------------------ | Branch (1769:4): [True: 1.69k, False: 22.0k] ------------------ 1770| 1.69k| result = charT('\r'); 1771| 1.69k| break; 1772| 0| case regex_constants::escape_type_control_t: ------------------ | Branch (1772:4): [True: 0, False: 23.7k] ------------------ 1773| 0| result = charT('\t'); 1774| 0| break; 1775| 0| case regex_constants::escape_type_control_v: ------------------ | Branch (1775:4): [True: 0, False: 23.7k] ------------------ 1776| 0| result = charT('\v'); 1777| 0| break; 1778| 0| case regex_constants::escape_type_word_assert: ------------------ | Branch (1778:4): [True: 0, False: 23.7k] ------------------ 1779| 0| result = charT('\b'); 1780| 0| break; 1781| 0| case regex_constants::escape_type_ascii_control: ------------------ | Branch (1781:4): [True: 0, False: 23.7k] ------------------ 1782| 0| ++m_position; 1783| 0| if(m_position == m_end) ------------------ | Branch (1783:10): [True: 0, False: 0] ------------------ 1784| 0| { 1785| | // Rewind to start of escape: 1786| 0| --m_position; 1787| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_escape) --m_position; ------------------ | Branch (1787:16): [True: 0, False: 0] ------------------ 1788| 0| fail(regex_constants::error_escape, m_position - m_base, "ASCII escape sequence terminated prematurely."); 1789| 0| return result; 1790| 0| } 1791| 0| result = static_cast(*m_position % 32); 1792| 0| break; 1793| 0| case regex_constants::escape_type_hex: ------------------ | Branch (1793:4): [True: 0, False: 23.7k] ------------------ 1794| 0| ++m_position; 1795| 0| if(m_position == m_end) ------------------ | Branch (1795:10): [True: 0, False: 0] ------------------ 1796| 0| { 1797| | // Rewind to start of escape: 1798| 0| --m_position; 1799| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_escape) --m_position; ------------------ | Branch (1799:16): [True: 0, False: 0] ------------------ 1800| 0| fail(regex_constants::error_escape, m_position - m_base, "Hexadecimal escape sequence terminated prematurely."); 1801| 0| return result; 1802| 0| } 1803| | // maybe have \x{ddd} 1804| 0| if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_open_brace) ------------------ | Branch (1804:10): [True: 0, False: 0] ------------------ 1805| 0| { 1806| 0| ++m_position; 1807| 0| if(m_position == m_end) ------------------ | Branch (1807:13): [True: 0, False: 0] ------------------ 1808| 0| { 1809| | // Rewind to start of escape: 1810| 0| --m_position; 1811| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_escape) --m_position; ------------------ | Branch (1811:19): [True: 0, False: 0] ------------------ 1812| 0| fail(regex_constants::error_escape, m_position - m_base, "Missing } in hexadecimal escape sequence."); 1813| 0| return result; 1814| 0| } 1815| 0| std::intmax_t i = this->m_traits.toi(m_position, m_end, 16); 1816| 0| if((m_position == m_end) ------------------ | Branch (1816:13): [True: 0, False: 0] ------------------ 1817| 0| || (i < 0) ------------------ | Branch (1817:16): [True: 0, False: 0] ------------------ 1818| 0| || ((std::numeric_limits::is_specialized) && (i > (std::intmax_t)(std::numeric_limits::max)())) ------------------ | Branch (1818:17): [Folded - Ignored] | Branch (1818:65): [True: 0, False: 0] ------------------ 1819| 0| || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_brace)) ------------------ | Branch (1819:16): [True: 0, False: 0] ------------------ 1820| 0| { 1821| | // Rewind to start of escape: 1822| 0| --m_position; 1823| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_escape) --m_position; ------------------ | Branch (1823:19): [True: 0, False: 0] ------------------ 1824| 0| fail(regex_constants::error_badbrace, m_position - m_base, "Hexadecimal escape sequence was invalid."); 1825| 0| return result; 1826| 0| } 1827| 0| ++m_position; 1828| 0| result = charT(i); 1829| 0| } 1830| 0| else 1831| 0| { 1832| 0| std::ptrdiff_t len = (std::min)(static_cast(2), static_cast(m_end - m_position)); 1833| 0| std::intmax_t i = this->m_traits.toi(m_position, m_position + len, 16); 1834| 0| if((i < 0) ------------------ | Branch (1834:13): [True: 0, False: 0] ------------------ 1835| 0| || !valid_value(charT(0), i)) ------------------ | Branch (1835:16): [True: 0, False: 0] ------------------ 1836| 0| { 1837| | // Rewind to start of escape: 1838| 0| --m_position; 1839| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_escape) --m_position; ------------------ | Branch (1839:19): [True: 0, False: 0] ------------------ 1840| 0| fail(regex_constants::error_escape, m_position - m_base, "Escape sequence did not encode a valid character."); 1841| 0| return result; 1842| 0| } 1843| 0| result = charT(i); 1844| 0| } 1845| 0| return result; 1846| 0| case regex_constants::syntax_digit: ------------------ | Branch (1846:4): [True: 0, False: 23.7k] ------------------ 1847| 0| { 1848| | // an octal escape sequence, the first character must be a zero 1849| | // followed by up to 3 octal digits: 1850| 0| std::ptrdiff_t len = (std::min)(std::distance(m_position, m_end), static_cast(4)); 1851| 0| const charT* bp = m_position; 1852| 0| std::intmax_t val = this->m_traits.toi(bp, bp + 1, 8); 1853| 0| if(val != 0) ------------------ | Branch (1853:10): [True: 0, False: 0] ------------------ 1854| 0| { 1855| | // Rewind to start of escape: 1856| 0| --m_position; 1857| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_escape) --m_position; ------------------ | Branch (1857:16): [True: 0, False: 0] ------------------ 1858| | // Oops not an octal escape after all: 1859| 0| fail(regex_constants::error_escape, m_position - m_base, "Invalid octal escape sequence."); 1860| 0| return result; 1861| 0| } 1862| 0| val = this->m_traits.toi(m_position, m_position + len, 8); 1863| 0| if((val < 0) || (val > (std::intmax_t)(std::numeric_limits::max)())) ------------------ | Branch (1863:10): [True: 0, False: 0] | Branch (1863:23): [True: 0, False: 0] ------------------ 1864| 0| { 1865| | // Rewind to start of escape: 1866| 0| --m_position; 1867| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_escape) --m_position; ------------------ | Branch (1867:16): [True: 0, False: 0] ------------------ 1868| 0| fail(regex_constants::error_escape, m_position - m_base, "Octal escape sequence is invalid."); 1869| 0| return result; 1870| 0| } 1871| 0| return static_cast(val); 1872| 0| } 1873| 0| case regex_constants::escape_type_named_char: ------------------ | Branch (1873:4): [True: 0, False: 23.7k] ------------------ 1874| 0| { 1875| 0| ++m_position; 1876| 0| if(m_position == m_end) ------------------ | Branch (1876:13): [True: 0, False: 0] ------------------ 1877| 0| { 1878| | // Rewind to start of escape: 1879| 0| --m_position; 1880| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_escape) --m_position; ------------------ | Branch (1880:19): [True: 0, False: 0] ------------------ 1881| 0| fail(regex_constants::error_escape, m_position - m_base); 1882| 0| return false; 1883| 0| } 1884| | // maybe have \N{name} 1885| 0| if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_open_brace) ------------------ | Branch (1885:13): [True: 0, False: 0] ------------------ 1886| 0| { 1887| 0| const charT* base = m_position; 1888| | // skip forward until we find enclosing brace: 1889| 0| while((m_position != m_end) && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_brace)) ------------------ | Branch (1889:19): [True: 0, False: 0] | Branch (1889:44): [True: 0, False: 0] ------------------ 1890| 0| ++m_position; 1891| 0| if(m_position == m_end) ------------------ | Branch (1891:16): [True: 0, False: 0] ------------------ 1892| 0| { 1893| | // Rewind to start of escape: 1894| 0| --m_position; 1895| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_escape) --m_position; ------------------ | Branch (1895:22): [True: 0, False: 0] ------------------ 1896| 0| fail(regex_constants::error_escape, m_position - m_base); 1897| 0| return false; 1898| 0| } 1899| 0| string_type s = this->m_traits.lookup_collatename(++base, m_position++); 1900| 0| if(s.empty()) ------------------ | Branch (1900:16): [True: 0, False: 0] ------------------ 1901| 0| { 1902| | // Rewind to start of escape: 1903| 0| --m_position; 1904| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_escape) --m_position; ------------------ | Branch (1904:22): [True: 0, False: 0] ------------------ 1905| 0| fail(regex_constants::error_collate, m_position - m_base); 1906| 0| return false; 1907| 0| } 1908| 0| if(s.size() == 1) ------------------ | Branch (1908:16): [True: 0, False: 0] ------------------ 1909| 0| { 1910| 0| return s[0]; 1911| 0| } 1912| 0| } 1913| | // fall through is a failure: 1914| | // Rewind to start of escape: 1915| 0| --m_position; 1916| 0| while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_escape) --m_position; ------------------ | Branch (1916:16): [True: 0, False: 0] ------------------ 1917| 0| fail(regex_constants::error_escape, m_position - m_base); 1918| 0| return false; 1919| 0| } 1920| 15.2k| default: ------------------ | Branch (1920:4): [True: 15.2k, False: 8.48k] ------------------ 1921| 15.2k| result = *m_position; 1922| 15.2k| break; 1923| 23.7k| } 1924| 23.7k| ++m_position; 1925| 23.7k| return result; 1926| |#ifdef BOOST_REGEX_MSVC 1927| |#pragma warning(pop) 1928| |#endif 1929| 23.7k|} _ZN5boost13re_detail_50018basic_regex_parserIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE15parse_match_anyEv: 945| 5.08k|{ 946| | // 947| | // we have a '.' that can match any character: 948| | // 949| 5.08k| ++m_position; 950| 5.08k| static_cast( 951| 5.08k| this->append_state(syntax_element_wild, sizeof(re_dot)) 952| 5.08k| )->mask = static_cast(this->flags() & regbase::no_mod_s ------------------ | Branch (952:44): [True: 0, False: 5.08k] ------------------ 953| 5.08k| ? BOOST_REGEX_DETAIL_NS::force_not_newline ------------------ | | 158| 0|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 0|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 0|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 0|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 954| 5.08k| : this->flags() & regbase::mod_s ? ------------------ | Branch (954:12): [True: 0, False: 5.08k] ------------------ 955| 5.08k| BOOST_REGEX_DETAIL_NS::force_newline : BOOST_REGEX_DETAIL_NS::dont_care); ------------------ | | 158| 0|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 0|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 0|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 0|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ BOOST_REGEX_DETAIL_NS::force_newline : BOOST_REGEX_DETAIL_NS::dont_care); ------------------ | | 158| 5.08k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 5.08k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 5.08k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 5.08k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 956| 5.08k| return true; 957| 5.08k|} _ZN5boost13re_detail_50018basic_regex_parserIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE12parse_repeatEmm: 961| 28.8k|{ 962| 28.8k| bool greedy = true; 963| 28.8k| bool possessive = false; 964| 28.8k| std::size_t insert_point; 965| | // 966| | // when we get to here we may have a non-greedy ? mark still to come: 967| | // 968| 28.8k| if((m_position != m_end) ------------------ | Branch (968:7): [True: 28.8k, False: 0] ------------------ 969| 28.8k| && ( 970| 28.8k| (0 == (this->flags() & (regbase::main_option_type | regbase::no_perl_ex))) ------------------ | Branch (970:13): [True: 28.8k, False: 0] ------------------ 971| 28.8k| || ((regbase::basic_syntax_group|regbase::emacs_ex) == (this->flags() & (regbase::main_option_type | regbase::emacs_ex))) ------------------ | Branch (971:16): [True: 0, False: 0] ------------------ 972| 28.8k| ) 973| 28.8k| ) 974| 28.8k| { 975| | // OK we have a perl or emacs regex, check for a '?': 976| 28.8k| if ((this->flags() & (regbase::main_option_type | regbase::mod_x | regbase::no_perl_ex)) == regbase::mod_x) ------------------ | Branch (976:11): [True: 0, False: 28.8k] ------------------ 977| 0| { 978| | // whitespace skip: 979| 0| while ((m_position != m_end) && this->m_traits.isctype(*m_position, this->m_mask_space)) ------------------ | Branch (979:17): [True: 0, False: 0] | Branch (979:42): [True: 0, False: 0] ------------------ 980| 0| ++m_position; 981| 0| } 982| 28.8k| if((m_position != m_end) && (this->m_traits.syntax_type(*m_position) == regex_constants::syntax_question)) ------------------ | Branch (982:10): [True: 28.8k, False: 0] | Branch (982:35): [True: 1.69k, False: 27.1k] ------------------ 983| 1.69k| { 984| 1.69k| greedy = false; 985| 1.69k| ++m_position; 986| 1.69k| } 987| | // for perl regexes only check for possessive ++ repeats. 988| 28.8k| if((m_position != m_end) ------------------ | Branch (988:10): [True: 28.8k, False: 0] ------------------ 989| 28.8k| && (0 == (this->flags() & regbase::main_option_type)) ------------------ | Branch (989:13): [True: 28.8k, False: 0] ------------------ 990| 28.8k| && (this->m_traits.syntax_type(*m_position) == regex_constants::syntax_plus)) ------------------ | Branch (990:13): [True: 0, False: 28.8k] ------------------ 991| 0| { 992| 0| possessive = true; 993| 0| ++m_position; 994| 0| } 995| 28.8k| } 996| 28.8k| if(0 == this->m_last_state) ------------------ | Branch (996:7): [True: 0, False: 28.8k] ------------------ 997| 0| { 998| 0| fail(regex_constants::error_badrepeat, std::distance(m_base, m_position), "Nothing to repeat."); 999| 0| return false; 1000| 0| } 1001| 28.8k| if(this->m_last_state->type == syntax_element_endmark) ------------------ | Branch (1001:7): [True: 10.1k, False: 18.6k] ------------------ 1002| 10.1k| { 1003| | // insert a repeat before the '(' matching the last ')': 1004| 10.1k| insert_point = this->m_paren_start; 1005| 10.1k| } 1006| 18.6k| else if((this->m_last_state->type == syntax_element_literal) && (static_cast(this->m_last_state)->length > 1)) ------------------ | Branch (1006:12): [True: 1.69k, False: 16.9k] | Branch (1006:68): [True: 0, False: 1.69k] ------------------ 1007| 0| { 1008| | // the last state was a literal with more than one character, split it in two: 1009| 0| re_literal* lit = static_cast(this->m_last_state); 1010| 0| charT c = (static_cast(static_cast(lit+1)))[lit->length - 1]; 1011| 0| lit->length -= 1; 1012| | // now append new state: 1013| 0| lit = static_cast(this->append_state(syntax_element_literal, sizeof(re_literal) + sizeof(charT))); 1014| 0| lit->length = 1; 1015| 0| (static_cast(static_cast(lit+1)))[0] = c; 1016| 0| insert_point = this->getoffset(this->m_last_state); 1017| 0| } 1018| 18.6k| else 1019| 18.6k| { 1020| | // repeat the last state whatever it was, need to add some error checking here: 1021| 18.6k| switch(this->m_last_state->type) 1022| 18.6k| { 1023| 0| case syntax_element_start_line: ------------------ | Branch (1023:7): [True: 0, False: 18.6k] ------------------ 1024| 0| case syntax_element_end_line: ------------------ | Branch (1024:7): [True: 0, False: 18.6k] ------------------ 1025| 0| case syntax_element_word_boundary: ------------------ | Branch (1025:7): [True: 0, False: 18.6k] ------------------ 1026| 0| case syntax_element_within_word: ------------------ | Branch (1026:7): [True: 0, False: 18.6k] ------------------ 1027| 0| case syntax_element_word_start: ------------------ | Branch (1027:7): [True: 0, False: 18.6k] ------------------ 1028| 0| case syntax_element_word_end: ------------------ | Branch (1028:7): [True: 0, False: 18.6k] ------------------ 1029| 0| case syntax_element_buffer_start: ------------------ | Branch (1029:7): [True: 0, False: 18.6k] ------------------ 1030| 0| case syntax_element_buffer_end: ------------------ | Branch (1030:7): [True: 0, False: 18.6k] ------------------ 1031| 0| case syntax_element_alt: ------------------ | Branch (1031:7): [True: 0, False: 18.6k] ------------------ 1032| 0| case syntax_element_soft_buffer_end: ------------------ | Branch (1032:7): [True: 0, False: 18.6k] ------------------ 1033| 0| case syntax_element_restart_continue: ------------------ | Branch (1033:7): [True: 0, False: 18.6k] ------------------ 1034| 0| case syntax_element_jump: ------------------ | Branch (1034:7): [True: 0, False: 18.6k] ------------------ 1035| 0| case syntax_element_startmark: ------------------ | Branch (1035:7): [True: 0, False: 18.6k] ------------------ 1036| 0| case syntax_element_backstep: ------------------ | Branch (1036:7): [True: 0, False: 18.6k] ------------------ 1037| 0| case syntax_element_toggle_case: ------------------ | Branch (1037:7): [True: 0, False: 18.6k] ------------------ 1038| | // can't legally repeat any of the above: 1039| 0| fail(regex_constants::error_badrepeat, m_position - m_base); 1040| 0| return false; 1041| 18.6k| default: ------------------ | Branch (1041:7): [True: 18.6k, False: 0] ------------------ 1042| | // do nothing... 1043| 18.6k| break; 1044| 18.6k| } 1045| 18.6k| insert_point = this->getoffset(this->m_last_state); 1046| 18.6k| } 1047| | // 1048| | // OK we now know what to repeat, so insert the repeat around it: 1049| | // 1050| 28.8k| re_repeat* rep = static_cast(this->insert_state(insert_point, syntax_element_rep, re_repeater_size)); 1051| 28.8k| rep->min = low; 1052| 28.8k| rep->max = high; 1053| 28.8k| rep->greedy = greedy; 1054| 28.8k| rep->leading = false; 1055| | // store our repeater position for later: 1056| 28.8k| std::ptrdiff_t rep_off = this->getoffset(rep); 1057| | // and append a back jump to the repeat: 1058| 28.8k| re_jump* jmp = static_cast(this->append_state(syntax_element_jump, sizeof(re_jump))); 1059| 28.8k| jmp->alt.i = rep_off - this->getoffset(jmp); 1060| 28.8k| this->m_pdata->m_data.align(); 1061| | // now fill in the alt jump for the repeat: 1062| 28.8k| rep = static_cast(this->getaddress(rep_off)); 1063| 28.8k| rep->alt.i = this->m_pdata->m_data.size() - rep_off; 1064| | // 1065| | // If the repeat is possessive then bracket the repeat with a (?>...) 1066| | // independent sub-expression construct: 1067| | // 1068| 28.8k| if(possessive) ------------------ | Branch (1068:7): [True: 0, False: 28.8k] ------------------ 1069| 0| { 1070| 0| if(m_position != m_end) ------------------ | Branch (1070:10): [True: 0, False: 0] ------------------ 1071| 0| { 1072| | // 1073| | // Check for illegal following quantifier, we have to do this here, because 1074| | // the extra states we insert below circumvents our usual error checking :-( 1075| | // 1076| 0| bool contin = false; 1077| 0| do 1078| 0| { 1079| 0| if ((this->flags() & (regbase::main_option_type | regbase::mod_x | regbase::no_perl_ex)) == regbase::mod_x) ------------------ | Branch (1079:17): [True: 0, False: 0] ------------------ 1080| 0| { 1081| | // whitespace skip: 1082| 0| while ((m_position != m_end) && this->m_traits.isctype(*m_position, this->m_mask_space)) ------------------ | Branch (1082:23): [True: 0, False: 0] | Branch (1082:48): [True: 0, False: 0] ------------------ 1083| 0| ++m_position; 1084| 0| } 1085| 0| if (m_position != m_end) ------------------ | Branch (1085:17): [True: 0, False: 0] ------------------ 1086| 0| { 1087| 0| switch (this->m_traits.syntax_type(*m_position)) 1088| 0| { 1089| 0| case regex_constants::syntax_star: ------------------ | Branch (1089:16): [True: 0, False: 0] ------------------ 1090| 0| case regex_constants::syntax_plus: ------------------ | Branch (1090:16): [True: 0, False: 0] ------------------ 1091| 0| case regex_constants::syntax_question: ------------------ | Branch (1091:16): [True: 0, False: 0] ------------------ 1092| 0| case regex_constants::syntax_open_brace: ------------------ | Branch (1092:16): [True: 0, False: 0] ------------------ 1093| 0| fail(regex_constants::error_badrepeat, m_position - m_base); 1094| 0| return false; 1095| 0| case regex_constants::syntax_open_mark: ------------------ | Branch (1095:16): [True: 0, False: 0] ------------------ 1096| | // Do we have a comment? If so we need to skip it here... 1097| 0| if ((m_position + 2 < m_end) && this->m_traits.syntax_type(*(m_position + 1)) == regex_constants::syntax_question ------------------ | Branch (1097:23): [True: 0, False: 0] | Branch (1097:51): [True: 0, False: 0] ------------------ 1098| 0| && this->m_traits.syntax_type(*(m_position + 2)) == regex_constants::syntax_hash) ------------------ | Branch (1098:25): [True: 0, False: 0] ------------------ 1099| 0| { 1100| 0| while ((m_position != m_end) ------------------ | Branch (1100:29): [True: 0, False: 0] ------------------ 1101| 0| && (this->m_traits.syntax_type(*m_position++) != regex_constants::syntax_close_mark)) { ------------------ | Branch (1101:28): [True: 0, False: 0] ------------------ 1102| 0| } 1103| 0| contin = true; 1104| 0| } 1105| 0| else 1106| 0| contin = false; 1107| 0| break; 1108| 0| default: ------------------ | Branch (1108:16): [True: 0, False: 0] ------------------ 1109| 0| contin = false; 1110| 0| } 1111| 0| } 1112| 0| else 1113| 0| contin = false; 1114| 0| } while (contin); ------------------ | Branch (1114:19): [True: 0, False: 0] ------------------ 1115| 0| } 1116| 0| re_brace* pb = static_cast(this->insert_state(insert_point, syntax_element_startmark, sizeof(re_brace))); 1117| 0| pb->index = -3; 1118| 0| pb->icase = this->flags() & regbase::icase; 1119| 0| jmp = static_cast(this->insert_state(insert_point + sizeof(re_brace), syntax_element_jump, sizeof(re_jump))); 1120| 0| this->m_pdata->m_data.align(); 1121| 0| jmp->alt.i = this->m_pdata->m_data.size() - this->getoffset(jmp); 1122| 0| pb = static_cast(this->append_state(syntax_element_endmark, sizeof(re_brace))); 1123| 0| pb->index = -3; 1124| 0| pb->icase = this->flags() & regbase::icase; 1125| 0| } 1126| 28.8k| return true; 1127| 28.8k|} _ZN5boost13re_detail_50018basic_regex_parserIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE9parse_altEv: 1271| 176k|{ 1272| | // 1273| | // error check: if there have been no previous states, 1274| | // or if the last state was a '(' then error: 1275| | // 1276| 176k| if( 1277| 176k| ((this->m_last_state == 0) || (this->m_last_state->type == syntax_element_startmark)) ------------------ | Branch (1277:8): [True: 0, False: 176k] | Branch (1277:37): [True: 0, False: 176k] ------------------ 1278| 176k| && 1279| 176k| !( 1280| 0| ((this->flags() & regbase::main_option_type) == regbase::perl_syntax_group) ------------------ | Branch (1280:10): [True: 0, False: 0] ------------------ 1281| 0| && 1282| 0| ((this->flags() & regbase::no_empty_expressions) == 0) ------------------ | Branch (1282:10): [True: 0, False: 0] ------------------ 1283| 0| ) 1284| 176k| ) 1285| 0| { 1286| 0| fail(regex_constants::error_empty, this->m_position - this->m_base, "A regular expression cannot start with the alternation operator |."); 1287| 0| return false; 1288| 0| } 1289| | // 1290| | // Reset mark count if required: 1291| | // 1292| 176k| if(m_max_mark < m_mark_count) ------------------ | Branch (1292:7): [True: 13.5k, False: 162k] ------------------ 1293| 13.5k| m_max_mark = m_mark_count; 1294| 176k| if(m_mark_reset >= 0) ------------------ | Branch (1294:7): [True: 0, False: 176k] ------------------ 1295| 0| m_mark_count = m_mark_reset; 1296| | 1297| 176k| ++m_position; 1298| | // 1299| | // we need to append a trailing jump: 1300| | // 1301| 176k| re_syntax_base* pj = this->append_state(BOOST_REGEX_DETAIL_NS::syntax_element_jump, sizeof(re_jump)); ------------------ | | 158| 176k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 176k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 176k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 176k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1302| 176k| std::ptrdiff_t jump_offset = this->getoffset(pj); 1303| | // 1304| | // now insert the alternative: 1305| | // 1306| 176k| re_alt* palt = static_cast(this->insert_state(this->m_alt_insert_point, syntax_element_alt, re_alt_size)); 1307| 176k| jump_offset += re_alt_size; 1308| 176k| this->m_pdata->m_data.align(); 1309| 176k| palt->alt.i = this->m_pdata->m_data.size() - this->getoffset(palt); 1310| | // 1311| | // update m_alt_insert_point so that the next alternate gets 1312| | // inserted at the start of the second of the two we've just created: 1313| | // 1314| 176k| this->m_alt_insert_point = this->m_pdata->m_data.size(); 1315| | // 1316| | // the start of this alternative must have a case changes state 1317| | // if the current block has messed around with case changes: 1318| | // 1319| 176k| if(m_has_case_change) ------------------ | Branch (1319:7): [True: 0, False: 176k] ------------------ 1320| 0| { 1321| 0| static_cast( 1322| 0| this->append_state(syntax_element_toggle_case, sizeof(re_case)) 1323| 0| )->icase = this->m_icase; 1324| 0| } 1325| | // 1326| | // push the alternative onto our stack, a recursive 1327| | // implementation here is easier to understand (and faster 1328| | // as it happens), but causes all kinds of stack overflow problems 1329| | // on programs with small stacks (COM+). 1330| | // 1331| 176k| m_alt_jumps.push_back(jump_offset); 1332| 176k| return true; 1333| 176k|} _ZN5boost13re_detail_50018basic_regex_parserIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE9parse_setEv: 1337| 23.7k|{ 1338| 23.7k| static const char incomplete_message[] = "Character set declaration starting with [ terminated prematurely - either no ] was found or the set had no content."; 1339| 23.7k| ++m_position; 1340| 23.7k| if(m_position == m_end) ------------------ | Branch (1340:7): [True: 0, False: 23.7k] ------------------ 1341| 0| { 1342| 0| fail(regex_constants::error_brack, m_position - m_base, incomplete_message); 1343| 0| return false; 1344| 0| } 1345| 23.7k| basic_char_set char_set; 1346| | 1347| 23.7k| const charT* base = m_position; // where the '[' was 1348| 23.7k| const charT* item_base = m_position; // where the '[' or '^' was 1349| | 1350| 72.9k| while(m_position != m_end) ------------------ | Branch (1350:10): [True: 72.9k, False: 0] ------------------ 1351| 72.9k| { 1352| 72.9k| switch(this->m_traits.syntax_type(*m_position)) 1353| 72.9k| { 1354| 8.48k| case regex_constants::syntax_caret: ------------------ | Branch (1354:7): [True: 8.48k, False: 64.4k] ------------------ 1355| 8.48k| if(m_position == base) ------------------ | Branch (1355:13): [True: 8.48k, False: 0] ------------------ 1356| 8.48k| { 1357| 8.48k| char_set.negate(); 1358| 8.48k| ++m_position; 1359| 8.48k| item_base = m_position; 1360| 8.48k| } 1361| 0| else 1362| 0| parse_set_literal(char_set); 1363| 8.48k| break; 1364| 23.7k| case regex_constants::syntax_close_set: ------------------ | Branch (1364:7): [True: 23.7k, False: 49.1k] ------------------ 1365| 23.7k| if(m_position == item_base) ------------------ | Branch (1365:13): [True: 0, False: 23.7k] ------------------ 1366| 0| { 1367| 0| parse_set_literal(char_set); 1368| 0| break; 1369| 0| } 1370| 23.7k| else 1371| 23.7k| { 1372| 23.7k| ++m_position; 1373| 23.7k| if(0 == this->append_set(char_set)) ------------------ | Branch (1373:16): [True: 0, False: 23.7k] ------------------ 1374| 0| { 1375| 0| fail(regex_constants::error_ctype, m_position - m_base); 1376| 0| return false; 1377| 0| } 1378| 23.7k| } 1379| 23.7k| return true; 1380| 15.2k| case regex_constants::syntax_open_set: ------------------ | Branch (1380:7): [True: 15.2k, False: 57.6k] ------------------ 1381| 15.2k| if(parse_inner_set(char_set)) ------------------ | Branch (1381:13): [True: 15.2k, False: 0] ------------------ 1382| 15.2k| break; 1383| 0| return true; 1384| 11.8k| case regex_constants::syntax_escape: ------------------ | Branch (1384:7): [True: 11.8k, False: 61.0k] ------------------ 1385| 11.8k| { 1386| | // 1387| | // look ahead and see if this is a character class shortcut 1388| | // \d \w \s etc... 1389| | // 1390| 11.8k| ++m_position; 1391| 11.8k| if(this->m_traits.escape_syntax_type(*m_position) ------------------ | Branch (1391:16): [True: 0, False: 11.8k] ------------------ 1392| 11.8k| == regex_constants::escape_type_class) 1393| 0| { 1394| 0| char_class_type m = this->m_traits.lookup_classname(m_position, m_position+1); 1395| 0| if(m != 0) ------------------ | Branch (1395:19): [True: 0, False: 0] ------------------ 1396| 0| { 1397| 0| char_set.add_class(m); 1398| 0| ++m_position; 1399| 0| break; 1400| 0| } 1401| 0| } 1402| 11.8k| else if(this->m_traits.escape_syntax_type(*m_position) ------------------ | Branch (1402:21): [True: 0, False: 11.8k] ------------------ 1403| 11.8k| == regex_constants::escape_type_not_class) 1404| 0| { 1405| | // negated character class: 1406| 0| char_class_type m = this->m_traits.lookup_classname(m_position, m_position+1); 1407| 0| if(m != 0) ------------------ | Branch (1407:19): [True: 0, False: 0] ------------------ 1408| 0| { 1409| 0| char_set.add_negated_class(m); 1410| 0| ++m_position; 1411| 0| break; 1412| 0| } 1413| 0| } 1414| | // not a character class, just a regular escape: 1415| 11.8k| --m_position; 1416| 11.8k| parse_set_literal(char_set); 1417| 11.8k| break; 1418| 11.8k| } 1419| 13.5k| default: ------------------ | Branch (1419:7): [True: 13.5k, False: 59.3k] ------------------ 1420| 13.5k| parse_set_literal(char_set); 1421| 13.5k| break; 1422| 72.9k| } 1423| 72.9k| } 1424| 0| return m_position != m_end; 1425| 23.7k|} _ZN5boost13re_detail_50018basic_regex_parserIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE17parse_set_literalERNS0_14basic_char_setIcS5_EE: 1591| 25.4k|{ 1592| 25.4k| digraph start_range(get_next_set_literal(char_set)); 1593| 25.4k| if(m_end == m_position) ------------------ | Branch (1593:7): [True: 0, False: 25.4k] ------------------ 1594| 0| { 1595| 0| fail(regex_constants::error_brack, m_position - m_base); 1596| 0| return; 1597| 0| } 1598| 25.4k| if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_dash) ------------------ | Branch (1598:7): [True: 3.39k, False: 22.0k] ------------------ 1599| 3.39k| { 1600| | // we have a range: 1601| 3.39k| if(m_end == ++m_position) ------------------ | Branch (1601:10): [True: 0, False: 3.39k] ------------------ 1602| 0| { 1603| 0| fail(regex_constants::error_brack, m_position - m_base); 1604| 0| return; 1605| 0| } 1606| 3.39k| if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_set) ------------------ | Branch (1606:10): [True: 0, False: 3.39k] ------------------ 1607| 0| { 1608| 0| digraph end_range = get_next_set_literal(char_set); 1609| 0| char_set.add_range(start_range, end_range); 1610| 0| if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_dash) ------------------ | Branch (1610:13): [True: 0, False: 0] ------------------ 1611| 0| { 1612| 0| if(m_end == ++m_position) ------------------ | Branch (1612:16): [True: 0, False: 0] ------------------ 1613| 0| { 1614| 0| fail(regex_constants::error_brack, m_position - m_base); 1615| 0| return; 1616| 0| } 1617| 0| if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_set) ------------------ | Branch (1617:16): [True: 0, False: 0] ------------------ 1618| 0| { 1619| | // trailing - : 1620| 0| --m_position; 1621| 0| return; 1622| 0| } 1623| 0| fail(regex_constants::error_range, m_position - m_base); 1624| 0| return; 1625| 0| } 1626| 0| return; 1627| 0| } 1628| 3.39k| --m_position; 1629| 3.39k| } 1630| 25.4k| char_set.add_single(start_range); 1631| 25.4k|} _ZN5boost13re_detail_50018basic_regex_parserIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE20get_next_set_literalERNS0_14basic_char_setIcS5_EE: 1635| 25.4k|{ 1636| 25.4k| digraph result; 1637| 25.4k| switch(this->m_traits.syntax_type(*m_position)) 1638| 25.4k| { 1639| 3.39k| case regex_constants::syntax_dash: ------------------ | Branch (1639:4): [True: 3.39k, False: 22.0k] ------------------ 1640| 3.39k| if(!char_set.empty()) ------------------ | Branch (1640:10): [True: 3.39k, False: 0] ------------------ 1641| 3.39k| { 1642| | // see if we are at the end of the set: 1643| 3.39k| if((++m_position == m_end) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_set)) ------------------ | Branch (1643:13): [True: 0, False: 3.39k] | Branch (1643:40): [True: 0, False: 3.39k] ------------------ 1644| 0| { 1645| 0| fail(regex_constants::error_range, m_position - m_base); 1646| 0| return result; 1647| 0| } 1648| 3.39k| --m_position; 1649| 3.39k| } 1650| 3.39k| result.first = *m_position++; 1651| 3.39k| return result; 1652| 11.8k| case regex_constants::syntax_escape: ------------------ | Branch (1652:4): [True: 11.8k, False: 13.5k] ------------------ 1653| | // check to see if escapes are supported first: 1654| 11.8k| if(this->flags() & regex_constants::no_escape_in_lists) ------------------ | Branch (1654:10): [True: 0, False: 11.8k] ------------------ 1655| 0| { 1656| 0| result = *m_position++; 1657| 0| break; 1658| 0| } 1659| 11.8k| ++m_position; 1660| 11.8k| result = unescape_character(); 1661| 11.8k| break; 1662| 0| case regex_constants::syntax_open_set: ------------------ | Branch (1662:4): [True: 0, False: 25.4k] ------------------ 1663| 0| { 1664| 0| if(m_end == ++m_position) ------------------ | Branch (1664:10): [True: 0, False: 0] ------------------ 1665| 0| { 1666| 0| fail(regex_constants::error_collate, m_position - m_base); 1667| 0| return result; 1668| 0| } 1669| 0| if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_dot) ------------------ | Branch (1669:10): [True: 0, False: 0] ------------------ 1670| 0| { 1671| 0| --m_position; 1672| 0| result.first = *m_position; 1673| 0| ++m_position; 1674| 0| return result; 1675| 0| } 1676| 0| if(m_end == ++m_position) ------------------ | Branch (1676:10): [True: 0, False: 0] ------------------ 1677| 0| { 1678| 0| fail(regex_constants::error_collate, m_position - m_base); 1679| 0| return result; 1680| 0| } 1681| 0| const charT* name_first = m_position; 1682| | // skip at least one character, then find the matching ':]' 1683| 0| if(m_end == ++m_position) ------------------ | Branch (1683:10): [True: 0, False: 0] ------------------ 1684| 0| { 1685| 0| fail(regex_constants::error_collate, name_first - m_base); 1686| 0| return result; 1687| 0| } 1688| 0| while((m_position != m_end) ------------------ | Branch (1688:13): [True: 0, False: 0] ------------------ 1689| 0| && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_dot)) ------------------ | Branch (1689:13): [True: 0, False: 0] ------------------ 1690| 0| ++m_position; 1691| 0| const charT* name_last = m_position; 1692| 0| if(m_end == m_position) ------------------ | Branch (1692:10): [True: 0, False: 0] ------------------ 1693| 0| { 1694| 0| fail(regex_constants::error_collate, name_first - m_base); 1695| 0| return result; 1696| 0| } 1697| 0| if((m_end == ++m_position) ------------------ | Branch (1697:10): [True: 0, False: 0] ------------------ 1698| 0| || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_set)) ------------------ | Branch (1698:13): [True: 0, False: 0] ------------------ 1699| 0| { 1700| 0| fail(regex_constants::error_collate, name_first - m_base); 1701| 0| return result; 1702| 0| } 1703| 0| ++m_position; 1704| 0| string_type s = this->m_traits.lookup_collatename(name_first, name_last); 1705| 0| if(s.empty() || (s.size() > 2)) ------------------ | Branch (1705:10): [True: 0, False: 0] | Branch (1705:23): [True: 0, False: 0] ------------------ 1706| 0| { 1707| 0| fail(regex_constants::error_collate, name_first - m_base); 1708| 0| return result; 1709| 0| } 1710| 0| result.first = s[0]; 1711| 0| if(s.size() > 1) ------------------ | Branch (1711:10): [True: 0, False: 0] ------------------ 1712| 0| result.second = s[1]; 1713| 0| else 1714| 0| result.second = 0; 1715| 0| return result; 1716| 0| } 1717| 10.1k| default: ------------------ | Branch (1717:4): [True: 10.1k, False: 15.2k] ------------------ 1718| 10.1k| result = *m_position++; 1719| 25.4k| } 1720| 22.0k| return result; 1721| 25.4k|} _ZN5boost13re_detail_50018basic_regex_parserIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE15parse_inner_setERNS0_14basic_char_setIcS5_EE: 1429| 15.2k|{ 1430| 15.2k| static const char incomplete_message[] = "Character class declaration starting with [ terminated prematurely - either no ] was found or the set had no content."; 1431| | // 1432| | // we have either a character class [:name:] 1433| | // a collating element [.name.] 1434| | // or an equivalence class [=name=] 1435| | // 1436| 15.2k| if(m_end == ++m_position) ------------------ | Branch (1436:7): [True: 0, False: 15.2k] ------------------ 1437| 0| { 1438| 0| fail(regex_constants::error_brack, m_position - m_base, incomplete_message); 1439| 0| return false; 1440| 0| } 1441| 15.2k| switch(this->m_traits.syntax_type(*m_position)) 1442| 15.2k| { 1443| 0| case regex_constants::syntax_dot: ------------------ | Branch (1443:4): [True: 0, False: 15.2k] ------------------ 1444| | // 1445| | // a collating element is treated as a literal: 1446| | // 1447| 0| --m_position; 1448| 0| parse_set_literal(char_set); 1449| 0| return true; 1450| 15.2k| case regex_constants::syntax_colon: ------------------ | Branch (1450:4): [True: 15.2k, False: 0] ------------------ 1451| 15.2k| { 1452| | // check that character classes are actually enabled: 1453| 15.2k| if((this->flags() & (regbase::main_option_type | regbase::no_char_classes)) ------------------ | Branch (1453:10): [True: 0, False: 15.2k] ------------------ 1454| 15.2k| == (regbase::basic_syntax_group | regbase::no_char_classes)) 1455| 0| { 1456| 0| --m_position; 1457| 0| parse_set_literal(char_set); 1458| 0| return true; 1459| 0| } 1460| | // skip the ':' 1461| 15.2k| if(m_end == ++m_position) ------------------ | Branch (1461:10): [True: 0, False: 15.2k] ------------------ 1462| 0| { 1463| 0| fail(regex_constants::error_brack, m_position - m_base, incomplete_message); 1464| 0| return false; 1465| 0| } 1466| 15.2k| const charT* name_first = m_position; 1467| | // skip at least one character, then find the matching ':]' 1468| 15.2k| if(m_end == ++m_position) ------------------ | Branch (1468:10): [True: 0, False: 15.2k] ------------------ 1469| 0| { 1470| 0| fail(regex_constants::error_brack, m_position - m_base, incomplete_message); 1471| 0| return false; 1472| 0| } 1473| 74.6k| while((m_position != m_end) ------------------ | Branch (1473:13): [True: 74.6k, False: 0] ------------------ 1474| 74.6k| && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_colon)) ------------------ | Branch (1474:13): [True: 59.3k, False: 15.2k] ------------------ 1475| 59.3k| ++m_position; 1476| 15.2k| const charT* name_last = m_position; 1477| 15.2k| if(m_end == m_position) ------------------ | Branch (1477:10): [True: 0, False: 15.2k] ------------------ 1478| 0| { 1479| 0| fail(regex_constants::error_brack, m_position - m_base, incomplete_message); 1480| 0| return false; 1481| 0| } 1482| 15.2k| if((m_end == ++m_position) ------------------ | Branch (1482:10): [True: 0, False: 15.2k] ------------------ 1483| 15.2k| || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_set)) ------------------ | Branch (1483:13): [True: 0, False: 15.2k] ------------------ 1484| 0| { 1485| 0| fail(regex_constants::error_brack, m_position - m_base, incomplete_message); 1486| 0| return false; 1487| 0| } 1488| | // 1489| | // check for negated class: 1490| | // 1491| 15.2k| bool negated = false; 1492| 15.2k| if(this->m_traits.syntax_type(*name_first) == regex_constants::syntax_caret) ------------------ | Branch (1492:10): [True: 0, False: 15.2k] ------------------ 1493| 0| { 1494| 0| ++name_first; 1495| 0| negated = true; 1496| 0| } 1497| 15.2k| typedef typename traits::char_class_type m_type; 1498| 15.2k| m_type m = this->m_traits.lookup_classname(name_first, name_last); 1499| 15.2k| if(m == 0) ------------------ | Branch (1499:10): [True: 0, False: 15.2k] ------------------ 1500| 0| { 1501| 0| if(char_set.empty() && (name_last - name_first == 1)) ------------------ | Branch (1501:13): [True: 0, False: 0] | Branch (1501:33): [True: 0, False: 0] ------------------ 1502| 0| { 1503| | // maybe a special case: 1504| 0| ++m_position; 1505| 0| if( (m_position != m_end) ------------------ | Branch (1505:17): [True: 0, False: 0] ------------------ 1506| 0| && (this->m_traits.syntax_type(*m_position) ------------------ | Branch (1506:19): [True: 0, False: 0] ------------------ 1507| 0| == regex_constants::syntax_close_set)) 1508| 0| { 1509| 0| if(this->m_traits.escape_syntax_type(*name_first) ------------------ | Branch (1509:19): [True: 0, False: 0] ------------------ 1510| 0| == regex_constants::escape_type_left_word) 1511| 0| { 1512| 0| ++m_position; 1513| 0| this->append_state(syntax_element_word_start); 1514| 0| return false; 1515| 0| } 1516| 0| if(this->m_traits.escape_syntax_type(*name_first) ------------------ | Branch (1516:19): [True: 0, False: 0] ------------------ 1517| 0| == regex_constants::escape_type_right_word) 1518| 0| { 1519| 0| ++m_position; 1520| 0| this->append_state(syntax_element_word_end); 1521| 0| return false; 1522| 0| } 1523| 0| } 1524| 0| } 1525| 0| fail(regex_constants::error_ctype, name_first - m_base); 1526| 0| return false; 1527| 0| } 1528| 15.2k| if(!negated) ------------------ | Branch (1528:10): [True: 15.2k, False: 0] ------------------ 1529| 15.2k| char_set.add_class(m); 1530| 0| else 1531| 0| char_set.add_negated_class(m); 1532| 15.2k| ++m_position; 1533| 15.2k| break; 1534| 15.2k| } 1535| 0| case regex_constants::syntax_equal: ------------------ | Branch (1535:4): [True: 0, False: 15.2k] ------------------ 1536| 0| { 1537| | // skip the '=' 1538| 0| if(m_end == ++m_position) ------------------ | Branch (1538:10): [True: 0, False: 0] ------------------ 1539| 0| { 1540| 0| fail(regex_constants::error_brack, m_position - m_base, incomplete_message); 1541| 0| return false; 1542| 0| } 1543| 0| const charT* name_first = m_position; 1544| | // skip at least one character, then find the matching '=]' 1545| 0| if(m_end == ++m_position) ------------------ | Branch (1545:10): [True: 0, False: 0] ------------------ 1546| 0| { 1547| 0| fail(regex_constants::error_brack, m_position - m_base, incomplete_message); 1548| 0| return false; 1549| 0| } 1550| 0| while((m_position != m_end) ------------------ | Branch (1550:13): [True: 0, False: 0] ------------------ 1551| 0| && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_equal)) ------------------ | Branch (1551:13): [True: 0, False: 0] ------------------ 1552| 0| ++m_position; 1553| 0| const charT* name_last = m_position; 1554| 0| if(m_end == m_position) ------------------ | Branch (1554:10): [True: 0, False: 0] ------------------ 1555| 0| { 1556| 0| fail(regex_constants::error_brack, m_position - m_base, incomplete_message); 1557| 0| return false; 1558| 0| } 1559| 0| if((m_end == ++m_position) ------------------ | Branch (1559:10): [True: 0, False: 0] ------------------ 1560| 0| || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_set)) ------------------ | Branch (1560:13): [True: 0, False: 0] ------------------ 1561| 0| { 1562| 0| fail(regex_constants::error_brack, m_position - m_base, incomplete_message); 1563| 0| return false; 1564| 0| } 1565| 0| string_type m = this->m_traits.lookup_collatename(name_first, name_last); 1566| 0| if(m.empty() || (m.size() > 2)) ------------------ | Branch (1566:10): [True: 0, False: 0] | Branch (1566:23): [True: 0, False: 0] ------------------ 1567| 0| { 1568| 0| fail(regex_constants::error_collate, name_first - m_base); 1569| 0| return false; 1570| 0| } 1571| 0| digraph d; 1572| 0| d.first = m[0]; 1573| 0| if(m.size() > 1) ------------------ | Branch (1573:10): [True: 0, False: 0] ------------------ 1574| 0| d.second = m[1]; 1575| 0| else 1576| 0| d.second = 0; 1577| 0| char_set.add_equivalent(d); 1578| 0| ++m_position; 1579| 0| break; 1580| 0| } 1581| 0| default: ------------------ | Branch (1581:4): [True: 0, False: 15.2k] ------------------ 1582| 0| --m_position; 1583| 0| parse_set_literal(char_set); 1584| 0| break; 1585| 15.2k| } 1586| 15.2k| return true; 1587| 15.2k|} _ZN5boost13re_detail_50018basic_regex_parserIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE13parse_literalEv: 422| 992k|{ 423| | // append this as a literal provided it's not a space character 424| | // or the perl option regbase::mod_x is not set: 425| 992k| if( 426| 992k| ((this->flags() ------------------ | Branch (426:7): [True: 992k, False: 0] ------------------ 427| 992k| & (regbase::main_option_type|regbase::mod_x|regbase::no_perl_ex)) 428| 992k| != regbase::mod_x) 429| 992k| || !this->m_traits.isctype(*m_position, this->m_mask_space)) ------------------ | Branch (429:10): [True: 0, False: 0] ------------------ 430| 992k| this->append_literal(*m_position); 431| 992k| ++m_position; 432| 992k| return true; 433| 992k|} _ZN5boost13re_detail_50018basic_regex_parserIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE9parse_allEv: 247| 35.6k|{ 248| 35.6k| if (++m_recursion_count > 400) ------------------ | Branch (248:8): [True: 0, False: 35.6k] ------------------ 249| 0| { 250| | // exceeded internal limits 251| 0| fail(boost::regex_constants::error_complexity, m_position - m_base, "Exceeded nested brace limit."); 252| 0| } 253| 35.6k| bool result = true; 254| 1.34M| while(result && (m_position != m_end)) ------------------ | Branch (254:10): [True: 1.31M, False: 32.2k] | Branch (254:20): [True: 1.31M, False: 3.39k] ------------------ 255| 1.31M| { 256| 1.31M| result = (this->*m_parser_proc)(); 257| 1.31M| } 258| 35.6k| --m_recursion_count; 259| 35.6k| return result; 260| 35.6k|} _ZN5boost13re_detail_50018basic_regex_parserIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE11unwind_altsEl: 3080| 35.6k|{ 3081| | // 3082| | // If we didn't actually add any states after the last 3083| | // alternative then that's an error: 3084| | // 3085| 35.6k| if((this->m_alt_insert_point == static_cast(this->m_pdata->m_data.size())) ------------------ | Branch (3085:7): [True: 0, False: 35.6k] ------------------ 3086| 35.6k| && (!m_alt_jumps.empty()) && (m_alt_jumps.back() > last_paren_start) ------------------ | Branch (3086:10): [True: 0, False: 0] | Branch (3086:36): [True: 0, False: 0] ------------------ 3087| 35.6k| && 3088| 35.6k| !( 3089| 0| ((this->flags() & regbase::main_option_type) == regbase::perl_syntax_group) ------------------ | Branch (3089:10): [True: 0, False: 0] ------------------ 3090| 0| && 3091| 0| ((this->flags() & regbase::no_empty_expressions) == 0) ------------------ | Branch (3091:10): [True: 0, False: 0] ------------------ 3092| 0| ) 3093| 35.6k| ) 3094| 0| { 3095| 0| fail(regex_constants::error_empty, this->m_position - this->m_base, "Can't terminate a sub-expression with an alternation operator |."); 3096| 0| return false; 3097| 0| } 3098| | // 3099| | // Fix up our alternatives: 3100| | // 3101| 212k| while((!m_alt_jumps.empty()) && (m_alt_jumps.back() > last_paren_start)) ------------------ | Branch (3101:10): [True: 203k, False: 8.48k] | Branch (3101:36): [True: 176k, False: 27.1k] ------------------ 3102| 176k| { 3103| | // 3104| | // fix up the jump to point to the end of the states 3105| | // that we've just added: 3106| | // 3107| 176k| std::ptrdiff_t jump_offset = m_alt_jumps.back(); 3108| 176k| m_alt_jumps.pop_back(); 3109| 176k| this->m_pdata->m_data.align(); 3110| 176k| re_jump* jmp = static_cast(this->getaddress(jump_offset)); 3111| 176k| if (jmp->type != syntax_element_jump) ------------------ | Branch (3111:11): [True: 0, False: 176k] ------------------ 3112| 0| { 3113| | // Something really bad happened, this used to be an assert, 3114| | // but we'll make it an error just in case we should ever get here. 3115| 0| fail(regex_constants::error_unknown, this->m_position - this->m_base, "Internal logic failed while compiling the expression, probably you added a repeat to something non-repeatable!"); 3116| 0| return false; 3117| 0| } 3118| 176k| jmp->alt.i = this->m_pdata->m_data.size() - jump_offset; 3119| 176k| } 3120| 35.6k| return true; 3121| 35.6k|} _ZN5boost16cpp_regex_traitsIcEC2Ev: 749| 2| : m_pimpl(BOOST_REGEX_DETAIL_NS::create_cpp_regex_traits(std::locale())) ------------------ | | 158| 2|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 2|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 2|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 2|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 750| 2| { } _ZN5boost13re_detail_50023create_cpp_regex_traitsIcEENSt3__110shared_ptrIKNS0_31cpp_regex_traits_implementationIT_EEEERKNS2_6localeE: 727| 2|{ 728| 2| cpp_regex_traits_base key(l); 729| 2| return ::boost::object_cache, cpp_regex_traits_implementation >::get(key, 5); 730| 2|} _ZN5boost13re_detail_50021cpp_regex_traits_baseIcEC2ERKNSt3__16localeE: 156| 2| { (void)imbue(l); } _ZN5boost13re_detail_50021cpp_regex_traits_baseIcE5imbueERKNSt3__16localeE: 186| 2|{ 187| 2| std::locale result(m_locale); 188| 2| m_locale = l; 189| 2| m_pctype = &std::use_facet>(l); 190| 2| m_pmessages = std::has_facet >(l) ? &std::use_facet >(l) : 0; ------------------ | Branch (190:18): [True: 2, False: 0] ------------------ 191| 2| m_pcollate = &std::use_facet >(l); 192| 2| return result; 193| 2|} _ZNK5boost13re_detail_50021cpp_regex_traits_baseIcEltERKS2_: 165| 10| { 166| 10| if(m_pctype == b.m_pctype) ------------------ | Branch (166:10): [True: 10, False: 0] ------------------ 167| 10| { 168| 10| if(m_pmessages == b.m_pmessages) ------------------ | Branch (168:13): [True: 10, False: 0] ------------------ 169| 10| { 170| 10| return m_pcollate < b.m_pcollate; 171| 10| } 172| 0| return m_pmessages < b.m_pmessages; 173| 10| } 174| 0| return m_pctype < b.m_pctype; 175| 10| } _ZNK5boost13re_detail_50021cpp_regex_traits_baseIcEeqERKS2_: 177| 1| { 178| 1| return (m_pctype == b.m_pctype) ------------------ | Branch (178:14): [True: 1, False: 0] ------------------ 179| 1| && (m_pmessages == b.m_pmessages) ------------------ | Branch (179:13): [True: 1, False: 0] ------------------ 180| 1| && (m_pcollate == b.m_pcollate); ------------------ | Branch (180:13): [True: 1, False: 0] ------------------ 181| 1| } _ZN5boost13re_detail_50031cpp_regex_traits_implementationIcEC2ERKNS0_21cpp_regex_traits_baseIcEE: 378| 1| : cpp_regex_traits_char_layer(l) 379| 1| { 380| 1| init(); 381| 1| } _ZN5boost13re_detail_50027cpp_regex_traits_char_layerIcEC2ERKNS0_21cpp_regex_traits_baseIcEE: 333| 1| : cpp_regex_traits_base(l) 334| 1| { 335| 1| init(); 336| 1| } _ZN5boost13re_detail_50027cpp_regex_traits_char_layerIcE4initEv: 954| 1| { 955| | // we need to start by initialising our syntax map so we know which 956| | // character is used for which purpose: 957| 1| std::memset(m_char_map, 0, sizeof(m_char_map)); 958| 1|#ifndef __IBMCPP__ 959| 1| std::messages::catalog cat = static_cast::catalog>(-1); 960| |#else 961| | std::messages::catalog cat = reinterpret_cast::catalog>(-1); 962| |#endif 963| 1| std::string cat_name(cpp_regex_traits::get_catalog_name()); 964| 1| if ((!cat_name.empty()) && (m_pmessages != 0)) ------------------ | Branch (964:11): [True: 0, False: 1] | Branch (964:34): [True: 0, False: 0] ------------------ 965| 0| { 966| 0| cat = this->m_pmessages->open( 967| 0| cat_name, 968| 0| this->m_locale); 969| 0| if ((int)cat < 0) ------------------ | Branch (969:14): [True: 0, False: 0] ------------------ 970| 0| { 971| 0| std::string m("Unable to open message catalog: "); 972| 0| std::runtime_error err(m + cat_name); 973| 0| boost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(err); 974| 0| } 975| 0| } 976| | // 977| | // if we have a valid catalog then load our messages: 978| | // 979| 1| if ((int)cat >= 0) ------------------ | Branch (979:11): [True: 0, False: 1] ------------------ 980| 0| { 981| 0|#ifndef BOOST_NO_EXCEPTIONS 982| 0| try { 983| 0|#endif 984| 0| for (regex_constants::syntax_type i = 1; i < regex_constants::syntax_max; ++i) ------------------ | Branch (984:54): [True: 0, False: 0] ------------------ 985| 0| { 986| 0| string_type mss = this->m_pmessages->get(cat, 0, i, get_default_syntax(i)); 987| 0| for (string_type::size_type j = 0; j < mss.size(); ++j) ------------------ | Branch (987:51): [True: 0, False: 0] ------------------ 988| 0| { 989| 0| m_char_map[static_cast(mss[j])] = i; 990| 0| } 991| 0| } 992| 0| this->m_pmessages->close(cat); 993| 0|#ifndef BOOST_NO_EXCEPTIONS 994| 0| } 995| 0| catch (...) 996| 0| { 997| 0| this->m_pmessages->close(cat); 998| 0| throw; 999| 0| } 1000| 0|#endif 1001| 0| } 1002| 1| else 1003| 1| { 1004| 60| for (regex_constants::syntax_type j = 1; j < regex_constants::syntax_max; ++j) ------------------ | Branch (1004:51): [True: 59, False: 1] ------------------ 1005| 59| { 1006| 59| const char* ptr = get_default_syntax(j); 1007| 120| while (ptr && *ptr) ------------------ | Branch (1007:20): [True: 120, False: 0] | Branch (1007:27): [True: 61, False: 59] ------------------ 1008| 61| { 1009| 61| m_char_map[static_cast(*ptr)] = j; 1010| 61| ++ptr; 1011| 61| } 1012| 59| } 1013| 1| } 1014| | // 1015| | // finish off by calculating our escape types: 1016| | // 1017| 1| unsigned char i = 'A'; 1018| 1| do 1019| 191| { 1020| 191| if (m_char_map[i] == 0) ------------------ | Branch (1020:14): [True: 157, False: 34] ------------------ 1021| 157| { 1022| 157| if (this->m_pctype->is(std::ctype_base::lower, i)) ------------------ | Branch (1022:17): [True: 12, False: 145] ------------------ 1023| 12| m_char_map[i] = regex_constants::escape_type_class; 1024| 145| else if (this->m_pctype->is(std::ctype_base::upper, i)) ------------------ | Branch (1024:22): [True: 14, False: 131] ------------------ 1025| 14| m_char_map[i] = regex_constants::escape_type_not_class; 1026| 157| } 1027| 191| } while (0xFF != i++); ------------------ | Branch (1027:16): [True: 190, False: 1] ------------------ 1028| 1| } _ZN5boost16cpp_regex_traitsIcE16get_catalog_nameEv: 934| 2|{ 935| 2|#ifdef BOOST_HAS_THREADS 936| 2| std::lock_guard lk(get_mutex_inst()); 937| 2|#endif 938| 2| std::string result(get_catalog_name_inst()); 939| 2| return result; 940| 2|} _ZN5boost16cpp_regex_traitsIcE14get_mutex_instEv: 945| 2|{ 946| 2| static std::mutex s_mutex; 947| 2| return s_mutex; 948| 2|} _ZN5boost16cpp_regex_traitsIcE21get_catalog_name_instEv: 927| 2|{ 928| 2| static std::string s_name; 929| 2| return s_name; 930| 2|} _ZN5boost13re_detail_50031cpp_regex_traits_implementationIcE4initEv: 602| 1|{ 603| 1|#ifndef __IBMCPP__ 604| 1| typename std::messages::catalog cat = static_cast::catalog>(-1); 605| |#else 606| | typename std::messages::catalog cat = reinterpret_cast::catalog>(-1); 607| |#endif 608| 1| std::string cat_name(cpp_regex_traits::get_catalog_name()); 609| 1| if((!cat_name.empty()) && (this->m_pmessages != 0)) ------------------ | Branch (609:7): [True: 0, False: 1] | Branch (609:30): [True: 0, False: 0] ------------------ 610| 0| { 611| 0| cat = this->m_pmessages->open( 612| 0| cat_name, 613| 0| this->m_locale); 614| 0| if((int)cat < 0) ------------------ | Branch (614:10): [True: 0, False: 0] ------------------ 615| 0| { 616| 0| std::string m("Unable to open message catalog: "); 617| 0| std::runtime_error err(m + cat_name); 618| 0| boost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(err); 619| 0| } 620| 0| } 621| | // 622| | // if we have a valid catalog then load our messages: 623| | // 624| 1| if((int)cat >= 0) ------------------ | Branch (624:7): [True: 0, False: 1] ------------------ 625| 0| { 626| | // 627| | // Error messages: 628| | // 629| 0| for(boost::regex_constants::error_type i = static_cast(0); 630| 0| i <= boost::regex_constants::error_unknown; ------------------ | Branch (630:10): [True: 0, False: 0] ------------------ 631| 0| i = static_cast(i + 1)) 632| 0| { 633| 0| const char* p = get_default_error_string(i); 634| 0| string_type default_message; 635| 0| while(*p) ------------------ | Branch (635:16): [True: 0, False: 0] ------------------ 636| 0| { 637| 0| default_message.append(1, this->m_pctype->widen(*p)); 638| 0| ++p; 639| 0| } 640| 0| string_type s = this->m_pmessages->get(cat, 0, i+200, default_message); 641| 0| std::string result; 642| 0| for(std::string::size_type j = 0; j < s.size(); ++j) ------------------ | Branch (642:44): [True: 0, False: 0] ------------------ 643| 0| { 644| 0| result.append(1, this->m_pctype->narrow(s[j], 0)); 645| 0| } 646| 0| m_error_strings[i] = result; 647| 0| } 648| | // 649| | // Custom class names: 650| | // 651| 0| static const char_class_type masks[16] = 652| 0| { 653| 0| static_cast(std::ctype::alnum), 654| 0| static_cast(std::ctype::alpha), 655| 0| static_cast(std::ctype::cntrl), 656| 0| static_cast(std::ctype::digit), 657| 0| static_cast(std::ctype::graph), 658| 0| cpp_regex_traits_implementation::mask_horizontal, 659| 0| static_cast(std::ctype::lower), 660| 0| static_cast(std::ctype::print), 661| 0| static_cast(std::ctype::punct), 662| 0| static_cast(std::ctype::space), 663| 0| static_cast(std::ctype::upper), 664| 0| cpp_regex_traits_implementation::mask_vertical, 665| 0| static_cast(std::ctype::xdigit), 666| 0| cpp_regex_traits_implementation::mask_blank, 667| 0| cpp_regex_traits_implementation::mask_word, 668| 0| cpp_regex_traits_implementation::mask_unicode, 669| 0| }; 670| 0| static const string_type null_string; 671| 0| for(unsigned int j = 0; j <= 13; ++j) ------------------ | Branch (671:31): [True: 0, False: 0] ------------------ 672| 0| { 673| 0| string_type s(this->m_pmessages->get(cat, 0, j+300, null_string)); 674| 0| if(!s.empty()) ------------------ | Branch (674:13): [True: 0, False: 0] ------------------ 675| 0| this->m_custom_class_names[s] = masks[j]; 676| 0| } 677| 0| } 678| | // 679| | // get the collation format used by m_pcollate: 680| | // 681| 1| m_collate_type = BOOST_REGEX_DETAIL_NS::find_sort_syntax(this, &m_collate_delim); ------------------ | | 158| 1|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 1|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 1|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 1|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 682| 1|} _ZNK5boost13re_detail_50031cpp_regex_traits_implementationIcE9transformEPKcS4_: 512| 3|{ 513| | // 514| | // PRECONDITIONS: 515| | // 516| | // A bug in gcc 3.2 (and maybe other versions as well) treats 517| | // p1 as a null terminated string, for efficiency reasons 518| | // we work around this elsewhere, but just assert here that 519| | // we adhere to gcc's (buggy) preconditions... 520| | // 521| 3| BOOST_REGEX_ASSERT(*p2 == 0); ------------------ | | 58| 3|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 3|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 522| | // 523| | // swallowing all exceptions here is a bad idea 524| | // however at least one std lib will always throw 525| | // std::bad_alloc for certain arguments... 526| | // 527| 3| string_type result, result2; 528| |#if defined(_CPPLIB_VER) 529| | // 530| | // A bug in VC11 and 12 causes the program to hang if we pass a null-string 531| | // to std::collate::transform, but only for certain locales :-( 532| | // Probably effects Intel and Clang or any compiler using the VC std library (Dinkumware). 533| | // 534| | if(*p1 == 0) 535| | { 536| | return result; 537| | } 538| |#endif 539| 3|#ifndef BOOST_NO_EXCEPTIONS 540| 3| try{ 541| 3|#endif 542| 3| result = this->m_pcollate->transform(p1, p2); 543| | // 544| | // some implementations (Dinkumware) append unnecessary trailing \0's: 545| 3| while((!result.empty()) && (charT(0) == *result.rbegin())) ------------------ | Branch (545:13): [True: 3, False: 0] | Branch (545:13): [True: 0, False: 3] | Branch (545:34): [True: 0, False: 3] ------------------ 546| 0| result.erase(result.size() - 1); 547| | // 548| | // We may have NULL's used as separators between sections of the collate string, 549| | // an example would be Boost.Locale. We have no way to detect this case via 550| | // #defines since this can be used with any compiler/platform combination. 551| | // Unfortunately our state machine (which was devised when all implementations 552| | // used underlying C language API's) can't cope with that case. One workaround 553| | // is to replace each character with 2, fortunately this code isn't used that 554| | // much as this is now slower than before :-( 555| | // 556| 3| typedef typename std::make_unsigned::type uchar_type; 557| 3| result2.reserve(result.size() * 2 + 2); 558| 6| for(unsigned i = 0; i < result.size(); ++i) ------------------ | Branch (558:27): [True: 3, False: 3] ------------------ 559| 3| { 560| 3| if(static_cast(result[i]) == (std::numeric_limits::max)()) ------------------ | Branch (560:13): [True: 0, False: 3] ------------------ 561| 0| { 562| 0| result2.append(1, charT((std::numeric_limits::max)())).append(1, charT('b')); 563| 0| } 564| 3| else 565| 3| { 566| 3| result2.append(1, static_cast(1 + static_cast(result[i]))).append(1, charT('b') - 1); 567| 3| } 568| 3| } 569| 3| BOOST_REGEX_ASSERT(std::find(result2.begin(), result2.end(), charT(0)) == result2.end()); ------------------ | | 58| 3|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 3|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 570| 3|#ifndef BOOST_NO_EXCEPTIONS 571| 3| } 572| 3| catch(...) 573| 3| { 574| 0| } 575| 0|#endif 576| 3| return result2; 577| 3|} _ZNK5boost16cpp_regex_traitsIcE16lookup_classnameEPKcS3_: 792| 32.2k| { 793| 32.2k| return m_pimpl->lookup_classname(p1, p2); 794| 32.2k| } _ZNK5boost13re_detail_50031cpp_regex_traits_implementationIcE16lookup_classnameEPKcS4_: 392| 32.2k| { 393| 32.2k| char_class_type result = lookup_classname_imp(p1, p2); 394| 32.2k| if(result == 0) ------------------ | Branch (394:10): [True: 0, False: 32.2k] ------------------ 395| 0| { 396| 0| string_type temp(p1, p2); 397| 0| this->m_pctype->tolower(&*temp.begin(), &*temp.begin() + temp.size()); 398| 0| result = lookup_classname_imp(&*temp.begin(), &*temp.begin() + temp.size()); 399| 0| } 400| 32.2k| return result; 401| 32.2k| } _ZNK5boost13re_detail_50031cpp_regex_traits_implementationIcE20lookup_classname_impEPKcS4_: 687| 32.2k|{ 688| 32.2k| static const char_class_type masks[22] = 689| 32.2k| { 690| 32.2k| 0, 691| 32.2k| static_cast(std::ctype::alnum), 692| 32.2k| static_cast(std::ctype::alpha), 693| 32.2k| cpp_regex_traits_implementation::mask_blank, 694| 32.2k| static_cast(std::ctype::cntrl), 695| 32.2k| static_cast(std::ctype::digit), 696| 32.2k| static_cast(std::ctype::digit), 697| 32.2k| static_cast(std::ctype::graph), 698| 32.2k| cpp_regex_traits_implementation::mask_horizontal, 699| 32.2k| static_cast(std::ctype::lower), 700| 32.2k| static_cast(std::ctype::lower), 701| 32.2k| static_cast(std::ctype::print), 702| 32.2k| static_cast(std::ctype::punct), 703| 32.2k| static_cast(std::ctype::space), 704| 32.2k| static_cast(std::ctype::space), 705| 32.2k| static_cast(std::ctype::upper), 706| 32.2k| cpp_regex_traits_implementation::mask_unicode, 707| 32.2k| static_cast(std::ctype::upper), 708| 32.2k| cpp_regex_traits_implementation::mask_vertical, 709| 32.2k| static_cast(std::ctype::alnum) | cpp_regex_traits_implementation::mask_word, 710| 32.2k| static_cast(std::ctype::alnum) | cpp_regex_traits_implementation::mask_word, 711| 32.2k| static_cast(std::ctype::xdigit), 712| 32.2k| }; 713| 32.2k| if(!m_custom_class_names.empty()) ------------------ | Branch (713:7): [True: 0, False: 32.2k] ------------------ 714| 0| { 715| 0| typedef typename std::map, char_class_type>::const_iterator map_iter; 716| 0| map_iter pos = m_custom_class_names.find(string_type(p1, p2)); 717| 0| if(pos != m_custom_class_names.end()) ------------------ | Branch (717:10): [True: 0, False: 0] ------------------ 718| 0| return pos->second; 719| 0| } 720| 32.2k| std::size_t state_id = 1 + BOOST_REGEX_DETAIL_NS::get_default_class_id(p1, p2); ------------------ | | 158| 32.2k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 32.2k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 32.2k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 32.2k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 721| 32.2k| BOOST_REGEX_ASSERT(state_id < sizeof(masks) / sizeof(masks[0])); ------------------ | | 58| 32.2k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 32.2k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 722| 32.2k| return masks[state_id]; 723| 32.2k|} _ZNK5boost16cpp_regex_traitsIcE11syntax_typeEc: 756| 1.73M| { 757| 1.73M| return m_pimpl->syntax_type(c); 758| 1.73M| } _ZNK5boost13re_detail_50027cpp_regex_traits_char_layerIcE11syntax_typeEc: 339| 1.73M| { 340| 1.73M| return m_char_map[static_cast(c)]; 341| 1.73M| } _ZNK5boost16cpp_regex_traitsIcE3toiERPKcS3_i: 892| 8.22M|{ 893| 8.22M| BOOST_REGEX_DETAIL_NS::parser_buf sbuf; // buffer for parsing numbers. ------------------ | | 158| 8.22M|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 8.22M|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 8.22M|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 8.22M|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 894| 8.22M| std::basic_istream is(&sbuf); // stream for parsing numbers. 895| | 896| | // we do NOT want to parse any thousands separators inside the stream: 897| 8.22M| last = std::find(first, last, std::use_facet>(is.getloc()).thousands_sep()); 898| | 899| 8.22M| sbuf.pubsetbuf(const_cast(static_cast(first)), static_cast(last-first)); 900| 8.22M| is.clear(); 901| 8.22M| if(std::abs(radix) == 16) is >> std::hex; ------------------ | Branch (901:7): [True: 2.33M, False: 5.88M] ------------------ 902| 5.88M| else if(std::abs(radix) == 8) is >> std::oct; ------------------ | Branch (902:12): [True: 445k, False: 5.44M] ------------------ 903| 5.44M| else is >> std::dec; 904| 8.22M| std::intmax_t val; 905| 8.22M| if(is >> val) ------------------ | Branch (905:7): [True: 5.36M, False: 2.85M] ------------------ 906| 5.36M| { 907| 5.36M| first = first + ((last - first) - sbuf.in_avail()); 908| 5.36M| return val; 909| 5.36M| } 910| 2.85M| else 911| 2.85M| return -1; 912| 8.22M|} _ZN5boost13re_detail_50010parser_bufIcNSt3__111char_traitsIcEEEC2Ev: 70| 8.22M| parser_buf() : base_type() { setbuf(0, 0); } _ZN5boost13re_detail_50010parser_bufIcNSt3__111char_traitsIcEEE6setbufEPcl: 84| 16.4M|{ 85| 16.4M| this->setg(s, s, s + n); 86| 16.4M| return this; 87| 16.4M|} _ZNK5boost16cpp_regex_traitsIcE18escape_syntax_typeEc: 760| 66.1k| { 761| 66.1k| return m_pimpl->escape_syntax_type(c); 762| 66.1k| } _ZNK5boost13re_detail_50027cpp_regex_traits_char_layerIcE18escape_syntax_typeEc: 343| 66.1k| { 344| 66.1k| return m_char_map[static_cast(c)]; 345| 66.1k| } _ZNK5boost16cpp_regex_traitsIcE9translateEcb: 772| 69.2M| { 773| 69.2M| return icase ? m_pimpl->m_pctype->tolower(c) : c; ------------------ | Branch (773:14): [True: 0, False: 69.2M] ------------------ 774| 69.2M| } _ZNK5boost16cpp_regex_traitsIcE7isctypeEcj: 800| 4.34M| { 801| 4.34M| typedef typename std::ctype::mask ctype_mask; 802| | 803| 4.34M| static const ctype_mask mask_base = 804| 4.34M| static_cast( 805| 4.34M| std::ctype::alnum 806| 4.34M| | std::ctype::alpha 807| 4.34M| | std::ctype::cntrl 808| 4.34M| | std::ctype::digit 809| 4.34M| | std::ctype::graph 810| 4.34M| | std::ctype::lower 811| 4.34M| | std::ctype::print 812| 4.34M| | std::ctype::punct 813| 4.34M| | std::ctype::space 814| 4.34M| | std::ctype::upper 815| 4.34M| | std::ctype::xdigit); 816| | 817| 4.34M| if((f & mask_base) ------------------ | Branch (817:10): [True: 3.90M, False: 434k] ------------------ 818| 4.34M| && (m_pimpl->m_pctype->is( ------------------ | Branch (818:13): [True: 722k, False: 3.18M] ------------------ 819| 3.90M| static_cast(f & mask_base), c))) 820| 722k| return true; 821| 3.61M| else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation::mask_unicode) && BOOST_REGEX_DETAIL_NS::is_extended(c)) ------------------ | | 158| 3.61M|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 3.61M|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 3.61M|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 3.61M|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation::mask_unicode) && BOOST_REGEX_DETAIL_NS::is_extended(c)) ------------------ | | 158| 0|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 0|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 0|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 0|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (821:15): [True: 0, False: 3.61M] | Branch (821:100): [True: 0, False: 0] ------------------ 822| 0| return true; 823| 3.61M| else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation::mask_word) && (c == '_')) ------------------ | | 158| 3.61M|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 3.61M|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 3.61M|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 3.61M|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (823:15): [True: 1.53M, False: 2.08M] | Branch (823:97): [True: 5.08k, False: 1.53M] ------------------ 824| 5.08k| return true; 825| 3.61M| else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation::mask_blank) ------------------ | | 158| 3.61M|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 3.61M|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 3.61M|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 3.61M|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (825:15): [True: 434k, False: 3.18M] ------------------ 826| 3.61M| && m_pimpl->m_pctype->is(std::ctype::space, c) ------------------ | Branch (826:13): [True: 10.1k, False: 424k] ------------------ 827| 3.61M| && !BOOST_REGEX_DETAIL_NS::is_separator(c)) ------------------ | | 158| 10.1k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 10.1k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 10.1k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 10.1k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (827:13): [True: 5.08k, False: 5.08k] ------------------ 828| 5.08k| return true; 829| 3.60M| else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation::mask_vertical) ------------------ | | 158| 3.60M|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 3.60M|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 3.60M|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 3.60M|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (829:15): [True: 0, False: 3.60M] ------------------ 830| 3.60M| && (::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) || (c == '\v'))) ------------------ | Branch (830:14): [True: 0, False: 0] | Branch (830:65): [True: 0, False: 0] ------------------ 831| 0| return true; 832| 3.60M| else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation::mask_horizontal) ------------------ | | 158| 3.60M|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 3.60M|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 3.60M|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 3.60M|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (832:15): [True: 0, False: 3.60M] ------------------ 833| 3.60M| && this->isctype(c, std::ctype::space) && !this->isctype(c, BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation::mask_vertical)) ------------------ | | 158| 0|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 0|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 0|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 0|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (833:13): [True: 0, False: 0] | Branch (833:59): [True: 0, False: 0] ------------------ 834| 0| return true; 835| |#ifdef __CYGWIN__ 836| | // 837| | // Cygwin has a buggy ctype facet, see https://www.cygwin.com/ml/cygwin/2012-08/msg00178.html: 838| | // 839| | else if((f & std::ctype::xdigit) == std::ctype::xdigit) 840| | { 841| | if((c >= 'a') && (c <= 'f')) 842| | return true; 843| | if((c >= 'A') && (c <= 'F')) 844| | return true; 845| | } 846| |#endif 847| 3.60M| return false; 848| 4.34M| } _ZN5boost16cpp_regex_traitsIcE6lengthEPKc: 752| 3.39k| { 753| 3.39k| return std::char_traits::length(p); 754| 3.39k| } _ZNK5boost16cpp_regex_traitsIcE7tolowerEc: 776| 6.86M| { 777| 6.86M| return m_pimpl->m_pctype->tolower(c); 778| 6.86M| } _ZNK5boost16cpp_regex_traitsIcE7toupperEc: 780| 17.6M| { 781| 17.6M| return m_pimpl->m_pctype->toupper(c); 782| 17.6M| } _ZN5boost15regex_constantsorENS0_12_match_flagsES1_: 98| 164k|{ return static_cast(static_cast(m1) | static_cast(m2)); } _ZN5boost15regex_constantsoRERNS0_12_match_flagsES1_: 106| 108k|{ m1 = m1|m2; return m1; } _ZN5boost15regex_constantsanENS0_12_match_flagsES1_: 96| 23.4M|{ return static_cast(static_cast(m1) & static_cast(m2)); } _ZN5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEEC2ERKS8_: 62| 1.69k| : m_subs(a), m_base(), m_null(), m_last_closed_paren(0), m_is_singular(true) {} _ZN5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEED2Ev: 90| 1.69k| ~match_results(){} _ZN5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEE9set_firstES4_: 500| 52.5k| { 501| 52.5k| BOOST_REGEX_ASSERT(m_subs.size() > 2); ------------------ | | 58| 52.5k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 52.5k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 502| | // set up prefix: 503| 52.5k| m_subs[1].second = i; 504| 52.5k| m_subs[1].matched = (m_subs[1].first != i); 505| | // set up $0: 506| 52.5k| m_subs[2].first = i; 507| | // zero out everything else: 508| 210k| for(size_type n = 3; n < m_subs.size(); ++n) ------------------ | Branch (508:28): [True: 157k, False: 52.5k] ------------------ 509| 157k| { 510| 157k| m_subs[n].first = m_subs[n].second = m_subs[0].second; 511| 157k| m_subs[n].matched = false; 512| 157k| } 513| 52.5k| } _ZN5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEE9set_firstES4_mb: 515| 52.5k| { 516| 52.5k| BOOST_REGEX_ASSERT(pos+2 < m_subs.size()); ------------------ | | 58| 52.5k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 52.5k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 517| 52.5k| if(pos || escape_k) ------------------ | Branch (517:10): [True: 52.5k, False: 0] | Branch (517:17): [True: 0, False: 0] ------------------ 518| 52.5k| { 519| 52.5k| m_subs[pos+2].first = i; 520| 52.5k| if(escape_k) ------------------ | Branch (520:13): [True: 0, False: 52.5k] ------------------ 521| 0| { 522| 0| m_subs[1].second = i; 523| 0| m_subs[1].matched = (m_subs[1].first != m_subs[1].second); 524| 0| } 525| 52.5k| } 526| 0| else 527| 0| set_first(i); 528| 52.5k| } _ZN5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEE10set_secondES4_: 443| 52.5k| { 444| 52.5k| BOOST_REGEX_ASSERT(m_subs.size() > 2); ------------------ | | 58| 52.5k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 52.5k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 445| 52.5k| m_subs[2].second = i; 446| 52.5k| m_subs[2].matched = true; 447| 52.5k| m_subs[0].first = i; 448| 52.5k| m_subs[0].matched = (m_subs[0].first != m_subs[0].second); 449| 52.5k| m_null.first = i; 450| 52.5k| m_null.second = i; 451| 52.5k| m_null.matched = false; 452| 52.5k| m_is_singular = false; 453| 52.5k| } _ZN5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEE10set_secondES4_mbb: 456| 52.5k| { 457| 52.5k| if(pos) ------------------ | Branch (457:10): [True: 52.5k, False: 0] ------------------ 458| 52.5k| m_last_closed_paren = static_cast(pos); 459| 52.5k| pos += 2; 460| 52.5k| BOOST_REGEX_ASSERT(m_subs.size() > pos); ------------------ | | 58| 52.5k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 52.5k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 461| 52.5k| m_subs[pos].second = i; 462| 52.5k| m_subs[pos].matched = m; 463| 52.5k| if((pos == 2) && !escape_k) ------------------ | Branch (463:10): [True: 0, False: 52.5k] | Branch (463:24): [True: 0, False: 0] ------------------ 464| 0| { 465| 0| m_subs[0].first = i; 466| 0| m_subs[0].matched = (m_subs[0].first != m_subs[0].second); 467| 0| m_null.first = i; 468| 0| m_null.second = i; 469| 0| m_null.matched = false; 470| 0| m_is_singular = false; 471| 0| } 472| 52.5k| } _ZNK5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEE6suffixEv: 307| 55.4k| { 308| 55.4k| if(m_is_singular) ------------------ | Branch (308:10): [True: 0, False: 55.4k] ------------------ 309| 0| raise_logic_error(); 310| 55.4k| return (*this)[-2]; 311| 55.4k| } _ZNK5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEE4sizeEv: 94| 578k| { return empty() ? 0 : m_subs.size() - 2; } ------------------ | Branch (94:13): [True: 0, False: 578k] ------------------ _ZNK5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEE5emptyEv: 98| 578k| { return m_subs.size() < 2; } _ZN5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEE8set_sizeEmS4_S4_: 474| 54.2k| { 475| 54.2k| value_type v(j); 476| 54.2k| size_type len = m_subs.size(); 477| 54.2k| if(len > n + 2) ------------------ | Branch (477:10): [True: 0, False: 54.2k] ------------------ 478| 0| { 479| 0| m_subs.erase(m_subs.begin()+n+2, m_subs.end()); 480| 0| std::fill(m_subs.begin(), m_subs.end(), v); 481| 0| } 482| 54.2k| else 483| 54.2k| { 484| 54.2k| std::fill(m_subs.begin(), m_subs.end(), v); 485| 54.2k| if(n+2 != len) ------------------ | Branch (485:13): [True: 1.69k, False: 52.5k] ------------------ 486| 1.69k| m_subs.insert(m_subs.end(), n+2-len, v); 487| 54.2k| } 488| 54.2k| m_subs[1].first = i; 489| 54.2k| m_last_closed_paren = 0; 490| 54.2k| } _ZN5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEE8set_baseES4_: 492| 105k| { 493| 105k| m_base = pos; 494| 105k| } _ZN5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEE14set_named_subsENS1_10shared_ptrINS_13re_detail_50020named_subexpressionsEEE: 532| 54.2k| { 533| 54.2k| m_named_subs = subs; 534| 54.2k| } _ZNK5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEE6lengthEi: 101| 52.5k| { 102| 52.5k| if(m_is_singular) ------------------ | Branch (102:10): [True: 0, False: 52.5k] ------------------ 103| 0| raise_logic_error(); 104| 52.5k| sub += 2; 105| 52.5k| if((sub < (int)m_subs.size()) && (sub > 0)) ------------------ | Branch (105:10): [True: 52.5k, False: 0] | Branch (105:40): [True: 52.5k, False: 0] ------------------ 106| 52.5k| return m_subs[sub].length(); 107| 0| return 0; 108| 52.5k| } _ZNK5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEE6prefixEv: 300| 276k| { 301| 276k| if(m_is_singular) ------------------ | Branch (301:10): [True: 0, False: 276k] ------------------ 302| 0| raise_logic_error(); 303| 276k| return (*this)[-1]; 304| 276k| } _ZNK5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEE6formatINS1_16ostream_iteratorIccNS1_11char_traitsIcEEEENS1_12basic_stringIcSD_NS5_IcEEEENS_11basic_regexIcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEEEET_SO_T0_NS_15regex_constants12_match_flagsERKT1_: 352| 52.5k| { 353| 52.5k| if(m_is_singular) ------------------ | Branch (353:10): [True: 0, False: 52.5k] ------------------ 354| 0| raise_logic_error(); 355| 52.5k| typedef ::boost::regex_traits_wrapper traits_type; 356| 52.5k| typedef typename BOOST_REGEX_DETAIL_NS::compute_functor_type, OutputIterator, traits_type>::type F; 357| 52.5k| F func(fmt); 358| 52.5k| return func(*this, out, flags, re.get_traits()); 359| 52.5k| } _ZNK5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEE25named_subexpression_indexEPKcSB_: 237| 75.0k| { 238| | // 239| | // Scan for the leftmost *matched* subexpression with the specified named. 240| | // If none found then return the leftmost expression with that name, 241| | // otherwise an invalid index: 242| | // 243| 75.0k| if(m_is_singular) ------------------ | Branch (243:10): [True: 0, False: 75.0k] ------------------ 244| 0| raise_logic_error(); 245| 75.0k| BOOST_REGEX_DETAIL_NS::named_subexpressions::range_type s, r; ------------------ | | 158| 75.0k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 75.0k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 75.0k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 75.0k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 246| 75.0k| s = r = m_named_subs->equal_range(i, j); 247| 75.0k| while((r.first != r.second) && ((*this)[r.first->index].matched == false)) ------------------ | Branch (247:13): [True: 0, False: 75.0k] | Branch (247:38): [True: 0, False: 0] ------------------ 248| 0| ++r.first; 249| 75.0k| if(r.first == r.second) ------------------ | Branch (249:10): [True: 75.0k, False: 0] ------------------ 250| 75.0k| r = s; 251| 75.0k| return r.first != r.second ? r.first->index : -20; ------------------ | Branch (251:14): [True: 0, False: 75.0k] ------------------ 252| 75.0k| } _ZNK5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEE19named_subexpressionEPKcSB_: 214| 112k| { 215| | // 216| | // Scan for the leftmost *matched* subexpression with the specified named: 217| | // 218| 112k| if(m_is_singular) ------------------ | Branch (218:10): [True: 0, False: 112k] ------------------ 219| 0| raise_logic_error(); 220| 112k| BOOST_REGEX_DETAIL_NS::named_subexpressions::range_type r = m_named_subs->equal_range(i, j); ------------------ | | 158| 112k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 112k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 112k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 112k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 221| 112k| while((r.first != r.second) && ((*this)[r.first->index].matched == false)) ------------------ | Branch (221:13): [True: 0, False: 112k] | Branch (221:38): [True: 0, False: 0] ------------------ 222| 0| ++r.first; 223| 112k| return r.first != r.second ? (*this)[r.first->index] : m_null; ------------------ | Branch (223:14): [True: 0, False: 112k] ------------------ 224| 112k| } _ZNK5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEE21get_last_closed_parenEv: 379| 100k| { 380| 100k| if(m_is_singular) ------------------ | Branch (380:10): [True: 0, False: 100k] ------------------ 381| 0| raise_logic_error(); 382| 100k| return m_last_closed_paren == 0 ? m_null : (*this)[m_last_closed_paren]; ------------------ | Branch (382:14): [True: 0, False: 100k] ------------------ 383| 100k| } _ZNK5boost13match_resultsINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEEixEi: 200| 2.95M| { 201| 2.95M| if(m_is_singular && m_subs.empty()) ------------------ | Branch (201:10): [True: 1.69k, False: 2.95M] | Branch (201:27): [True: 0, False: 1.69k] ------------------ 202| 0| raise_logic_error(); 203| 2.95M| sub += 2; 204| 2.95M| if(sub < (int)m_subs.size() && (sub >= 0)) ------------------ | Branch (204:10): [True: 2.47M, False: 486k] | Branch (204:38): [True: 2.47M, False: 0] ------------------ 205| 2.47M| { 206| 2.47M| return m_subs[sub]; 207| 2.47M| } 208| 486k| return m_null; 209| 2.95M| } _ZN5boost13re_detail_50013get_mem_blockEv: 159| 54.2k|{ 160| 54.2k| return mem_block_cache::instance().get(); 161| 54.2k|} _ZN5boost13re_detail_50015mem_block_cache8instanceEv: 71| 108k| { 72| 108k| static mem_block_cache block_cache = { { {nullptr} } }; 73| 108k| return block_cache; 74| 108k| } _ZN5boost13re_detail_50015mem_block_cacheD2Ev: 44| 1| { 45| 17| for (size_t i = 0;i < BOOST_REGEX_MAX_CACHE_BLOCKS; ++i) { ------------------ | | 441| 17|# define BOOST_REGEX_MAX_CACHE_BLOCKS 16 ------------------ | Branch (45:24): [True: 16, False: 1] ------------------ 46| 16| if (cache[i].load()) ::operator delete(cache[i].load()); ------------------ | Branch (46:12): [True: 1, False: 15] ------------------ 47| 16| } 48| 1| } _ZN5boost13re_detail_50015mem_block_cache3getEv: 50| 54.2k| { 51| 54.2k| for (size_t i = 0;i < BOOST_REGEX_MAX_CACHE_BLOCKS; ++i) { ------------------ | | 441| 54.2k|# define BOOST_REGEX_MAX_CACHE_BLOCKS 16 ------------------ | Branch (51:24): [True: 54.2k, False: 1] ------------------ 52| 54.2k| void* p = cache[i].load(); 53| 54.2k| if (p != NULL) { ------------------ | Branch (53:12): [True: 54.2k, False: 16] ------------------ 54| 54.2k| if (cache[i].compare_exchange_strong(p, NULL)) return p; ------------------ | Branch (54:14): [True: 54.2k, False: 0] ------------------ 55| 54.2k| } 56| 54.2k| } 57| 1| return ::operator new(BOOST_REGEX_BLOCKSIZE); ------------------ | | 429| 1|# define BOOST_REGEX_BLOCKSIZE 4096 ------------------ 58| 54.2k| } _ZN5boost13re_detail_50013put_mem_blockEPv: 164| 54.2k|{ 165| 54.2k| mem_block_cache::instance().put(p); 166| 54.2k|} _ZN5boost13re_detail_50015mem_block_cache3putEPv: 60| 54.2k| { 61| 54.2k| for (size_t i = 0;i < BOOST_REGEX_MAX_CACHE_BLOCKS; ++i) { ------------------ | | 441| 54.2k|# define BOOST_REGEX_MAX_CACHE_BLOCKS 16 ------------------ | Branch (61:24): [True: 54.2k, False: 0] ------------------ 62| 54.2k| void* p = cache[i].load(); 63| 54.2k| if (p == NULL) { ------------------ | Branch (63:12): [True: 54.2k, False: 0] ------------------ 64| 54.2k| if (cache[i].compare_exchange_strong(p, ptr)) return; ------------------ | Branch (64:14): [True: 54.2k, False: 0] ------------------ 65| 54.2k| } 66| 54.2k| } 67| 0| ::operator delete(ptr); 68| 0| } _ZN5boost12object_cacheINS_13re_detail_50021cpp_regex_traits_baseIcEENS1_31cpp_regex_traits_implementationIcEEE3getERKS3_m: 66| 2|{ 67| 2|#ifdef BOOST_HAS_THREADS 68| 2| static std::mutex mut; 69| 2| std::lock_guard l(mut); 70| 2| return do_get(k, l_max_cache_size); 71| |#else 72| | return do_get(k, l_max_cache_size); 73| |#endif 74| 2|} _ZN5boost12object_cacheINS_13re_detail_50021cpp_regex_traits_baseIcEENS1_31cpp_regex_traits_implementationIcEEE6do_getERKS3_m: 81| 2|{ 82| 2| typedef typename object_cache::data object_data; 83| 2| typedef typename map_type::size_type map_size_type; 84| 2| static object_data s_data; 85| | 86| | // 87| | // see if the object is already in the cache: 88| | // 89| 2| map_iterator mpos = s_data.index.find(k); 90| 2| if(mpos != s_data.index.end()) ------------------ | Branch (90:7): [True: 1, False: 1] ------------------ 91| 1| { 92| | // 93| | // Eureka! 94| | // We have a cached item, bump it up the list and return it: 95| | // 96| 1| if(--(s_data.cont.end()) != mpos->second) ------------------ | Branch (96:10): [True: 0, False: 1] ------------------ 97| 0| { 98| | // splice out the item we want to move: 99| 0| list_type temp; 100| 0| temp.splice(temp.end(), s_data.cont, mpos->second); 101| | // and now place it at the end of the list: 102| 0| s_data.cont.splice(s_data.cont.end(), temp, temp.begin()); 103| 0| BOOST_REGEX_ASSERT(*(s_data.cont.back().second) == k); ------------------ | | 58| 0|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 0|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 104| | // update index with new position: 105| 0| mpos->second = --(s_data.cont.end()); 106| 0| BOOST_REGEX_ASSERT(&(mpos->first) == mpos->second->second); ------------------ | | 58| 0|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 0|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 107| 0| BOOST_REGEX_ASSERT(&(mpos->first) == s_data.cont.back().second); ------------------ | | 58| 0|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 0|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 108| 0| } 109| 1| return s_data.cont.back().first; 110| 1| } 111| | // 112| | // if we get here then the item is not in the cache, 113| | // so create it: 114| | // 115| 1| std::shared_ptr result(new Object(k)); 116| | // 117| | // Add it to the list, and index it: 118| | // 119| 1| s_data.cont.push_back(value_type(result, static_cast(0))); 120| 1| s_data.index.insert(std::make_pair(k, --(s_data.cont.end()))); 121| 1| s_data.cont.back().second = &(s_data.index.find(k)->first); 122| 1| map_size_type s = s_data.index.size(); 123| 1| BOOST_REGEX_ASSERT(s_data.index[k]->first.get() == result.get()); ------------------ | | 58| 1|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 1|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 124| 1| BOOST_REGEX_ASSERT(&(s_data.index.find(k)->first) == s_data.cont.back().second); ------------------ | | 58| 1|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 1|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 125| 1| BOOST_REGEX_ASSERT(s_data.index.find(k)->first == k); ------------------ | | 58| 1|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 1|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 126| 1| if(s > l_max_cache_size) ------------------ | Branch (126:7): [True: 0, False: 1] ------------------ 127| 0| { 128| | // 129| | // We have too many items in the list, so we need to start 130| | // popping them off the back of the list, but only if they're 131| | // being held uniquely by us: 132| | // 133| 0| list_iterator pos = s_data.cont.begin(); 134| 0| list_iterator last = s_data.cont.end(); 135| 0| while((pos != last) && (s > l_max_cache_size)) ------------------ | Branch (135:13): [True: 0, False: 0] | Branch (135:30): [True: 0, False: 0] ------------------ 136| 0| { 137| 0| if(pos->first.use_count() == 1) ------------------ | Branch (137:13): [True: 0, False: 0] ------------------ 138| 0| { 139| 0| list_iterator condemmed(pos); 140| 0| ++pos; 141| | // now remove the items from our containers, 142| | // then order has to be as follows: 143| 0| BOOST_REGEX_ASSERT(s_data.index.find(*(condemmed->second)) != s_data.index.end()); ------------------ | | 58| 0|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 0|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 144| 0| s_data.index.erase(*(condemmed->second)); 145| 0| s_data.cont.erase(condemmed); 146| 0| --s; 147| 0| } 148| 0| else 149| 0| ++pos; 150| 0| } 151| 0| BOOST_REGEX_ASSERT(s_data.index[k]->first.get() == result.get()); ------------------ | | 58| 0|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 0|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 152| 0| BOOST_REGEX_ASSERT(&(s_data.index.find(k)->first) == s_data.cont.back().second); ------------------ | | 58| 0|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 0|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 153| 0| BOOST_REGEX_ASSERT(s_data.index.find(k)->first == k); ------------------ | | 58| 0|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 0|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 154| 0| } 155| 1| return result; 156| 1|} _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEC2ES5_S5_RNS_13match_resultsIS5_S9_EERKNS_11basic_regexIcSD_EENS_15regex_constants12_match_flagsES5_: 362| 54.2k| : m_result(what), base(first), last(end), 363| 54.2k| position(first), backstop(l_base), re(e), traits_inst(e.get_traits()), 364| 54.2k| m_independent(false), next_count(&rep_obj), rep_obj(&next_count) 365| 54.2k| , m_recursions(0) 366| 54.2k| { 367| 54.2k| construct_init(e, f); 368| 54.2k| } _ZN5boost13re_detail_50014repeater_countINSt3__111__wrap_iterIPcEEEC2EPPS6_: 257| 54.2k| repeater_count(repeater_count** s) : stack(s), next(0), state_id(-1), count(0), start_pos() {} _ZN5boost13re_detail_50014repeater_countINSt3__111__wrap_iterIPcEEED2Ev: 282| 54.2k| { 283| 54.2k| if(next) ------------------ | Branch (283:10): [True: 0, False: 54.2k] ------------------ 284| 0| *stack = next; 285| 54.2k| } _ZN5boost13re_detail_5009can_startEcPKhh: 61| 1.53M|{ 62| 1.53M| return map[(unsigned char)c] & mask; 63| 1.53M|} _ZN5boost13re_detail_50014verify_optionsEjNS_15regex_constants12_match_flagsE: 38| 54.2k|{ 39| | // 40| | // can't mix match_extra with POSIX matching rules: 41| | // 42| 54.2k| if ((mf & match_extra) && (mf & match_posix)) ------------------ | Branch (42:8): [True: 0, False: 54.2k] | Branch (42:30): [True: 0, False: 0] ------------------ 43| 0| { 44| 0| std::logic_error msg("Usage Error: Can't mix regular expression captures with POSIX matching rules"); 45| 0|#ifndef BOOST_REGEX_STANDALONE 46| 0| throw_exception(msg); 47| |#else 48| | throw msg; 49| |#endif 50| 0| } 51| 54.2k|} _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE14construct_initERKNS_11basic_regexIcSD_EENS_15regex_constants12_match_flagsE: 40| 54.2k|{ 41| 54.2k| typedef typename std::iterator_traits::iterator_category category; 42| 54.2k| typedef typename basic_regex::flag_type expression_flag_type; 43| | 44| 54.2k| if(e.empty()) ------------------ | Branch (44:7): [True: 0, False: 54.2k] ------------------ 45| 0| { 46| | // precondition failure: e is not a valid regex. 47| 0| std::invalid_argument ex("Invalid regular expression object"); 48| 0|#ifndef BOOST_REGEX_STANDALONE 49| 0| boost::throw_exception(ex); 50| |#else 51| | throw e; 52| |#endif 53| 0| } 54| 54.2k| pstate = 0; 55| 54.2k| m_match_flags = f; 56| 54.2k| estimate_max_state_count(static_cast(0)); 57| 54.2k| expression_flag_type re_f = re.flags(); 58| 54.2k| icase = re_f & regex_constants::icase; 59| 54.2k| if(!(m_match_flags & (match_perl|match_posix))) ------------------ | Branch (59:7): [True: 54.2k, False: 0] ------------------ 60| 54.2k| { 61| 54.2k| if((re_f & (regbase::main_option_type|regbase::no_perl_ex)) == 0) ------------------ | Branch (61:10): [True: 54.2k, False: 0] ------------------ 62| 54.2k| m_match_flags |= match_perl; 63| 0| else if((re_f & (regbase::main_option_type|regbase::emacs_ex)) == (regbase::basic_syntax_group|regbase::emacs_ex)) ------------------ | Branch (63:15): [True: 0, False: 0] ------------------ 64| 0| m_match_flags |= match_perl; 65| 0| else if((re_f & (regbase::main_option_type|regbase::literal)) == (regbase::literal)) ------------------ | Branch (65:15): [True: 0, False: 0] ------------------ 66| 0| m_match_flags |= match_perl; 67| 0| else 68| 0| m_match_flags |= match_posix; 69| 54.2k| } 70| 54.2k| if(m_match_flags & match_posix) ------------------ | Branch (70:7): [True: 0, False: 54.2k] ------------------ 71| 0| { 72| 0| m_temp_match.reset(new match_results()); 73| 0| m_presult = m_temp_match.get(); 74| 0| } 75| 54.2k| else 76| 54.2k| m_presult = &m_result; 77| 54.2k| m_stack_base = 0; 78| 54.2k| m_backup_state = 0; 79| | // find the value to use for matching word boundaries: 80| 54.2k| m_word_mask = re.get_data().m_word_mask; 81| | // find bitmask to use for matching '.': 82| 54.2k| match_any_mask = static_cast((f & match_not_dot_newline) ? BOOST_REGEX_DETAIL_NS::test_not_newline : BOOST_REGEX_DETAIL_NS::test_newline); ------------------ | | 158| 0|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 0|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 0|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 0|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ match_any_mask = static_cast((f & match_not_dot_newline) ? BOOST_REGEX_DETAIL_NS::test_not_newline : BOOST_REGEX_DETAIL_NS::test_newline); ------------------ | | 158| 54.2k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 54.2k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 54.2k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 54.2k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (82:48): [True: 0, False: 54.2k] ------------------ 83| | // Disable match_any if requested in the state machine: 84| 54.2k| if(e.get_data().m_disable_match_any) ------------------ | Branch (84:7): [True: 0, False: 54.2k] ------------------ 85| 0| m_match_flags &= regex_constants::match_not_any; 86| 54.2k|} _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE24estimate_max_state_countEPNS2_26random_access_iterator_tagE: 93| 54.2k|{ 94| | // 95| | // How many states should we allow our machine to visit before giving up? 96| | // This is a heuristic: it takes the greater of O(N^2) and O(NS^2) 97| | // where N is the length of the string, and S is the number of states 98| | // in the machine. It's tempting to up this to O(N^2S) or even O(N^2S^2) 99| | // but these take unreasonably amounts of time to bale out in pathological 100| | // cases. 101| | // 102| | // Calculate NS^2 first: 103| | // 104| 54.2k| static const std::ptrdiff_t k = 100000; 105| 54.2k| std::ptrdiff_t dist = std::distance(base, last); 106| 54.2k| if(dist == 0) ------------------ | Branch (106:7): [True: 0, False: 54.2k] ------------------ 107| 0| dist = 1; 108| 54.2k| std::ptrdiff_t states = re.size(); 109| 54.2k| if(states == 0) ------------------ | Branch (109:7): [True: 0, False: 54.2k] ------------------ 110| 0| states = 1; 111| 54.2k| if ((std::numeric_limits::max)() / states < states) ------------------ | Branch (111:8): [True: 0, False: 54.2k] ------------------ 112| 0| { 113| 0| max_state_count = (std::min)((std::ptrdiff_t)BOOST_REGEX_MAX_STATE_COUNT, (std::numeric_limits::max)() - 2); ------------------ | | 343| 0|# define BOOST_REGEX_MAX_STATE_COUNT 100000000 ------------------ 114| 0| return; 115| 0| } 116| 54.2k| states *= states; 117| 54.2k| if((std::numeric_limits::max)() / dist < states) ------------------ | Branch (117:7): [True: 0, False: 54.2k] ------------------ 118| 0| { 119| 0| max_state_count = (std::min)((std::ptrdiff_t)BOOST_REGEX_MAX_STATE_COUNT, (std::numeric_limits::max)() - 2); ------------------ | | 343| 0|# define BOOST_REGEX_MAX_STATE_COUNT 100000000 ------------------ 120| 0| return; 121| 0| } 122| 54.2k| states *= dist; 123| 54.2k| if((std::numeric_limits::max)() - k < states) ------------------ | Branch (123:7): [True: 0, False: 54.2k] ------------------ 124| 0| { 125| 0| max_state_count = (std::min)((std::ptrdiff_t)BOOST_REGEX_MAX_STATE_COUNT, (std::numeric_limits::max)() - 2); ------------------ | | 343| 0|# define BOOST_REGEX_MAX_STATE_COUNT 100000000 ------------------ 126| 0| return; 127| 0| } 128| 54.2k| states += k; 129| | 130| 54.2k| max_state_count = states; 131| | 132| | // 133| | // Now calculate N^2: 134| | // 135| 54.2k| states = dist; 136| 54.2k| if((std::numeric_limits::max)() / dist < states) ------------------ | Branch (136:7): [True: 0, False: 54.2k] ------------------ 137| 0| { 138| 0| max_state_count = (std::min)((std::ptrdiff_t)BOOST_REGEX_MAX_STATE_COUNT, (std::numeric_limits::max)() - 2); ------------------ | | 343| 0|# define BOOST_REGEX_MAX_STATE_COUNT 100000000 ------------------ 139| 0| return; 140| 0| } 141| 54.2k| states *= dist; 142| 54.2k| if((std::numeric_limits::max)() - k < states) ------------------ | Branch (142:7): [True: 0, False: 54.2k] ------------------ 143| 0| { 144| 0| max_state_count = (std::min)((std::ptrdiff_t)BOOST_REGEX_MAX_STATE_COUNT, (std::numeric_limits::max)() - 2); ------------------ | | 343| 0|# define BOOST_REGEX_MAX_STATE_COUNT 100000000 ------------------ 145| 0| return; 146| 0| } 147| 54.2k| states += k; 148| | // 149| | // N^2 can be a very large number indeed, to prevent things getting out 150| | // of control, cap the max states: 151| | // 152| 54.2k| if(states > BOOST_REGEX_MAX_STATE_COUNT) ------------------ | | 343| 54.2k|# define BOOST_REGEX_MAX_STATE_COUNT 100000000 ------------------ | Branch (152:7): [True: 0, False: 54.2k] ------------------ 153| 0| states = BOOST_REGEX_MAX_STATE_COUNT; ------------------ | | 343| 0|# define BOOST_REGEX_MAX_STATE_COUNT 100000000 ------------------ 154| | // 155| | // If (the possibly capped) N^2 is larger than our first estimate, 156| | // use this instead: 157| | // 158| 54.2k| if(states > max_state_count) ------------------ | Branch (158:7): [True: 35.6k, False: 18.6k] ------------------ 159| 35.6k| max_state_count = states; 160| 54.2k|} _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE4findEv: 215| 54.2k|{ 216| 54.2k| return find_imp(); 217| 54.2k|} _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE8find_impEv: 221| 54.2k|{ 222| 54.2k| static matcher_proc_type const s_find_vtable[7] = 223| 54.2k| { 224| 54.2k| &perl_matcher::find_restart_any, 225| 54.2k| &perl_matcher::find_restart_word, 226| 54.2k| &perl_matcher::find_restart_line, 227| 54.2k| &perl_matcher::find_restart_buf, 228| 54.2k| &perl_matcher::match_prefix, 229| 54.2k| &perl_matcher::find_restart_lit, 230| 54.2k| &perl_matcher::find_restart_lit, 231| 54.2k| }; 232| | 233| | // initialise our stack if we are non-recursive: 234| 54.2k| save_state_init init(&m_stack_base, &m_backup_state); 235| 54.2k| used_block_count = BOOST_REGEX_MAX_BLOCKS; ------------------ | | 435| 54.2k|# define BOOST_REGEX_MAX_BLOCKS 1024 ------------------ 236| 54.2k|#if !defined(BOOST_NO_EXCEPTIONS) 237| 54.2k| try{ 238| 54.2k|#endif 239| | 240| 54.2k| state_count = 0; 241| 54.2k| if((m_match_flags & regex_constants::match_init) == 0) ------------------ | Branch (241:7): [True: 54.2k, False: 0] ------------------ 242| 54.2k| { 243| | // reset our state machine: 244| 54.2k| search_base = position = base; 245| 54.2k| pstate = re.get_first_state(); 246| 54.2k| m_presult->set_size((m_match_flags & match_nosubs) ? 1u : static_cast(1u + re.mark_count()), base, last); ------------------ | Branch (246:27): [True: 0, False: 54.2k] ------------------ 247| 54.2k| m_presult->set_base(base); 248| 54.2k| m_presult->set_named_subs(this->re.get_named_subs()); 249| 54.2k| m_match_flags |= regex_constants::match_init; 250| 54.2k| } 251| 0| else 252| 0| { 253| | // start again: 254| 0| search_base = position = m_result[0].second; 255| | // If last match was null and match_not_null was not set then increment 256| | // our start position, otherwise we go into an infinite loop: 257| 0| if(((m_match_flags & match_not_null) == 0) && (m_result.length() == 0)) ------------------ | Branch (257:10): [True: 0, False: 0] | Branch (257:53): [True: 0, False: 0] ------------------ 258| 0| { 259| 0| if(position == last) ------------------ | Branch (259:13): [True: 0, False: 0] ------------------ 260| 0| return false; 261| 0| else 262| 0| ++position; 263| 0| } 264| | // reset $` start: 265| 0| m_presult->set_size((m_match_flags & match_nosubs) ? 1u : static_cast(1u + re.mark_count()), search_base, last); ------------------ | Branch (265:27): [True: 0, False: 0] ------------------ 266| | //if((base != search_base) && (base == backstop)) 267| | // m_match_flags |= match_prev_avail; 268| 0| } 269| 54.2k| if(m_match_flags & match_posix) ------------------ | Branch (269:7): [True: 0, False: 54.2k] ------------------ 270| 0| { 271| 0| m_result.set_size(static_cast(1u + re.mark_count()), base, last); 272| 0| m_result.set_base(base); 273| 0| } 274| | 275| 54.2k| verify_options(re.flags(), m_match_flags); 276| | // find out what kind of expression we have: 277| 54.2k| unsigned type = (m_match_flags & match_continuous) ? ------------------ | Branch (277:20): [True: 0, False: 54.2k] ------------------ 278| 0| static_cast(regbase::restart_continue) 279| 54.2k| : static_cast(re.get_restart_type()); 280| | 281| | // call the appropriate search routine: 282| 54.2k| matcher_proc_type proc = s_find_vtable[type]; 283| 54.2k| return (this->*proc)(); 284| | 285| 54.2k|#if !defined(BOOST_NO_EXCEPTIONS) 286| 54.2k| } 287| 54.2k| catch(...) 288| 54.2k| { 289| | // unwind all pushed states, apart from anything else this 290| | // ensures that all the states are correctly destructed 291| | // not just the memory freed. 292| 0| while(unwind(true)){} ------------------ | Branch (292:13): [True: 0, False: 0] ------------------ 293| 0| throw; 294| 0| } 295| 54.2k|#endif 296| 54.2k|} _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE16find_restart_anyEv: 798| 54.2k|{ 799| |#ifdef BOOST_REGEX_MSVC 800| |#pragma warning(push) 801| |#pragma warning(disable:4127) 802| |#endif 803| 54.2k| const unsigned char* _map = re.get_map(); 804| 54.2k| while(true) ------------------ | Branch (804:10): [Folded - Ignored] ------------------ 805| 54.2k| { 806| | // skip everything we can't match: 807| 1.40M| while((position != last) && !can_start(*position, _map, (unsigned char)mask_any) ) ------------------ | Branch (807:13): [True: 1.40M, False: 1.69k] | Branch (807:35): [True: 1.35M, False: 52.5k] ------------------ 808| 1.35M| ++position; 809| 54.2k| if(position == last) ------------------ | Branch (809:10): [True: 1.69k, False: 52.5k] ------------------ 810| 1.69k| { 811| | // run out of characters, try a null match if possible: 812| 1.69k| if(re.can_be_null()) ------------------ | Branch (812:13): [True: 0, False: 1.69k] ------------------ 813| 0| return match_prefix(); 814| 1.69k| break; 815| 1.69k| } 816| | // now try and obtain a match: 817| 52.5k| if(match_prefix()) ------------------ | Branch (817:10): [True: 52.5k, False: 0] ------------------ 818| 52.5k| return true; 819| 0| if(position == last) ------------------ | Branch (819:10): [True: 0, False: 0] ------------------ 820| 0| return false; 821| 0| ++position; 822| 0| } 823| 1.69k| return false; 824| |#ifdef BOOST_REGEX_MSVC 825| |#pragma warning(pop) 826| |#endif 827| 54.2k|} _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE12match_prefixEv: 300| 52.5k|{ 301| 52.5k| m_has_partial_match = false; 302| 52.5k| m_has_found_match = false; 303| 52.5k| pstate = re.get_first_state(); 304| 52.5k| m_presult->set_first(position); 305| 52.5k| restart = position; 306| 52.5k| match_all_states(); 307| 52.5k| if(!m_has_found_match && m_has_partial_match && (m_match_flags & match_partial)) ------------------ | Branch (307:7): [True: 0, False: 52.5k] | Branch (307:29): [True: 0, False: 0] | Branch (307:52): [True: 0, False: 0] ------------------ 308| 0| { 309| 0| m_has_found_match = true; 310| 0| m_presult->set_second(last, 0, false); 311| 0| position = last; 312| 0| if((m_match_flags & match_posix) == match_posix) ------------------ | Branch (312:10): [True: 0, False: 0] ------------------ 313| 0| { 314| 0| m_result.maybe_assign(*m_presult); 315| 0| } 316| 0| } 317| |#ifdef BOOST_REGEX_MATCH_EXTRA 318| | if(m_has_found_match && (match_extra & m_match_flags)) 319| | { 320| | // 321| | // we have a match, reverse the capture information: 322| | // 323| | for(unsigned i = 0; i < m_presult->size(); ++i) 324| | { 325| | typename sub_match::capture_sequence_type & seq = ((*m_presult)[i]).get_captures(); 326| | std::reverse(seq.begin(), seq.end()); 327| | } 328| | } 329| |#endif 330| 52.5k| if(!m_has_found_match) ------------------ | Branch (330:7): [True: 0, False: 52.5k] ------------------ 331| 0| position = restart; // reset search postion 332| 52.5k| return m_has_found_match; 333| 52.5k|} _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE13match_literalEv: 337| 52.5k|{ 338| 52.5k| unsigned int len = static_cast(pstate)->length; 339| 52.5k| const char_type* what = reinterpret_cast(static_cast(pstate) + 1); 340| | // 341| | // compare string with what we stored in 342| | // our records: 343| 105k| for(unsigned int i = 0; i < len; ++i, ++position) ------------------ | Branch (343:28): [True: 52.5k, False: 52.5k] ------------------ 344| 52.5k| { 345| 52.5k| if((position == last) || (traits_inst.translate(*position, icase) != what[i])) ------------------ | Branch (345:10): [True: 0, False: 52.5k] | Branch (345:32): [True: 0, False: 52.5k] ------------------ 346| 0| return false; 347| 52.5k| } 348| 52.5k| pstate = pstate->next.p; 349| 52.5k| return true; 350| 52.5k|} _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE10match_jumpEv: 643| 52.5k|{ 644| 52.5k| pstate = static_cast(pstate)->alt.p; 645| 52.5k| return true; 646| 52.5k|} _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE16match_all_statesEv: 150| 52.5k|{ 151| 52.5k| static matcher_proc_type const s_match_vtable[34] = 152| 52.5k| { 153| 52.5k| (&perl_matcher::match_startmark), 154| 52.5k| &perl_matcher::match_endmark, 155| 52.5k| &perl_matcher::match_literal, 156| 52.5k| &perl_matcher::match_start_line, 157| 52.5k| &perl_matcher::match_end_line, 158| 52.5k| &perl_matcher::match_wild, 159| 52.5k| &perl_matcher::match_match, 160| 52.5k| &perl_matcher::match_word_boundary, 161| 52.5k| &perl_matcher::match_within_word, 162| 52.5k| &perl_matcher::match_word_start, 163| 52.5k| &perl_matcher::match_word_end, 164| 52.5k| &perl_matcher::match_buffer_start, 165| 52.5k| &perl_matcher::match_buffer_end, 166| 52.5k| &perl_matcher::match_backref, 167| 52.5k| &perl_matcher::match_long_set, 168| 52.5k| &perl_matcher::match_set, 169| 52.5k| &perl_matcher::match_jump, 170| 52.5k| &perl_matcher::match_alt, 171| 52.5k| &perl_matcher::match_rep, 172| 52.5k| &perl_matcher::match_combining, 173| 52.5k| &perl_matcher::match_soft_buffer_end, 174| 52.5k| &perl_matcher::match_restart_continue, 175| | // Although this next line *should* be evaluated at compile time, in practice 176| | // some compilers (VC++) emit run-time initialisation which breaks thread 177| | // safety, so use a dispatch function instead: 178| | //(::boost::is_random_access_iterator::value ? &perl_matcher::match_dot_repeat_fast : &perl_matcher::match_dot_repeat_slow), 179| 52.5k| &perl_matcher::match_dot_repeat_dispatch, 180| 52.5k| &perl_matcher::match_char_repeat, 181| 52.5k| &perl_matcher::match_set_repeat, 182| 52.5k| &perl_matcher::match_long_set_repeat, 183| 52.5k| &perl_matcher::match_backstep, 184| 52.5k| &perl_matcher::match_assert_backref, 185| 52.5k| &perl_matcher::match_toggle_case, 186| 52.5k| &perl_matcher::match_recursion, 187| 52.5k| &perl_matcher::match_fail, 188| 52.5k| &perl_matcher::match_accept, 189| 52.5k| &perl_matcher::match_commit, 190| 52.5k| &perl_matcher::match_then, 191| 52.5k| }; 192| 52.5k| incrementer inc(&m_recursions); 193| 52.5k| if(inc > 80) ------------------ | Branch (193:7): [True: 0, False: 52.5k] ------------------ 194| 0| raise_error(traits_inst, regex_constants::error_complexity); 195| 52.5k| push_recursion_stopper(); 196| 52.5k| do{ 197| 422k| while(pstate) ------------------ | Branch (197:13): [True: 369k, False: 52.5k] ------------------ 198| 369k| { 199| 369k| matcher_proc_type proc = s_match_vtable[pstate->type]; 200| 369k| ++state_count; 201| 369k| if(!(this->*proc)()) ------------------ | Branch (201:13): [True: 0, False: 369k] ------------------ 202| 0| { 203| 0| if(state_count > max_state_count) ------------------ | Branch (203:16): [True: 0, False: 0] ------------------ 204| 0| raise_error(traits_inst, regex_constants::error_complexity); 205| 0| if((m_match_flags & match_partial) && (position == last) && (position != search_base)) ------------------ | Branch (205:16): [True: 0, False: 0] | Branch (205:51): [True: 0, False: 0] | Branch (205:73): [True: 0, False: 0] ------------------ 206| 0| m_has_partial_match = true; 207| 0| bool successful_unwind = unwind(false); 208| 0| if((m_match_flags & match_partial) && (position == last) && (position != search_base)) ------------------ | Branch (208:16): [True: 0, False: 0] | Branch (208:51): [True: 0, False: 0] | Branch (208:73): [True: 0, False: 0] ------------------ 209| 0| m_has_partial_match = true; 210| 0| if(!successful_unwind) ------------------ | Branch (210:16): [True: 0, False: 0] ------------------ 211| 0| return m_recursive_result; 212| 0| } 213| 369k| } 214| 52.5k| }while(unwind(true)); ------------------ | Branch (214:11): [True: 0, False: 52.5k] ------------------ 215| 52.5k| return m_recursive_result; 216| 52.5k|} _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE15match_startmarkEv: 387| 94.9k|{ 388| 94.9k| int index = static_cast(pstate)->index; 389| 94.9k| icase = static_cast(pstate)->icase; 390| 94.9k| switch(index) 391| 94.9k| { 392| 42.4k| case 0: ------------------ | Branch (392:4): [True: 42.4k, False: 52.5k] ------------------ 393| 42.4k| pstate = pstate->next.p; 394| 42.4k| break; 395| 0| case -1: ------------------ | Branch (395:4): [True: 0, False: 94.9k] ------------------ 396| 0| case -2: ------------------ | Branch (396:4): [True: 0, False: 94.9k] ------------------ 397| 0| { 398| | // forward lookahead assert: 399| 0| const re_syntax_base* next_pstate = static_cast(pstate->next.p)->alt.p->next.p; 400| 0| pstate = pstate->next.p->next.p; 401| 0| push_assertion(next_pstate, index == -1); 402| 0| break; 403| 0| } 404| 0| case -3: ------------------ | Branch (404:4): [True: 0, False: 94.9k] ------------------ 405| 0| { 406| | // independent sub-expression, currently this is always recursive: 407| 0| bool old_independent = m_independent; 408| 0| m_independent = true; 409| 0| const re_syntax_base* next_pstate = static_cast(pstate->next.p)->alt.p->next.p; 410| 0| pstate = pstate->next.p->next.p; 411| 0| bool r = false; 412| 0|#if !defined(BOOST_NO_EXCEPTIONS) 413| 0| try{ 414| 0|#endif 415| 0| r = match_all_states(); 416| 0| if(!r && !m_independent) ------------------ | Branch (416:13): [True: 0, False: 0] | Branch (416:19): [True: 0, False: 0] ------------------ 417| 0| { 418| | // Must be unwinding from a COMMIT/SKIP/PRUNE and the independent 419| | // sub failed, need to unwind everything else: 420| 0| while (m_backup_state->state_id) ------------------ | Branch (420:20): [True: 0, False: 0] ------------------ 421| 0| unwind(false); 422| 0| return false; 423| 0| } 424| 0|#if !defined(BOOST_NO_EXCEPTIONS) 425| 0| } 426| 0| catch(...) 427| 0| { 428| 0| pstate = next_pstate; 429| | // unwind all pushed states, apart from anything else this 430| | // ensures that all the states are correctly destructed 431| | // not just the memory freed. 432| 0| while(unwind(true)) {} ------------------ | Branch (432:16): [True: 0, False: 0] ------------------ 433| 0| throw; 434| 0| } 435| 0|#endif 436| 0| pstate = next_pstate; 437| 0| m_independent = old_independent; 438| |#ifdef BOOST_REGEX_MATCH_EXTRA 439| | if(r && (m_match_flags & match_extra)) 440| | { 441| | // 442| | // our captures have been stored in *m_presult 443| | // we need to unpack them, and insert them 444| | // back in the right order when we unwind the stack: 445| | // 446| | match_results temp_match(*m_presult); 447| | unsigned i; 448| | for(i = 0; i < temp_match.size(); ++i) 449| | (*m_presult)[i].get_captures().clear(); 450| | // match everything else: 451| |#if !defined(BOOST_NO_EXCEPTIONS) 452| | try{ 453| |#endif 454| | r = match_all_states(); 455| |#if !defined(BOOST_NO_EXCEPTIONS) 456| | } 457| | catch(...) 458| | { 459| | pstate = next_pstate; 460| | // unwind all pushed states, apart from anything else this 461| | // ensures that all the states are correctly destructed 462| | // not just the memory freed. 463| | while(unwind(true)) {} 464| | throw; 465| | } 466| |#endif 467| | // now place the stored captures back: 468| | for(i = 0; i < temp_match.size(); ++i) 469| | { 470| | typedef typename sub_match::capture_sequence_type seq; 471| | seq& s1 = (*m_presult)[i].get_captures(); 472| | const seq& s2 = temp_match[i].captures(); 473| | s1.insert( 474| | s1.end(), 475| | s2.begin(), 476| | s2.end()); 477| | } 478| | } 479| |#endif 480| 0| return r; 481| 0| } 482| 0| case -4: ------------------ | Branch (482:4): [True: 0, False: 94.9k] ------------------ 483| 0| { 484| | // conditional expression: 485| 0| const re_alt* alt = static_cast(pstate->next.p); 486| 0| BOOST_REGEX_ASSERT(alt->type == syntax_element_alt); ------------------ | | 58| 0|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 0|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 487| 0| pstate = alt->next.p; 488| 0| if(pstate->type == syntax_element_assert_backref) ------------------ | Branch (488:10): [True: 0, False: 0] ------------------ 489| 0| { 490| 0| if(!match_assert_backref()) ------------------ | Branch (490:13): [True: 0, False: 0] ------------------ 491| 0| pstate = alt->alt.p; 492| 0| break; 493| 0| } 494| 0| else 495| 0| { 496| | // zero width assertion, have to match this recursively: 497| 0| BOOST_REGEX_ASSERT(pstate->type == syntax_element_startmark); ------------------ | | 58| 0|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 0|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 498| 0| bool negated = static_cast(pstate)->index == -2; 499| 0| BidiIterator saved_position = position; 500| 0| const re_syntax_base* next_pstate = static_cast(pstate->next.p)->alt.p->next.p; 501| 0| pstate = pstate->next.p->next.p; 502| 0|#if !defined(BOOST_NO_EXCEPTIONS) 503| 0| try{ 504| 0|#endif 505| 0| bool r = match_all_states(); 506| 0| position = saved_position; 507| 0| if(negated) ------------------ | Branch (507:16): [True: 0, False: 0] ------------------ 508| 0| r = !r; 509| 0| if(r) ------------------ | Branch (509:16): [True: 0, False: 0] ------------------ 510| 0| pstate = next_pstate; 511| 0| else 512| 0| pstate = alt->alt.p; 513| 0|#if !defined(BOOST_NO_EXCEPTIONS) 514| 0| } 515| 0| catch(...) 516| 0| { 517| 0| pstate = next_pstate; 518| | // unwind all pushed states, apart from anything else this 519| | // ensures that all the states are correctly destructed 520| | // not just the memory freed. 521| 0| while(unwind(true)){} ------------------ | Branch (521:19): [True: 0, False: 0] ------------------ 522| 0| throw; 523| 0| } 524| 0|#endif 525| 0| break; 526| 0| } 527| 0| } 528| 0| case -5: ------------------ | Branch (528:4): [True: 0, False: 94.9k] ------------------ 529| 0| { 530| 0| push_matched_paren(0, (*m_presult)[0]); 531| 0| m_presult->set_first(position, 0, true); 532| 0| pstate = pstate->next.p; 533| 0| break; 534| 0| } 535| 52.5k| default: ------------------ | Branch (535:4): [True: 52.5k, False: 42.4k] ------------------ 536| 52.5k| { 537| 52.5k| BOOST_REGEX_ASSERT(index > 0); ------------------ | | 58| 52.5k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 52.5k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 538| 52.5k| if((m_match_flags & match_nosubs) == 0) ------------------ | Branch (538:10): [True: 52.5k, False: 0] ------------------ 539| 52.5k| { 540| 52.5k| push_matched_paren(index, (*m_presult)[index]); 541| 52.5k| m_presult->set_first(position, index); 542| 52.5k| } 543| 52.5k| pstate = pstate->next.p; 544| 52.5k| break; 545| 52.5k| } 546| 94.9k| } 547| 94.9k| return true; 548| 94.9k|} _ZN5boost13re_detail_50011saved_stateC2Ej: 52| 159k| saved_state(unsigned i) : state_id(i) {} _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE18push_matched_parenEiRKS8_: 240| 52.5k|{ 241| | //BOOST_REGEX_ASSERT(index); 242| 52.5k| saved_matched_paren* pmp = static_cast*>(m_backup_state); 243| 52.5k| --pmp; 244| 52.5k| if(pmp < m_stack_base) ------------------ | Branch (244:7): [True: 0, False: 52.5k] ------------------ 245| 0| { 246| 0| extend_stack(); 247| 0| pmp = static_cast*>(m_backup_state); 248| 0| --pmp; 249| 0| } 250| 52.5k| (void) new (pmp)saved_matched_paren(index, sub); 251| 52.5k| m_backup_state = pmp; 252| 52.5k|} _ZN5boost13re_detail_50019saved_matched_parenINSt3__111__wrap_iterIPcEEEC2EiRKNS_9sub_matchIS5_EE: 60| 52.5k| saved_matched_paren(int i, const sub_match& s) : saved_state(1), index(i), sub(s){} _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE13match_endmarkEv: 1045| 52.5k|{ 1046| 52.5k| int index = static_cast(pstate)->index; 1047| 52.5k| icase = static_cast(pstate)->icase; 1048| 52.5k| if(index > 0) ------------------ | Branch (1048:7): [True: 52.5k, False: 0] ------------------ 1049| 52.5k| { 1050| 52.5k| if((m_match_flags & match_nosubs) == 0) ------------------ | Branch (1050:10): [True: 52.5k, False: 0] ------------------ 1051| 52.5k| { 1052| 52.5k| m_presult->set_second(position, index); 1053| 52.5k| } 1054| 52.5k| if(!recursion_stack.empty()) ------------------ | Branch (1054:10): [True: 0, False: 52.5k] ------------------ 1055| 0| { 1056| 0| if(index == recursion_stack.back().idx) ------------------ | Branch (1056:13): [True: 0, False: 0] ------------------ 1057| 0| { 1058| 0| pstate = recursion_stack.back().preturn_address; 1059| 0| *m_presult = recursion_stack.back().results; 1060| 0| push_recursion(recursion_stack.back().idx, recursion_stack.back().preturn_address, m_presult, &recursion_stack.back().results); 1061| 0| recursion_stack.pop_back(); 1062| 0| push_repeater_count(-(2 + index), &next_count); 1063| 0| } 1064| 0| } 1065| 52.5k| } 1066| 0| else if((index < 0) && (index != -4)) ------------------ | Branch (1066:12): [True: 0, False: 0] | Branch (1066:27): [True: 0, False: 0] ------------------ 1067| 0| { 1068| | // matched forward lookahead: 1069| 0| pstate = 0; 1070| 0| return true; 1071| 0| } 1072| 52.5k| pstate = pstate->next.p; 1073| 52.5k| return true; 1074| 52.5k|} _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE11match_matchEv: 1078| 52.5k|{ 1079| 52.5k| if(!recursion_stack.empty()) ------------------ | Branch (1079:7): [True: 0, False: 52.5k] ------------------ 1080| 0| { 1081| 0| BOOST_REGEX_ASSERT(0 == recursion_stack.back().idx); ------------------ | | 58| 0|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 0|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 1082| 0| pstate = recursion_stack.back().preturn_address; 1083| 0| push_recursion(recursion_stack.back().idx, recursion_stack.back().preturn_address, m_presult, &recursion_stack.back().results); 1084| 0| *m_presult = recursion_stack.back().results; 1085| 0| recursion_stack.pop_back(); 1086| 0| return true; 1087| 0| } 1088| 52.5k| if((m_match_flags & match_not_null) && (position == (*m_presult)[0].first)) ------------------ | Branch (1088:7): [True: 0, False: 52.5k] | Branch (1088:43): [True: 0, False: 0] ------------------ 1089| 0| return false; 1090| 52.5k| if((m_match_flags & match_all) && (position != last)) ------------------ | Branch (1090:7): [True: 0, False: 52.5k] | Branch (1090:38): [True: 0, False: 0] ------------------ 1091| 0| return false; 1092| 52.5k| if((m_match_flags & regex_constants::match_not_initial_null) && (position == search_base)) ------------------ | Branch (1092:7): [True: 0, False: 52.5k] | Branch (1092:68): [True: 0, False: 0] ------------------ 1093| 0| return false; 1094| 52.5k| m_presult->set_second(position); 1095| 52.5k| pstate = 0; 1096| 52.5k| m_has_found_match = true; 1097| 52.5k| if((m_match_flags & match_posix) == match_posix) ------------------ | Branch (1097:7): [True: 0, False: 52.5k] ------------------ 1098| 0| { 1099| 0| m_result.maybe_assign(*m_presult); 1100| 0| if((m_match_flags & match_any) == 0) ------------------ | Branch (1100:10): [True: 0, False: 0] ------------------ 1101| 0| return false; 1102| 0| } 1103| |#ifdef BOOST_REGEX_MATCH_EXTRA 1104| | if(match_extra & m_match_flags) 1105| | { 1106| | for(unsigned i = 0; i < m_presult->size(); ++i) 1107| | if((*m_presult)[i].matched) 1108| | ((*m_presult)[i]).get_captures().push_back((*m_presult)[i]); 1109| | } 1110| |#endif 1111| 52.5k| return true; 1112| 52.5k|} _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE9match_altEv: 552| 64.4k|{ 553| 64.4k| bool take_first, take_second; 554| 64.4k| const re_alt* jmp = static_cast(pstate); 555| | 556| | // find out which of these two alternatives we need to take: 557| 64.4k| if(position == last) ------------------ | Branch (557:7): [True: 0, False: 64.4k] ------------------ 558| 0| { 559| 0| take_first = jmp->can_be_null & mask_take; 560| 0| take_second = jmp->can_be_null & mask_skip; 561| 0| } 562| 64.4k| else 563| 64.4k| { 564| 64.4k| take_first = can_start(*position, jmp->_map, (unsigned char)mask_take); 565| 64.4k| take_second = can_start(*position, jmp->_map, (unsigned char)mask_skip); 566| 64.4k| } 567| | 568| 64.4k| if(take_first) ------------------ | Branch (568:7): [True: 52.5k, False: 11.8k] ------------------ 569| 52.5k| { 570| | // we can take the first alternative, 571| | // see if we need to push next alternative: 572| 52.5k| if(take_second) ------------------ | Branch (572:10): [True: 0, False: 52.5k] ------------------ 573| 0| { 574| 0| push_alt(jmp->alt.p); 575| 0| } 576| 52.5k| pstate = pstate->next.p; 577| 52.5k| return true; 578| 52.5k| } 579| 11.8k| if(take_second) ------------------ | Branch (579:7): [True: 11.8k, False: 0] ------------------ 580| 11.8k| { 581| 11.8k| pstate = jmp->alt.p; 582| 11.8k| return true; 583| 11.8k| } 584| 0| return false; // neither option is possible 585| 11.8k|} _ZN5boost13re_detail_50011incrementerC2EPj: 141| 52.5k| incrementer(unsigned* pu) : m_pu(pu) { ++*m_pu; } _ZN5boost13re_detail_50011incrementergtEj: 143| 52.5k| bool operator > (unsigned i) { return *m_pu > i; } _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE22push_recursion_stopperEv: 272| 52.5k|{ 273| 52.5k| saved_state* pmp = m_backup_state; 274| 52.5k| --pmp; 275| 52.5k| if(pmp < m_stack_base) ------------------ | Branch (275:7): [True: 0, False: 52.5k] ------------------ 276| 0| { 277| 0| extend_stack(); 278| 0| pmp = m_backup_state; 279| 0| --pmp; 280| 0| } 281| 52.5k| (void) new (pmp)saved_state(saved_type_recurse); 282| 52.5k| m_backup_state = pmp; 283| 52.5k|} _ZN5boost13re_detail_50011incrementerD2Ev: 142| 52.5k| ~incrementer() { --*m_pu; } _ZN5boost13re_detail_50015save_state_initC2EPPNS0_11saved_stateES4_: 98| 54.2k| : stack(base) 99| 54.2k| { 100| 54.2k| *base = static_cast(get_mem_block()); 101| 54.2k| *end = reinterpret_cast(reinterpret_cast(*base)+BOOST_REGEX_BLOCKSIZE); ------------------ | | 429| 54.2k|# define BOOST_REGEX_BLOCKSIZE 4096 ------------------ 102| 54.2k| --(*end); 103| 54.2k| (void) new (*end)saved_state(0); 104| 54.2k| BOOST_REGEX_ASSERT(*end > *base); ------------------ | | 58| 54.2k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 54.2k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 105| 54.2k| } _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE6unwindEb: 1225| 52.5k|{ 1226| 52.5k| static unwind_proc_type const s_unwind_table[19] = 1227| 52.5k| { 1228| 52.5k| &perl_matcher::unwind_end, 1229| 52.5k| &perl_matcher::unwind_paren, 1230| 52.5k| &perl_matcher::unwind_recursion_stopper, 1231| 52.5k| &perl_matcher::unwind_assertion, 1232| 52.5k| &perl_matcher::unwind_alt, 1233| 52.5k| &perl_matcher::unwind_repeater_counter, 1234| 52.5k| &perl_matcher::unwind_extra_block, 1235| 52.5k| &perl_matcher::unwind_greedy_single_repeat, 1236| 52.5k| &perl_matcher::unwind_slow_dot_repeat, 1237| 52.5k| &perl_matcher::unwind_fast_dot_repeat, 1238| 52.5k| &perl_matcher::unwind_char_repeat, 1239| 52.5k| &perl_matcher::unwind_short_set_repeat, 1240| 52.5k| &perl_matcher::unwind_long_set_repeat, 1241| 52.5k| &perl_matcher::unwind_non_greedy_repeat, 1242| 52.5k| &perl_matcher::unwind_recursion, 1243| 52.5k| &perl_matcher::unwind_recursion_pop, 1244| 52.5k| &perl_matcher::unwind_commit, 1245| 52.5k| &perl_matcher::unwind_then, 1246| 52.5k| &perl_matcher::unwind_case, 1247| 52.5k| }; 1248| | 1249| 52.5k| m_recursive_result = have_match; 1250| 52.5k| m_unwound_lookahead = false; 1251| 52.5k| m_unwound_alt = false; 1252| 52.5k| unwind_proc_type unwinder; 1253| 52.5k| bool cont; 1254| | // 1255| | // keep unwinding our stack until we have something to do: 1256| | // 1257| 52.5k| do 1258| 105k| { 1259| 105k| unwinder = s_unwind_table[m_backup_state->state_id]; 1260| 105k| cont = (this->*unwinder)(m_recursive_result); 1261| 105k| }while(cont); ------------------ | Branch (1261:11): [True: 52.5k, False: 52.5k] ------------------ 1262| | // 1263| | // return true if we have more states to try: 1264| | // 1265| 52.5k| return pstate ? true : false; ------------------ | Branch (1265:11): [True: 0, False: 52.5k] ------------------ 1266| 52.5k|} _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE12unwind_parenEb: 1287| 52.5k|{ 1288| 52.5k| saved_matched_paren* pmp = static_cast*>(m_backup_state); 1289| | // restore previous values if no match was found: 1290| 52.5k| if(!have_match) ------------------ | Branch (1290:7): [True: 0, False: 52.5k] ------------------ 1291| 0| { 1292| 0| m_presult->set_first(pmp->sub.first, pmp->index, pmp->index == 0); 1293| 0| m_presult->set_second(pmp->sub.second, pmp->index, pmp->sub.matched, pmp->index == 0); 1294| 0| } 1295| |#ifdef BOOST_REGEX_MATCH_EXTRA 1296| | // 1297| | // we have a match, push the capture information onto the stack: 1298| | // 1299| | else if(pmp->sub.matched && (match_extra & m_match_flags)) 1300| | ((*m_presult)[pmp->index]).get_captures().push_back(pmp->sub); 1301| |#endif 1302| | // unwind stack: 1303| 52.5k| m_backup_state = pmp+1; 1304| 52.5k| boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp); 1305| 52.5k| return true; // keep looking 1306| 52.5k|} _ZN5boost13re_detail_50015inplace_destroyINS0_19saved_matched_parenINSt3__111__wrap_iterIPcEEEEEEvPT_: 38| 52.5k|{ 39| 52.5k| (void)p; // warning suppression 40| 52.5k| p->~T(); 41| 52.5k|} _ZN5boost13re_detail_50012perl_matcherINSt3__111__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS5_EEEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE24unwind_recursion_stopperEb: 1310| 52.5k|{ 1311| 52.5k| boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(m_backup_state++); 1312| 52.5k| pstate = 0; // nothing left to search 1313| 52.5k| return false; // end of stack nothing more to search 1314| 52.5k|} _ZN5boost13re_detail_50015inplace_destroyINS0_11saved_stateEEEvPT_: 38| 52.5k|{ 39| 52.5k| (void)p; // warning suppression 40| 52.5k| p->~T(); 41| 52.5k|} _ZN5boost13re_detail_50015save_state_initD2Ev: 107| 54.2k| { 108| 54.2k| put_mem_block(*stack); 109| 54.2k| *stack = 0; 110| 54.2k| } _ZN5boost13re_detail_50016find_sort_syntaxINS0_31cpp_regex_traits_implementationIcEEcEEjPKT_PT0_: 54| 1|{ 55| | // 56| | // compare 'a' with 'A' to see how similar they are, 57| | // should really use a-accute but we can't portably do that, 58| | // 59| 1| typedef typename traits::string_type string_type; 60| 1| typedef typename traits::char_type char_type; 61| | 62| | // Suppress incorrect warning for MSVC 63| 1| (void)pt; 64| | 65| 1| char_type a[2] = {'a', '\0', }; 66| 1| string_type sa(pt->transform(a, a+1)); 67| 1| if(sa == a) ------------------ | Branch (67:7): [True: 0, False: 1] ------------------ 68| 0| { 69| 0| *delim = 0; 70| 0| return sort_C; 71| 0| } 72| 1| char_type A[2] = { 'A', '\0', }; 73| 1| string_type sA(pt->transform(A, A+1)); 74| 1| char_type c[2] = { ';', '\0', }; 75| 1| string_type sc(pt->transform(c, c+1)); 76| | 77| 1| int pos = 0; 78| 1| while((pos <= static_cast(sa.size())) && (pos <= static_cast(sA.size())) && (sa[pos] == sA[pos])) ++pos; ------------------ | Branch (78:10): [True: 1, False: 0] | Branch (78:50): [True: 1, False: 0] | Branch (78:90): [True: 0, False: 1] ------------------ 79| 1| --pos; 80| 1| if(pos < 0) ------------------ | Branch (80:7): [True: 1, False: 0] ------------------ 81| 1| { 82| 1| *delim = 0; 83| 1| return sort_unknown; 84| 1| } 85| | // 86| | // at this point sa[pos] is either the end of a fixed width field 87| | // or the character that acts as a delimiter: 88| | // 89| 0| charT maybe_delim = sa[pos]; 90| 0| if((pos != 0) && (count_chars(sa, maybe_delim) == count_chars(sA, maybe_delim)) && (count_chars(sa, maybe_delim) == count_chars(sc, maybe_delim))) ------------------ | Branch (90:7): [True: 0, False: 0] | Branch (90:21): [True: 0, False: 0] | Branch (90:87): [True: 0, False: 0] ------------------ 91| 0| { 92| 0| *delim = maybe_delim; 93| 0| return sort_delim; 94| 0| } 95| | // 96| | // OK doen't look like a delimiter, try for fixed width field: 97| | // 98| 0| if((sa.size() == sA.size()) && (sa.size() == sc.size())) ------------------ | Branch (98:7): [True: 0, False: 0] | Branch (98:35): [True: 0, False: 0] ------------------ 99| 0| { 100| | // note assumes that the fixed width field is less than 101| | // (numeric_limits::max)(), should be true for all types 102| | // I can't imagine 127 character fields... 103| 0| *delim = static_cast(++pos); 104| 0| return sort_fixed; 105| 0| } 106| | // 107| | // don't know what it is: 108| | // 109| 0| *delim = 0; 110| 0| return sort_unknown; 111| 0|} _ZN5boost13re_detail_50024format_functor_containerINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS6_INS_9sub_matchISC_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEEEC2ERKS8_: 1061| 52.5k| format_functor_container(const Container& c) : func(c) {} _ZN5boost13re_detail_50024format_functor_containerINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS6_INS_9sub_matchISC_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEEEclINS2_16ostream_iteratorIccS5_EEEET_RKSG_SR_NS_15regex_constants12_match_flagsERKSM_: 1065| 52.5k| { 1066| | //typedef typename Match::char_type char_type; 1067| 52.5k| return BOOST_REGEX_DETAIL_NS::regex_format_imp(i, m, func.begin(), func.end(), f, t); ------------------ | | 158| 52.5k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 52.5k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 52.5k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 52.5k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1068| 52.5k| } _ZN5boost13re_detail_50016regex_format_impINSt3__116ostream_iteratorIccNS2_11char_traitsIcEEEENS2_11__wrap_iterIPcEENS2_9allocatorINS_9sub_matchIS9_EEEENS7_IPKcEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEEEET_SN_RKNS_13match_resultsIT0_T1_EET2_SU_NS_15regex_constants12_match_flagsERKT3_: 814| 52.5k|{ 815| 52.5k| if(flags & regex_constants::format_literal) ------------------ | Branch (815:7): [True: 0, False: 52.5k] ------------------ 816| 0| { 817| 0| return BOOST_REGEX_DETAIL_NS::copy(p1, p2, out); ------------------ | | 158| 0|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 0|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 0|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 0|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 818| 0| } 819| | 820| 52.5k| BOOST_REGEX_DETAIL_NS::basic_regex_formatter< ------------------ | | 158| 52.5k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 52.5k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 52.5k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 52.5k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 821| 52.5k| OutputIterator, 822| 52.5k| match_results, 823| 52.5k| traits, ForwardIter> f(out, m, t); 824| 52.5k| return f.format(p1, p2, flags); 825| 52.5k|} _ZN5boost13re_detail_50021basic_regex_formatterINSt3__116ostream_iteratorIccNS2_11char_traitsIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS2_9allocatorINS_9sub_matchISA_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEENS8_IPKcEEEC2ES6_RKSF_RKSL_: 80| 52.5k| : m_traits(t), m_results(r), m_out(o), m_position(), m_end(), m_flags(), m_state(output_copy), m_restore_state(output_copy), m_have_conditional(false) {} _ZN5boost13re_detail_50021basic_regex_formatterINSt3__116ostream_iteratorIccNS2_11char_traitsIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS2_9allocatorINS_9sub_matchISA_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEENS8_IPKcEEE6formatESO_SO_NS_15regex_constants12_match_flagsE: 193| 52.5k|{ 194| 52.5k| m_position = p1; 195| 52.5k| m_end = p2; 196| 52.5k| m_flags = f; 197| 52.5k| format_all(); 198| 52.5k| return m_out; 199| 52.5k|} _ZN5boost13re_detail_50021basic_regex_formatterINSt3__116ostream_iteratorIccNS2_11char_traitsIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS2_9allocatorINS_9sub_matchISA_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEENS8_IPKcEEE10format_allEv: 203| 15.1M|{ 204| | // over and over: 205| 384M| while(m_position != m_end) ------------------ | Branch (205:10): [True: 383M, False: 1.10M] ------------------ 206| 383M| { 207| 383M| switch(*m_position) 208| 383M| { 209| 624k| case '&': ------------------ | Branch (209:7): [True: 624k, False: 382M] ------------------ 210| 624k| if(m_flags & ::boost::regex_constants::format_sed) ------------------ | Branch (210:13): [True: 0, False: 624k] ------------------ 211| 0| { 212| 0| ++m_position; 213| 0| put(m_results[0]); 214| 0| break; 215| 0| } 216| 624k| put(*m_position++); 217| 624k| break; 218| 4.88M| case '\\': ------------------ | Branch (218:7): [True: 4.88M, False: 378M] ------------------ 219| 4.88M| format_escape(); 220| 4.88M| break; 221| 13.8M| case '(': ------------------ | Branch (221:7): [True: 13.8M, False: 369M] ------------------ 222| 13.8M| if(m_flags & boost::regex_constants::format_all) ------------------ | Branch (222:13): [True: 13.8M, False: 0] ------------------ 223| 13.8M| { 224| 13.8M| ++m_position; 225| 13.8M| bool have_conditional = m_have_conditional; 226| 13.8M| m_have_conditional = false; 227| 13.8M| format_until_scope_end(); 228| 13.8M| m_have_conditional = have_conditional; 229| 13.8M| if(m_position == m_end) ------------------ | Branch (229:16): [True: 13.7M, False: 104k] ------------------ 230| 13.7M| return; 231| 104k| BOOST_REGEX_ASSERT(*m_position == static_cast(')')); ------------------ | | 58| 104k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 104k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 232| 104k| ++m_position; // skip the closing ')' 233| 104k| break; 234| 104k| } 235| 0| put(*m_position); 236| 0| ++m_position; 237| 0| break; 238| 147k| case ')': ------------------ | Branch (238:7): [True: 147k, False: 383M] ------------------ 239| 147k| if(m_flags & boost::regex_constants::format_all) ------------------ | Branch (239:13): [True: 147k, False: 0] ------------------ 240| 147k| { 241| 147k| return; 242| 147k| } 243| 0| put(*m_position); 244| 0| ++m_position; 245| 0| break; 246| 1.00M| case ':': ------------------ | Branch (246:7): [True: 1.00M, False: 382M] ------------------ 247| 1.00M| if((m_flags & boost::regex_constants::format_all) && m_have_conditional) ------------------ | Branch (247:13): [True: 1.00M, False: 0] | Branch (247:63): [True: 75.7k, False: 926k] ------------------ 248| 75.7k| { 249| 75.7k| return; 250| 75.7k| } 251| 926k| put(*m_position); 252| 926k| ++m_position; 253| 926k| break; 254| 1.75M| case '?': ------------------ | Branch (254:7): [True: 1.75M, False: 381M] ------------------ 255| 1.75M| if(m_flags & boost::regex_constants::format_all) ------------------ | Branch (255:13): [True: 1.75M, False: 0] ------------------ 256| 1.75M| { 257| 1.75M| ++m_position; 258| 1.75M| format_conditional(); 259| 1.75M| break; 260| 1.75M| } 261| 0| put(*m_position); 262| 0| ++m_position; 263| 0| break; 264| 2.93M| case '$': ------------------ | Branch (264:7): [True: 2.93M, False: 380M] ------------------ 265| 2.93M| if((m_flags & format_sed) == 0) ------------------ | Branch (265:13): [True: 2.93M, False: 0] ------------------ 266| 2.93M| { 267| 2.93M| format_perl(); 268| 2.93M| break; 269| 2.93M| } 270| | // not a special character: 271| 0| BOOST_REGEX_FALLTHROUGH; ------------------ | | 127| 0|# define BOOST_REGEX_FALLTHROUGH BOOST_FALLTHROUGH | | ------------------ | | | | 125| 0|# define BOOST_FALLTHROUGH [[clang::fallthrough]] | | ------------------ ------------------ 272| 358M| default: ------------------ | Branch (272:7): [True: 358M, False: 25.2M] ------------------ 273| 358M| put(*m_position); 274| 358M| ++m_position; 275| 358M| break; 276| 383M| } 277| 383M| } 278| 15.1M|} _ZN5boost13re_detail_50021basic_regex_formatterINSt3__116ostream_iteratorIccNS2_11char_traitsIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS2_9allocatorINS_9sub_matchISA_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEENS8_IPKcEEE3putERKSD_: 775| 1.71M|{ 776| 1.71M| typedef typename sub_match_type::iterator iterator_type; 777| 1.71M| iterator_type i = sub.first; 778| 30.1M| while(i != sub.second) ------------------ | Branch (778:10): [True: 28.4M, False: 1.71M] ------------------ 779| 28.4M| { 780| 28.4M| put(*i); 781| 28.4M| ++i; 782| 28.4M| } 783| 1.71M|} _ZN5boost13re_detail_50021basic_regex_formatterINSt3__116ostream_iteratorIccNS2_11char_traitsIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS2_9allocatorINS_9sub_matchISA_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEENS8_IPKcEEE3putEc: 745| 394M|{ 746| | // write a single character to output 747| | // according to which case translation mode we are in: 748| 394M| switch(this->m_state) 749| 394M| { 750| 94.2M| case output_none: ------------------ | Branch (750:4): [True: 94.2M, False: 300M] ------------------ 751| 94.2M| return; 752| 147k| case output_next_lower: ------------------ | Branch (752:4): [True: 147k, False: 394M] ------------------ 753| 147k| c = m_traits.tolower(c); 754| 147k| this->m_state = m_restore_state; 755| 147k| break; 756| 464k| case output_next_upper: ------------------ | Branch (756:4): [True: 464k, False: 394M] ------------------ 757| 464k| c = m_traits.toupper(c); 758| 464k| this->m_state = m_restore_state; 759| 464k| break; 760| 6.71M| case output_lower: ------------------ | Branch (760:4): [True: 6.71M, False: 387M] ------------------ 761| 6.71M| c = m_traits.tolower(c); 762| 6.71M| break; 763| 17.2M| case output_upper: ------------------ | Branch (763:4): [True: 17.2M, False: 377M] ------------------ 764| 17.2M| c = m_traits.toupper(c); 765| 17.2M| break; 766| 275M| default: ------------------ | Branch (766:4): [True: 275M, False: 118M] ------------------ 767| 275M| break; 768| 394M| } 769| 300M| *m_out = c; 770| 300M| ++m_out; 771| 300M|} _ZN5boost13re_detail_50021basic_regex_formatterINSt3__116ostream_iteratorIccNS2_11char_traitsIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS2_9allocatorINS_9sub_matchISA_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEENS8_IPKcEEE13format_escapeEv: 490| 4.88M|{ 491| | // skip the escape and check for trailing escape: 492| 4.88M| if(++m_position == m_end) ------------------ | Branch (492:7): [True: 1.30k, False: 4.88M] ------------------ 493| 1.30k| { 494| 1.30k| put(static_cast('\\')); 495| 1.30k| return; 496| 1.30k| } 497| | // now switch on the escape type: 498| 4.88M| switch(*m_position) 499| 4.88M| { 500| 76.8k| case 'a': ------------------ | Branch (500:4): [True: 76.8k, False: 4.81M] ------------------ 501| 76.8k| put(static_cast('\a')); 502| 76.8k| ++m_position; 503| 76.8k| break; 504| 2.88k| case 'f': ------------------ | Branch (504:4): [True: 2.88k, False: 4.88M] ------------------ 505| 2.88k| put(static_cast('\f')); 506| 2.88k| ++m_position; 507| 2.88k| break; 508| 152k| case 'n': ------------------ | Branch (508:4): [True: 152k, False: 4.73M] ------------------ 509| 152k| put(static_cast('\n')); 510| 152k| ++m_position; 511| 152k| break; 512| 64.3k| case 'r': ------------------ | Branch (512:4): [True: 64.3k, False: 4.82M] ------------------ 513| 64.3k| put(static_cast('\r')); 514| 64.3k| ++m_position; 515| 64.3k| break; 516| 424k| case 't': ------------------ | Branch (516:4): [True: 424k, False: 4.46M] ------------------ 517| 424k| put(static_cast('\t')); 518| 424k| ++m_position; 519| 424k| break; 520| 21.9k| case 'v': ------------------ | Branch (520:4): [True: 21.9k, False: 4.86M] ------------------ 521| 21.9k| put(static_cast('\v')); 522| 21.9k| ++m_position; 523| 21.9k| break; 524| 2.33M| case 'x': ------------------ | Branch (524:4): [True: 2.33M, False: 2.55M] ------------------ 525| 2.33M| if(++m_position == m_end) ------------------ | Branch (525:10): [True: 248, False: 2.33M] ------------------ 526| 248| { 527| 248| put(static_cast('x')); 528| 248| return; 529| 248| } 530| | // maybe have \x{ddd} 531| 2.33M| if(*m_position == static_cast('{')) ------------------ | Branch (531:10): [True: 203k, False: 2.13M] ------------------ 532| 203k| { 533| 203k| ++m_position; 534| 203k| int val = this->toi(m_position, m_end, 16); 535| 203k| if(val < 0) ------------------ | Branch (535:13): [True: 102k, False: 101k] ------------------ 536| 102k| { 537| | // invalid value treat everything as literals: 538| 102k| put(static_cast('x')); 539| 102k| put(static_cast('{')); 540| 102k| return; 541| 102k| } 542| 101k| if((m_position == m_end) || (*m_position != static_cast('}'))) ------------------ | Branch (542:13): [True: 620, False: 100k] | Branch (542:38): [True: 32.0k, False: 68.3k] ------------------ 543| 32.7k| { 544| 32.7k| --m_position; 545| 162k| while(*m_position != static_cast('\\')) ------------------ | Branch (545:19): [True: 129k, False: 32.7k] ------------------ 546| 129k| --m_position; 547| 32.7k| ++m_position; 548| 32.7k| put(*m_position++); 549| 32.7k| return; 550| 32.7k| } 551| 68.3k| ++m_position; 552| 68.3k| put(static_cast(val)); 553| 68.3k| return; 554| 101k| } 555| 2.13M| else 556| 2.13M| { 557| 2.13M| std::ptrdiff_t len = std::distance(m_position, m_end); 558| 2.13M| len = (std::min)(static_cast(2), len); 559| 2.13M| int val = this->toi(m_position, m_position + len, 16); 560| 2.13M| if(val < 0) ------------------ | Branch (560:13): [True: 374k, False: 1.75M] ------------------ 561| 374k| { 562| 374k| --m_position; 563| 374k| put(*m_position++); 564| 374k| return; 565| 374k| } 566| 1.75M| put(static_cast(val)); 567| 1.75M| } 568| 1.75M| break; 569| 1.75M| case 'c': ------------------ | Branch (569:4): [True: 51.8k, False: 4.83M] ------------------ 570| 51.8k| if(++m_position == m_end) ------------------ | Branch (570:10): [True: 124, False: 51.7k] ------------------ 571| 124| { 572| 124| --m_position; 573| 124| put(*m_position++); 574| 124| return; 575| 124| } 576| 51.7k| put(static_cast(*m_position++ % 32)); 577| 51.7k| break; 578| 22.0k| case 'e': ------------------ | Branch (578:4): [True: 22.0k, False: 4.86M] ------------------ 579| 22.0k| put(static_cast(27)); 580| 22.0k| ++m_position; 581| 22.0k| break; 582| 1.73M| default: ------------------ | Branch (582:4): [True: 1.73M, False: 3.15M] ------------------ 583| | // see if we have a perl specific escape: 584| 1.73M| if((m_flags & boost::regex_constants::format_sed) == 0) ------------------ | Branch (584:10): [True: 1.73M, False: 0] ------------------ 585| 1.73M| { 586| 1.73M| bool breakout = false; 587| 1.73M| switch(*m_position) ------------------ | Branch (587:17): [True: 1.40M, False: 328k] ------------------ 588| 1.73M| { 589| 125k| case 'l': ------------------ | Branch (589:10): [True: 125k, False: 1.60M] ------------------ 590| 125k| ++m_position; 591| 125k| m_restore_state = m_state; 592| 125k| m_state = output_next_lower; 593| 125k| breakout = true; 594| 125k| break; 595| 21.2k| case 'L': ------------------ | Branch (595:10): [True: 21.2k, False: 1.71M] ------------------ 596| 21.2k| ++m_position; 597| 21.2k| m_state = output_lower; 598| 21.2k| breakout = true; 599| 21.2k| break; 600| 30.8k| case 'u': ------------------ | Branch (600:10): [True: 30.8k, False: 1.70M] ------------------ 601| 30.8k| ++m_position; 602| 30.8k| m_restore_state = m_state; 603| 30.8k| m_state = output_next_upper; 604| 30.8k| breakout = true; 605| 30.8k| break; 606| 118k| case 'U': ------------------ | Branch (606:10): [True: 118k, False: 1.61M] ------------------ 607| 118k| ++m_position; 608| 118k| m_state = output_upper; 609| 118k| breakout = true; 610| 118k| break; 611| 32.0k| case 'E': ------------------ | Branch (611:10): [True: 32.0k, False: 1.70M] ------------------ 612| 32.0k| ++m_position; 613| 32.0k| m_state = output_copy; 614| 32.0k| breakout = true; 615| 32.0k| break; 616| 1.73M| } 617| 1.73M| if(breakout) ------------------ | Branch (617:13): [True: 328k, False: 1.40M] ------------------ 618| 328k| break; 619| 1.73M| } 620| | // see if we have a \n sed style backreference: 621| 1.40M| std::ptrdiff_t len = std::distance(m_position, m_end); 622| 1.40M| len = (std::min)(static_cast(1), len); 623| 1.40M| int v = this->toi(m_position, m_position+len, 10); 624| 1.40M| if((v > 0) || ((v == 0) && (m_flags & ::boost::regex_constants::format_sed))) ------------------ | Branch (624:10): [True: 333k, False: 1.07M] | Branch (624:22): [True: 445k, False: 625k] | Branch (624:34): [True: 0, False: 445k] ------------------ 625| 333k| { 626| 333k| put(m_results[v]); 627| 333k| break; 628| 333k| } 629| 1.07M| else if(v == 0) ------------------ | Branch (629:15): [True: 445k, False: 625k] ------------------ 630| 445k| { 631| | // octal ecape sequence: 632| 445k| --m_position; 633| 445k| len = std::distance(m_position, m_end); 634| 445k| len = (std::min)(static_cast(4), len); 635| 445k| v = this->toi(m_position, m_position + len, 8); 636| 445k| BOOST_REGEX_ASSERT(v >= 0); ------------------ | | 58| 445k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 445k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 637| 445k| put(static_cast(v)); 638| 445k| break; 639| 445k| } 640| | // Otherwise output the character "as is": 641| 625k| put(*m_position++); 642| 625k| break; 643| 4.88M| } 644| 4.88M|} _ZN5boost13re_detail_50021basic_regex_formatterINSt3__116ostream_iteratorIccNS2_11char_traitsIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS2_9allocatorINS_9sub_matchISA_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEENS8_IPKcEEE3toiERSO_SO_i: 163| 8.22M| { 164| |#if defined(_MSC_VER) && defined(__INTEL_COMPILER) && ((__INTEL_COMPILER == 9999) || (__INTEL_COMPILER == 1210)) 165| | // Workaround for Intel support issue #656654. 166| | // See also https://svn.boost.org/trac/boost/ticket/6359 167| | return toi(i, j, base, std::integral_constant()); 168| |#else 169| 8.22M| typedef typename std::is_convertible::type tag_type; 170| 8.22M| return toi(i, j, base, tag_type()); 171| 8.22M|#endif 172| 8.22M| } _ZN5boost13re_detail_50021basic_regex_formatterINSt3__116ostream_iteratorIccNS2_11char_traitsIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS2_9allocatorINS_9sub_matchISA_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEENS8_IPKcEEE3toiERSO_SO_iRKNS2_17integral_constantIbLb0EEE: 143| 8.22M| { 144| 8.22M| if(i != j) ------------------ | Branch (144:10): [True: 8.22M, False: 930] ------------------ 145| 8.22M| { 146| 8.22M| std::vector v(i, j); 147| 8.22M| const char_type* start = &v[0]; 148| 8.22M| const char_type* pos = start; 149| 8.22M| int r = (int)m_traits.toi(pos, &v[0] + v.size(), base); 150| 8.22M| std::advance(i, pos - start); 151| 8.22M| return r; 152| 8.22M| } 153| 930| return -1; 154| 8.22M| } _ZN5boost13re_detail_50021basic_regex_formatterINSt3__116ostream_iteratorIccNS2_11char_traitsIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS2_9allocatorINS_9sub_matchISA_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEENS8_IPKcEEE22format_until_scope_endEv: 733| 13.9M|{ 734| 13.9M| do 735| 13.9M| { 736| 13.9M| format_all(); 737| 13.9M| if((m_position == m_end) || (*m_position == static_cast(')'))) ------------------ | Branch (737:10): [True: 13.8M, False: 129k] | Branch (737:35): [True: 129k, False: 0] ------------------ 738| 13.9M| return; 739| 0| put(*m_position++); 740| 0| }while(m_position != m_end); ------------------ | Branch (740:11): [True: 0, False: 0] ------------------ 741| 13.9M|} _ZN5boost13re_detail_50021basic_regex_formatterINSt3__116ostream_iteratorIccNS2_11char_traitsIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS2_9allocatorINS_9sub_matchISA_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEENS8_IPKcEEE18format_conditionalEv: 648| 1.75M|{ 649| 1.75M| if(m_position == m_end) ------------------ | Branch (649:7): [True: 2.04k, False: 1.75M] ------------------ 650| 2.04k| { 651| | // oops trailing '?': 652| 2.04k| put(static_cast('?')); 653| 2.04k| return; 654| 2.04k| } 655| 1.75M| int v; 656| 1.75M| if(*m_position == '{') ------------------ | Branch (656:7): [True: 230k, False: 1.52M] ------------------ 657| 230k| { 658| 230k| ForwardIter base = m_position; 659| 230k| ++m_position; 660| 230k| v = this->toi(m_position, m_end, 10); 661| 230k| if(v < 0) ------------------ | Branch (661:10): [True: 75.0k, False: 155k] ------------------ 662| 75.0k| { 663| | // Try a named subexpression: 664| 286M| while((m_position != m_end) && (*m_position != '}')) ------------------ | Branch (664:16): [True: 286M, False: 37.6k] | Branch (664:41): [True: 286M, False: 37.3k] ------------------ 665| 286M| ++m_position; 666| 75.0k| v = this->get_named_sub_index(base + 1, m_position); 667| 75.0k| } 668| 230k| if((v < 0) || (*m_position != '}')) ------------------ | Branch (668:10): [True: 75.0k, False: 155k] | Branch (668:21): [True: 101k, False: 54.1k] ------------------ 669| 176k| { 670| 176k| m_position = base; 671| | // oops trailing '?': 672| 176k| put(static_cast('?')); 673| 176k| return; 674| 176k| } 675| | // Skip trailing '}': 676| 54.1k| ++m_position; 677| 54.1k| } 678| 1.52M| else 679| 1.52M| { 680| 1.52M| std::ptrdiff_t len = std::distance(m_position, m_end); 681| 1.52M| len = (std::min)(static_cast(2), len); 682| 1.52M| v = this->toi(m_position, m_position + len, 10); 683| 1.52M| } 684| 1.57M| if(v < 0) ------------------ | Branch (684:7): [True: 481k, False: 1.09M] ------------------ 685| 481k| { 686| | // oops not a number: 687| 481k| put(static_cast('?')); 688| 481k| return; 689| 481k| } 690| | 691| | // output varies depending upon whether sub-expression v matched or not: 692| 1.09M| if(m_results[v].matched) ------------------ | Branch (692:7): [True: 690k, False: 403k] ------------------ 693| 690k| { 694| 690k| m_have_conditional = true; 695| 690k| format_all(); 696| 690k| m_have_conditional = false; 697| 690k| if((m_position != m_end) && (*m_position == static_cast(':'))) ------------------ | Branch (697:10): [True: 42.8k, False: 647k] | Branch (697:35): [True: 34.9k, False: 7.86k] ------------------ 698| 34.9k| { 699| | // skip the ':': 700| 34.9k| ++m_position; 701| | // save output state, then turn it off: 702| 34.9k| output_state saved_state = m_state; 703| 34.9k| m_state = output_none; 704| | // format the rest of this scope: 705| 34.9k| format_until_scope_end(); 706| | // restore output state: 707| 34.9k| m_state = saved_state; 708| 34.9k| } 709| 690k| } 710| 403k| else 711| 403k| { 712| | // save output state, then turn it off: 713| 403k| output_state saved_state = m_state; 714| 403k| m_state = output_none; 715| | // format until ':' or ')': 716| 403k| m_have_conditional = true; 717| 403k| format_all(); 718| 403k| m_have_conditional = false; 719| | // restore state: 720| 403k| m_state = saved_state; 721| 403k| if((m_position != m_end) && (*m_position == static_cast(':'))) ------------------ | Branch (721:10): [True: 48.7k, False: 354k] | Branch (721:35): [True: 40.8k, False: 7.97k] ------------------ 722| 40.8k| { 723| | // skip the ':': 724| 40.8k| ++m_position; 725| | // format the rest of this scope: 726| 40.8k| format_until_scope_end(); 727| 40.8k| } 728| 403k| } 729| 1.09M|} _ZN5boost13re_detail_50021basic_regex_formatterINSt3__116ostream_iteratorIccNS2_11char_traitsIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS2_9allocatorINS_9sub_matchISA_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEENS8_IPKcEEE19get_named_sub_indexESO_SO_: 133| 75.0k| { 134| 75.0k| typedef typename std::is_convertible::type tag_type; 135| 75.0k| return get_named_sub_index(i, j, tag_type()); 136| 75.0k| } _ZN5boost13re_detail_50021basic_regex_formatterINSt3__116ostream_iteratorIccNS2_11char_traitsIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS2_9allocatorINS_9sub_matchISA_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEENS8_IPKcEEE19get_named_sub_indexESO_SO_RKNS2_17integral_constantIbLb0EEE: 123| 75.0k| { 124| 75.0k| std::vector v(i, j); 125| 75.0k| return (i != j) ? this->m_results.named_subexpression_index(&v[0], &v[0] + v.size()) ------------------ | Branch (125:14): [True: 70.4k, False: 4.52k] ------------------ 126| 75.0k| : this->m_results.named_subexpression_index(static_cast(0), static_cast(0)); 127| 75.0k| } _ZN5boost13re_detail_50021basic_regex_formatterINSt3__116ostream_iteratorIccNS2_11char_traitsIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS2_9allocatorINS_9sub_matchISA_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEENS8_IPKcEEE11format_perlEv: 282| 2.93M|{ 283| | // 284| | // On entry *m_position points to a '$' character 285| | // output the information that goes with it: 286| | // 287| 2.93M| BOOST_REGEX_ASSERT(*m_position == '$'); ------------------ | | 58| 2.93M|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 2.93M|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 288| | // 289| | // see if this is a trailing '$': 290| | // 291| 2.93M| if(++m_position == m_end) ------------------ | Branch (291:7): [True: 2.01k, False: 2.93M] ------------------ 292| 2.01k| { 293| 2.01k| --m_position; 294| 2.01k| put(*m_position); 295| 2.01k| ++m_position; 296| 2.01k| return; 297| 2.01k| } 298| | // 299| | // OK find out what kind it is: 300| | // 301| 2.93M| bool have_brace = false; 302| 2.93M| ForwardIter save_position = m_position; 303| 2.93M| switch(*m_position) 304| 2.93M| { 305| 38.5k| case '&': ------------------ | Branch (305:4): [True: 38.5k, False: 2.89M] ------------------ 306| 38.5k| ++m_position; 307| 38.5k| put(this->m_results[0]); 308| 38.5k| break; 309| 59.7k| case '`': ------------------ | Branch (309:4): [True: 59.7k, False: 2.87M] ------------------ 310| 59.7k| ++m_position; 311| 59.7k| put(this->m_results.prefix()); 312| 59.7k| break; 313| 46.0k| case '\'': ------------------ | Branch (313:4): [True: 46.0k, False: 2.88M] ------------------ 314| 46.0k| ++m_position; 315| 46.0k| put(this->m_results.suffix()); 316| 46.0k| break; 317| 190k| case '$': ------------------ | Branch (317:4): [True: 190k, False: 2.74M] ------------------ 318| 190k| put(*m_position++); 319| 190k| break; 320| 316k| case '+': ------------------ | Branch (320:4): [True: 316k, False: 2.61M] ------------------ 321| 316k| if((++m_position != m_end) && (*m_position == '{')) ------------------ | Branch (321:10): [True: 315k, False: 961] | Branch (321:37): [True: 143k, False: 171k] ------------------ 322| 143k| { 323| 143k| ForwardIter base = ++m_position; 324| 108M| while((m_position != m_end) && (*m_position != '}')) ++m_position; ------------------ | Branch (324:16): [True: 108M, False: 31.0k] | Branch (324:41): [True: 108M, False: 112k] ------------------ 325| 143k| if(m_position != m_end) ------------------ | Branch (325:13): [True: 112k, False: 31.0k] ------------------ 326| 112k| { 327| | // Named sub-expression: 328| 112k| put(get_named_sub(base, m_position)); 329| 112k| ++m_position; 330| 112k| break; 331| 112k| } 332| 31.0k| else 333| 31.0k| { 334| 31.0k| m_position = --base; 335| 31.0k| } 336| 143k| } 337| 203k| put((this->m_results)[this->m_results.size() > 1 ? static_cast(this->m_results.size() - 1) : 1]); ------------------ | Branch (337:29): [True: 203k, False: 0] ------------------ 338| 203k| break; 339| 964k| case '{': ------------------ | Branch (339:4): [True: 964k, False: 1.96M] ------------------ 340| 964k| have_brace = true; 341| 964k| ++m_position; 342| 964k| BOOST_REGEX_FALLTHROUGH; ------------------ | | 127| 964k|# define BOOST_REGEX_FALLTHROUGH BOOST_FALLTHROUGH | | ------------------ | | | | 125| 964k|# define BOOST_FALLTHROUGH [[clang::fallthrough]] | | ------------------ ------------------ 343| 2.28M| default: ------------------ | Branch (343:4): [True: 1.31M, False: 1.61M] ------------------ 344| | // see if we have a number: 345| 2.28M| { 346| 2.28M| std::ptrdiff_t len = std::distance(m_position, m_end); 347| | //len = (std::min)(static_cast(2), len); 348| 2.28M| int v = this->toi(m_position, m_position + len, 10); 349| 2.28M| if((v < 0) || (have_brace && ((m_position == m_end) || (*m_position != '}')))) ------------------ | Branch (349:13): [True: 1.36M, False: 914k] | Branch (349:25): [True: 713k, False: 201k] | Branch (349:40): [True: 62, False: 713k] | Branch (349:65): [True: 315k, False: 397k] ------------------ 350| 1.68M| { 351| | // Look for a Perl-5.10 verb: 352| 1.68M| if(!handle_perl_verb(have_brace)) ------------------ | Branch (352:16): [True: 1.36M, False: 319k] ------------------ 353| 1.36M| { 354| | // leave the $ as is, and carry on: 355| 1.36M| m_position = --save_position; 356| 1.36M| put(*m_position); 357| 1.36M| ++m_position; 358| 1.36M| } 359| 1.68M| break; 360| 1.68M| } 361| | // otherwise output sub v: 362| 599k| put(this->m_results[v]); 363| 599k| if(have_brace) ------------------ | Branch (363:13): [True: 397k, False: 201k] ------------------ 364| 397k| ++m_position; 365| 599k| } 366| 2.93M| } 367| 2.93M|} _ZN5boost13re_detail_50021basic_regex_formatterINSt3__116ostream_iteratorIccNS2_11char_traitsIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS2_9allocatorINS_9sub_matchISA_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEENS8_IPKcEEE13get_named_subESO_SO_: 118| 112k| { 119| 112k| typedef typename std::is_convertible::type tag_type; 120| 112k| return get_named_sub(i, j, tag_type()); 121| 112k| } _ZN5boost13re_detail_50021basic_regex_formatterINSt3__116ostream_iteratorIccNS2_11char_traitsIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS2_9allocatorINS_9sub_matchISA_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEENS8_IPKcEEE13get_named_subESO_SO_RKNS2_17integral_constantIbLb0EEE: 108| 112k| { 109| 112k| std::vector v(i, j); 110| 112k| return (i != j) ? this->m_results.named_subexpression(&v[0], &v[0] + v.size()) ------------------ | Branch (110:14): [True: 32.7k, False: 79.9k] ------------------ 111| 112k| : this->m_results.named_subexpression(static_cast(0), static_cast(0)); 112| 112k| } _ZN5boost13re_detail_50021basic_regex_formatterINSt3__116ostream_iteratorIccNS2_11char_traitsIcEEEENS_13match_resultsINS2_11__wrap_iterIPcEENS2_9allocatorINS_9sub_matchISA_EEEEEENS_20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEENS8_IPKcEEE16handle_perl_verbEb: 371| 1.68M|{ 372| | // 373| | // We may have a capitalised string containing a Perl action: 374| | // 375| 1.68M| static const char_type MATCH[] = { 'M', 'A', 'T', 'C', 'H' }; 376| 1.68M| static const char_type PREMATCH[] = { 'P', 'R', 'E', 'M', 'A', 'T', 'C', 'H' }; 377| 1.68M| static const char_type POSTMATCH[] = { 'P', 'O', 'S', 'T', 'M', 'A', 'T', 'C', 'H' }; 378| 1.68M| static const char_type LAST_PAREN_MATCH[] = { 'L', 'A', 'S', 'T', '_', 'P', 'A', 'R', 'E', 'N', '_', 'M', 'A', 'T', 'C', 'H' }; 379| 1.68M| static const char_type LAST_SUBMATCH_RESULT[] = { 'L', 'A', 'S', 'T', '_', 'S', 'U', 'B', 'M', 'A', 'T', 'C', 'H', '_', 'R', 'E', 'S', 'U', 'L', 'T' }; 380| 1.68M| static const char_type LAST_SUBMATCH_RESULT_ALT[] = { '^', 'N' }; 381| | 382| 1.68M| if(m_position == m_end) ------------------ | Branch (382:7): [True: 1.64k, False: 1.68M] ------------------ 383| 1.64k| return false; 384| 1.68M| if(have_brace && (*m_position == '^')) ------------------ | Branch (384:7): [True: 566k, False: 1.11M] | Branch (384:21): [True: 105k, False: 460k] ------------------ 385| 105k| ++m_position; 386| | 387| 1.68M| std::ptrdiff_t max_len = m_end - m_position; 388| | 389| 1.68M| if((max_len >= 5) && std::equal(m_position, m_position + 5, MATCH)) ------------------ | Branch (389:7): [True: 1.67M, False: 7.16k] | Branch (389:25): [True: 33.7k, False: 1.64M] ------------------ 390| 33.7k| { 391| 33.7k| m_position += 5; 392| 33.7k| if(have_brace) ------------------ | Branch (392:10): [True: 29.8k, False: 3.90k] ------------------ 393| 29.8k| { 394| 29.8k| if((m_position != m_end) && (*m_position == '}')) ------------------ | Branch (394:13): [True: 29.8k, False: 31] | Branch (394:38): [True: 8.49k, False: 21.3k] ------------------ 395| 8.49k| ++m_position; 396| 21.3k| else 397| 21.3k| { 398| 21.3k| m_position -= 5; 399| 21.3k| return false; 400| 21.3k| } 401| 29.8k| } 402| 12.4k| put(this->m_results[0]); 403| 12.4k| return true; 404| 33.7k| } 405| 1.64M| if((max_len >= 8) && std::equal(m_position, m_position + 8, PREMATCH)) ------------------ | Branch (405:7): [True: 1.63M, False: 11.1k] | Branch (405:25): [True: 133k, False: 1.50M] ------------------ 406| 133k| { 407| 133k| m_position += 8; 408| 133k| if(have_brace) ------------------ | Branch (408:10): [True: 87.3k, False: 46.5k] ------------------ 409| 87.3k| { 410| 87.3k| if((m_position != m_end) && (*m_position == '}')) ------------------ | Branch (410:13): [True: 87.3k, False: 31] | Branch (410:38): [True: 64.6k, False: 22.6k] ------------------ 411| 64.6k| ++m_position; 412| 22.6k| else 413| 22.6k| { 414| 22.6k| m_position -= 8; 415| 22.6k| return false; 416| 22.6k| } 417| 87.3k| } 418| 111k| put(this->m_results.prefix()); 419| 111k| return true; 420| 133k| } 421| 1.51M| if((max_len >= 9) && std::equal(m_position, m_position + 9, POSTMATCH)) ------------------ | Branch (421:7): [True: 1.50M, False: 12.8k] | Branch (421:25): [True: 11.4k, False: 1.49M] ------------------ 422| 11.4k| { 423| 11.4k| m_position += 9; 424| 11.4k| if(have_brace) ------------------ | Branch (424:10): [True: 5.64k, False: 5.82k] ------------------ 425| 5.64k| { 426| 5.64k| if((m_position != m_end) && (*m_position == '}')) ------------------ | Branch (426:13): [True: 5.61k, False: 31] | Branch (426:38): [True: 3.65k, False: 1.95k] ------------------ 427| 3.65k| ++m_position; 428| 1.98k| else 429| 1.98k| { 430| 1.98k| m_position -= 9; 431| 1.98k| return false; 432| 1.98k| } 433| 5.64k| } 434| 9.48k| put(this->m_results.suffix()); 435| 9.48k| return true; 436| 11.4k| } 437| 1.50M| if((max_len >= 16) && std::equal(m_position, m_position + 16, LAST_PAREN_MATCH)) ------------------ | Branch (437:7): [True: 1.48M, False: 21.1k] | Branch (437:26): [True: 89.3k, False: 1.39M] ------------------ 438| 89.3k| { 439| 89.3k| m_position += 16; 440| 89.3k| if(have_brace) ------------------ | Branch (440:10): [True: 57.5k, False: 31.7k] ------------------ 441| 57.5k| { 442| 57.5k| if((m_position != m_end) && (*m_position == '}')) ------------------ | Branch (442:13): [True: 57.5k, False: 31] | Branch (442:38): [True: 54.0k, False: 3.56k] ------------------ 443| 54.0k| ++m_position; 444| 3.59k| else 445| 3.59k| { 446| 3.59k| m_position -= 16; 447| 3.59k| return false; 448| 3.59k| } 449| 57.5k| } 450| 85.7k| put((this->m_results)[this->m_results.size() > 1 ? static_cast(this->m_results.size() - 1) : 1]); ------------------ | Branch (450:29): [True: 85.7k, False: 0] ------------------ 451| 85.7k| return true; 452| 89.3k| } 453| 1.41M| if((max_len >= 20) && std::equal(m_position, m_position + 20, LAST_SUBMATCH_RESULT)) ------------------ | Branch (453:7): [True: 1.38M, False: 26.5k] | Branch (453:26): [True: 51.9k, False: 1.33M] ------------------ 454| 51.9k| { 455| 51.9k| m_position += 20; 456| 51.9k| if(have_brace) ------------------ | Branch (456:10): [True: 14.8k, False: 37.1k] ------------------ 457| 14.8k| { 458| 14.8k| if((m_position != m_end) && (*m_position == '}')) ------------------ | Branch (458:13): [True: 14.7k, False: 31] | Branch (458:38): [True: 1.73k, False: 13.0k] ------------------ 459| 1.73k| ++m_position; 460| 13.0k| else 461| 13.0k| { 462| 13.0k| m_position -= 20; 463| 13.0k| return false; 464| 13.0k| } 465| 14.8k| } 466| 38.8k| put(this->m_results.get_last_closed_paren()); 467| 38.8k| return true; 468| 51.9k| } 469| 1.36M| if((max_len >= 2) && std::equal(m_position, m_position + 2, LAST_SUBMATCH_RESULT_ALT)) ------------------ | Branch (469:7): [True: 1.36M, False: 1.98k] | Branch (469:25): [True: 115k, False: 1.24M] ------------------ 470| 115k| { 471| 115k| m_position += 2; 472| 115k| if(have_brace) ------------------ | Branch (472:10): [True: 74.0k, False: 41.8k] ------------------ 473| 74.0k| { 474| 74.0k| if((m_position != m_end) && (*m_position == '}')) ------------------ | Branch (474:13): [True: 74.0k, False: 31] | Branch (474:38): [True: 20.1k, False: 53.8k] ------------------ 475| 20.1k| ++m_position; 476| 53.9k| else 477| 53.9k| { 478| 53.9k| m_position -= 2; 479| 53.9k| return false; 480| 53.9k| } 481| 74.0k| } 482| 62.0k| put(this->m_results.get_last_closed_paren()); 483| 62.0k| return true; 484| 115k| } 485| 1.24M| return false; 486| 1.36M|} _ZN5boost14regex_iteratorINSt3__111__wrap_iterIPcEEcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEC2ES4_S4_RKNS_11basic_regexIcS8_EENS_15regex_constants12_match_flagsE: 96| 1.69k| : pdata(new impl(&re, b, m)) 97| 1.69k| { 98| 1.69k| if(!pdata->init(a)) ------------------ | Branch (98:10): [True: 0, False: 1.69k] ------------------ 99| 0| { 100| 0| pdata.reset(); 101| 0| } 102| 1.69k| } _ZN5boost29regex_iterator_implementationINSt3__111__wrap_iterIPcEEcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEC2EPKNS_11basic_regexIcS8_EES4_NS_15regex_constants12_match_flagsE: 41| 1.69k| : base(), end(last), re(*p), flags(f){} _ZN5boost29regex_iterator_implementationINSt3__111__wrap_iterIPcEEcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE4initES4_: 45| 1.69k| { 46| 1.69k| base = first; 47| 1.69k| return regex_search(first, end, what, re, flags); 48| 1.69k| } _ZN5boost14regex_iteratorINSt3__111__wrap_iterIPcEEcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEC2Ev: 92| 1.69k| regex_iterator(){} _ZNK5boost14regex_iteratorINSt3__111__wrap_iterIPcEEcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEeqERKS9_: 111| 55.9k| { 112| 55.9k| if((pdata.get() == 0) || (that.pdata.get() == 0)) ------------------ | Branch (112:10): [True: 1.69k, False: 54.2k] | Branch (112:32): [True: 54.2k, False: 0] ------------------ 113| 55.9k| return pdata.get() == that.pdata.get(); 114| 0| return pdata->compare(*(that.pdata.get())); 115| 55.9k| } _ZNK5boost14regex_iteratorINSt3__111__wrap_iterIPcEEcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEneERKS9_: 117| 54.2k| { return !(*this == that); } _ZNK5boost14regex_iteratorINSt3__111__wrap_iterIPcEEcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEptEv: 121| 157k| { return &(pdata->get()); } _ZN5boost29regex_iterator_implementationINSt3__111__wrap_iterIPcEEcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE3getEv: 55| 210k| { return what; } _ZNK5boost14regex_iteratorINSt3__111__wrap_iterIPcEEcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEdeEv: 119| 52.5k| { return pdata->get(); } _ZN5boost14regex_iteratorINSt3__111__wrap_iterIPcEEcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEppEv: 123| 52.5k| { 124| 52.5k| cow(); 125| 52.5k| if(0 == pdata->next()) ------------------ | Branch (125:10): [True: 1.69k, False: 50.8k] ------------------ 126| 1.69k| { 127| 1.69k| pdata.reset(); 128| 1.69k| } 129| 52.5k| return *this; 130| 52.5k| } _ZN5boost14regex_iteratorINSt3__111__wrap_iterIPcEEcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE3cowEv: 142| 52.5k| { 143| | // copy-on-write 144| 52.5k| if(pdata.get() && (pdata.use_count() > 1)) ------------------ | Branch (144:10): [True: 52.5k, False: 0] | Branch (144:25): [True: 0, False: 52.5k] ------------------ 145| 0| { 146| 0| pdata.reset(new impl(*(pdata.get()))); 147| 0| } 148| 52.5k| } _ZN5boost29regex_iterator_implementationINSt3__111__wrap_iterIPcEEcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEE4nextEv: 57| 52.5k| { 58| | //if(what.prefix().first != what[0].second) 59| | // flags |= match_prev_avail; 60| 52.5k| BidirectionalIterator next_start = what[0].second; 61| 52.5k| match_flag_type f(flags); 62| 52.5k| if(!what.length() || (f & regex_constants::match_posix)) ------------------ | Branch (62:10): [True: 0, False: 52.5k] | Branch (62:28): [True: 0, False: 52.5k] ------------------ 63| 0| f |= regex_constants::match_not_initial_null; 64| | //if(base != next_start) 65| | // f |= regex_constants::match_not_bob; 66| 52.5k| bool result = regex_search(next_start, end, what, re, f, base); 67| 52.5k| if(result) ------------------ | Branch (67:10): [True: 50.8k, False: 1.69k] ------------------ 68| 50.8k| what.set_base(base); 69| 52.5k| return result; 70| 52.5k| } _ZN5boost13re_detail_50011raw_storageC2Ev: 198| 3.39k|{ 199| 3.39k| last = start = end = 0; 200| 3.39k|} _ZN5boost13re_detail_50011raw_storageD2Ev: 111| 3.39k| { 112| 3.39k| ::operator delete(start); 113| 3.39k| } _ZN5boost13re_detail_50011raw_storage5clearEv: 180| 3.39k| { 181| 3.39k| end = start; 182| 3.39k| } _ZNK5boost13re_detail_50011raw_storage4dataEv: 170| 3.41M| { 171| 3.41M| return start; 172| 3.41M| } _ZN5boost13re_detail_50011raw_storage6insertEmm: 149| 205k| { 150| 205k| BOOST_REGEX_ASSERT(pos <= size_type(end - start)); ------------------ | | 58| 205k|# define BOOST_REGEX_ASSERT(x) BOOST_ASSERT(x) | | ------------------ | | | | 66| 205k|# define BOOST_ASSERT(expr) assert(expr) | | ------------------ ------------------ 151| 205k| if (size_type(last - end) < n) ------------------ | Branch (151:11): [True: 8.48k, False: 196k] ------------------ 152| 8.48k| resize(n + (end - start)); 153| 205k| void* result = start + pos; 154| 205k| std::memmove(start + pos + n, start + pos, (end - start) - pos); 155| 205k| end += n; 156| 205k| return result; 157| 205k| } _ZN5boost13re_detail_50011raw_storage6resizeEm: 116| 15.2k| { 117| 15.2k| size_type newsize = start ? last - start : 1024; ------------------ | Branch (117:27): [True: 11.8k, False: 3.39k] ------------------ 118| 27.1k| while (newsize < n) ------------------ | Branch (118:14): [True: 11.8k, False: 15.2k] ------------------ 119| 11.8k| newsize *= 2; 120| 15.2k| size_type datasize = end - start; 121| | // extend newsize to WORD/DWORD boundary: 122| 15.2k| newsize = (newsize + padding_mask) & ~(padding_mask); 123| | 124| | // allocate and copy data: 125| 15.2k| pointer ptr = static_cast(::operator new(newsize)); 126| 15.2k| BOOST_REGEX_NOEH_ASSERT(ptr) 127| 15.2k| if (start) ------------------ | Branch (127:14): [True: 11.8k, False: 3.39k] ------------------ 128| 11.8k| std::memcpy(ptr, start, datasize); 129| | 130| | // get rid of old buffer: 131| 15.2k| ::operator delete(start); 132| | 133| | // and set up pointers: 134| 15.2k| start = ptr; 135| 15.2k| end = ptr + datasize; 136| 15.2k| last = ptr + newsize; 137| 15.2k| } _ZN5boost13re_detail_50011raw_storage5alignEv: 185| 1.12M| { 186| | // move end up to a boundary: 187| 1.12M| end = start + (((end - start) + padding_mask) & ~padding_mask); 188| 1.12M| } _ZN5boost13re_detail_50011raw_storage4sizeEv: 160| 1.33M| { 161| 1.33M| return size_type(end - start); 162| 1.33M| } _ZN5boost13re_detail_50011raw_storage6extendEm: 140| 1.32M| { 141| 1.32M| if(size_type(last - end) < n) ------------------ | Branch (141:10): [True: 6.78k, False: 1.31M] ------------------ 142| 6.78k| resize(n + (end - start)); 143| 1.32M| pointer result = end; 144| 1.32M| end += n; 145| 1.32M| return result; 146| 1.32M| } _ZN5boost13regex_replaceINSt3__116ostream_iteratorIccNS1_11char_traitsIcEEEENS1_11__wrap_iterIPcEENS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEcNS1_12basic_stringIcS4_NS1_9allocatorIcEEEEEET_SH_T0_SI_RKNS_11basic_regexIT2_T1_EET3_NS_15regex_constants12_match_flagsE: 34| 1.69k|{ 35| 1.69k| regex_iterator i(first, last, e, flags); 36| 1.69k| regex_iterator j; 37| 1.69k| if(i == j) ------------------ | Branch (37:7): [True: 0, False: 1.69k] ------------------ 38| 0| { 39| 0| if(!(flags & regex_constants::format_no_copy)) ------------------ | Branch (39:10): [True: 0, False: 0] ------------------ 40| 0| out = BOOST_REGEX_DETAIL_NS::copy(first, last, out); ------------------ | | 158| 0|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 0|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 0|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 0|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 41| 0| } 42| 1.69k| else 43| 1.69k| { 44| 1.69k| BidirectionalIterator last_m(first); 45| 54.2k| while(i != j) ------------------ | Branch (45:13): [True: 52.5k, False: 1.69k] ------------------ 46| 52.5k| { 47| 52.5k| if(!(flags & regex_constants::format_no_copy)) ------------------ | Branch (47:13): [True: 52.5k, False: 0] ------------------ 48| 52.5k| out = BOOST_REGEX_DETAIL_NS::copy(i->prefix().first, i->prefix().second, out); ------------------ | | 158| 52.5k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 52.5k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 52.5k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 52.5k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 49| 52.5k| out = i->format(out, fmt, flags, e); 50| 52.5k| last_m = (*i)[0].second; 51| 52.5k| if(flags & regex_constants::format_first_only) ------------------ | Branch (51:13): [True: 0, False: 52.5k] ------------------ 52| 0| break; 53| 52.5k| ++i; 54| 52.5k| } 55| 1.69k| if(!(flags & regex_constants::format_no_copy)) ------------------ | Branch (55:10): [True: 1.69k, False: 0] ------------------ 56| 1.69k| out = BOOST_REGEX_DETAIL_NS::copy(last_m, last, out); ------------------ | | 158| 1.69k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 1.69k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 1.69k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 1.69k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 57| 1.69k| } 58| 1.69k| return out; 59| 1.69k|} _ZN5boost12regex_searchINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEEbT_SD_RNS_13match_resultsISD_T0_EERKNS_11basic_regexIT1_T2_EENS_15regex_constants12_match_flagsE: 30| 1.69k|{ 31| 1.69k| return regex_search(first, last, m, e, flags, first); 32| 1.69k|} _ZN5boost12regex_searchINSt3__111__wrap_iterIPcEENS1_9allocatorINS_9sub_matchIS4_EEEEcNS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEEbT_SD_RNS_13match_resultsISD_T0_EERKNS_11basic_regexIT1_T2_EENS_15regex_constants12_match_flagsESD_: 40| 54.2k|{ 41| 54.2k| if(e.flags() & regex_constants::failbit) ------------------ | Branch (41:7): [True: 0, False: 54.2k] ------------------ 42| 0| return false; 43| | 44| 54.2k| BOOST_REGEX_DETAIL_NS::perl_matcher matcher(first, last, m, e, flags, base); ------------------ | | 158| 54.2k|#define BOOST_REGEX_DETAIL_NS BOOST_REGEX_JOIN(re_detail_, BOOST_RE_VERSION) | | ------------------ | | | | 122| 54.2k|#define BOOST_REGEX_JOIN(X, Y) BOOST_REGEX_DO_JOIN(X, Y) | | | | ------------------ | | | | | | 123| 54.2k|#define BOOST_REGEX_DO_JOIN(X, Y) BOOST_REGEX_DO_JOIN2(X,Y) | | | | | | ------------------ | | | | | | | | 124| 54.2k|#define BOOST_REGEX_DO_JOIN2(X, Y) X##Y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 45| 54.2k| return matcher.find(); 46| 54.2k|} _ZN5boost20regex_traits_wrapperINS_12regex_traitsIcNS_16cpp_regex_traitsIcEEEEEC2Ev: 121| 2| regex_traits_wrapper(){} _ZN5boost12regex_traitsIcNS_16cpp_regex_traitsIcEEEC2Ev: 39| 2| regex_traits() : implementationT() {} _ZN5boost13re_detail_50018get_default_syntaxEh: 50| 59|{ 51| | // if the user hasn't supplied a message catalog, then this supplies 52| | // default "messages" for us to load in the range 1-100. 53| 59| const char* messages[] = { 54| 59| "", 55| 59| "(", 56| 59| ")", 57| 59| "$", 58| 59| "^", 59| 59| ".", 60| 59| "*", 61| 59| "+", 62| 59| "?", 63| 59| "[", 64| 59| "]", 65| 59| "|", 66| 59| "\\", 67| 59| "#", 68| 59| "-", 69| 59| "{", 70| 59| "}", 71| 59| "0123456789", 72| 59| "b", 73| 59| "B", 74| 59| "<", 75| 59| ">", 76| 59| "", 77| 59| "", 78| 59| "A`", 79| 59| "z'", 80| 59| "\n", 81| 59| ",", 82| 59| "a", 83| 59| "f", 84| 59| "n", 85| 59| "r", 86| 59| "t", 87| 59| "v", 88| 59| "x", 89| 59| "c", 90| 59| ":", 91| 59| "=", 92| 59| "e", 93| 59| "", 94| 59| "", 95| 59| "", 96| 59| "", 97| 59| "", 98| 59| "", 99| 59| "", 100| 59| "", 101| 59| "E", 102| 59| "Q", 103| 59| "X", 104| 59| "C", 105| 59| "Z", 106| 59| "G", 107| 59| "!", 108| 59| "p", 109| 59| "P", 110| 59| "N", 111| 59| "gk", 112| 59| "K", 113| 59| "R", 114| 59| }; 115| | 116| 59| return ((n >= (sizeof(messages) / sizeof(messages[1]))) ? "" : messages[n]); ------------------ | Branch (116:12): [True: 0, False: 59] ------------------ 117| 59|} _ZN5boost13re_detail_50020get_default_class_idIcEEiPKT_S4_: 767| 32.2k|{ 768| 32.2k| static const charT data[73] = { 769| 32.2k| 'a', 'l', 'n', 'u', 'm', 770| 32.2k| 'a', 'l', 'p', 'h', 'a', 771| 32.2k| 'b', 'l', 'a', 'n', 'k', 772| 32.2k| 'c', 'n', 't', 'r', 'l', 773| 32.2k| 'd', 'i', 'g', 'i', 't', 774| 32.2k| 'g', 'r', 'a', 'p', 'h', 775| 32.2k| 'l', 'o', 'w', 'e', 'r', 776| 32.2k| 'p', 'r', 'i', 'n', 't', 777| 32.2k| 'p', 'u', 'n', 'c', 't', 778| 32.2k| 's', 'p', 'a', 'c', 'e', 779| 32.2k| 'u', 'n', 'i', 'c', 'o', 'd', 'e', 780| 32.2k| 'u', 'p', 'p', 'e', 'r', 781| 32.2k| 'v', 782| 32.2k| 'w', 'o', 'r', 'd', 783| 32.2k| 'x', 'd', 'i', 'g', 'i', 't', 784| 32.2k| }; 785| | 786| 32.2k| static const character_pointer_range ranges[21] = 787| 32.2k| { 788| 32.2k| {data+0, data+5,}, // alnum 789| 32.2k| {data+5, data+10,}, // alpha 790| 32.2k| {data+10, data+15,}, // blank 791| 32.2k| {data+15, data+20,}, // cntrl 792| 32.2k| {data+20, data+21,}, // d 793| 32.2k| {data+20, data+25,}, // digit 794| 32.2k| {data+25, data+30,}, // graph 795| 32.2k| {data+29, data+30,}, // h 796| 32.2k| {data+30, data+31,}, // l 797| 32.2k| {data+30, data+35,}, // lower 798| 32.2k| {data+35, data+40,}, // print 799| 32.2k| {data+40, data+45,}, // punct 800| 32.2k| {data+45, data+46,}, // s 801| 32.2k| {data+45, data+50,}, // space 802| 32.2k| {data+57, data+58,}, // u 803| 32.2k| {data+50, data+57,}, // unicode 804| 32.2k| {data+57, data+62,}, // upper 805| 32.2k| {data+62, data+63,}, // v 806| 32.2k| {data+63, data+64,}, // w 807| 32.2k| {data+63, data+67,}, // word 808| 32.2k| {data+67, data+73,}, // xdigit 809| 32.2k| }; 810| 32.2k| const character_pointer_range* ranges_begin = ranges; 811| 32.2k| const character_pointer_range* ranges_end = ranges + (sizeof(ranges)/sizeof(ranges[0])); 812| | 813| 32.2k| character_pointer_range t = { p1, p2, }; 814| 32.2k| const character_pointer_range* p = std::lower_bound(ranges_begin, ranges_end, t); 815| 32.2k| if((p != ranges_end) && (t == *p)) ------------------ | Branch (815:7): [True: 32.2k, False: 0] | Branch (815:28): [True: 32.2k, False: 0] ------------------ 816| 32.2k| return static_cast(p - ranges); 817| 0| return -1; 818| 32.2k|} _ZNK5boost13re_detail_50023character_pointer_rangeIcEltERKS2_: 740| 142k| { 741| 142k| return std::lexicographical_compare(p1, p2, r.p1, r.p2); 742| 142k| } _ZNK5boost13re_detail_50023character_pointer_rangeIcEeqERKS2_: 744| 32.2k| { 745| | // Not only do we check that the ranges are of equal size before 746| | // calling std::equal, but there is no other algorithm available: 747| | // not even a non-standard MS one. So forward to unchecked_equal 748| | // in the MS case. 749| 32.2k|#ifdef __cpp_lib_robust_nonmodifying_seq_ops 750| 32.2k| return std::equal(p1, p2, r.p1, r.p2); 751| |#elif defined(BOOST_REGEX_MSVC) 752| | if (((p2 - p1) != (r.p2 - r.p1))) 753| | return false; 754| | const charT* with = r.p1; 755| | const charT* pos = p1; 756| | while (pos != p2) 757| | if (*pos++ != *with++) return false; 758| | return true; 759| | 760| |#else 761| | return ((p2 - p1) == (r.p2 - r.p1)) && std::equal(p1, p2, r.p1); 762| |#endif 763| 32.2k| } _ZN5boost13re_detail_50012is_separatorIcEEbT_: 650| 10.1k|{ 651| 10.1k| return BOOST_REGEX_MAKE_BOOL((c == '\n') || (c == '\r') || (c == '\f')); ------------------ | | 35| 35.6k|# define BOOST_REGEX_MAKE_BOOL(x) static_cast(x) | | ------------------ | | | Branch (35:54): [True: 1.69k, False: 8.48k] | | | Branch (35:54): [True: 1.69k, False: 6.78k] | | | Branch (35:54): [True: 1.69k, False: 5.08k] | | ------------------ ------------------ 652| 10.1k|} _ZN5boost9sub_matchINSt3__111__wrap_iterIPcEEEC2Ev: 35| 1.69k| sub_match() : std::pair(), matched(false) {} _ZN5boost9sub_matchINSt3__111__wrap_iterIPcEEEC2ERKS5_b: 121| 62.7k| : std::pair(that), 122| 62.7k| matched(that.matched) 123| 62.7k| { 124| |#ifdef BOOST_REGEX_MATCH_EXTRA 125| | if(that.m_captures) 126| | if(deep_copy) 127| | m_captures.reset(new capture_sequence_type(*(that.m_captures))); 128| |#endif 129| 62.7k| } _ZN5boost9sub_matchINSt3__111__wrap_iterIPcEEEaSERKS5_: 131| 315k| { 132| 315k| this->first = that.first; 133| 315k| this->second = that.second; 134| 315k| matched = that.matched; 135| |#ifdef BOOST_REGEX_MATCH_EXTRA 136| | if(that.m_captures) 137| | get_captures() = *(that.m_captures); 138| |#endif 139| 315k| return *this; 140| 315k| } _ZN5boost9sub_matchINSt3__111__wrap_iterIPcEEEC2ES4_: 36| 54.2k| sub_match(BidiIterator i) : std::pair(i, i), matched(false) {} _ZNK5boost9sub_matchINSt3__111__wrap_iterIPcEEE6lengthEv: 43| 52.5k| { 44| 52.5k| difference_type n = matched ? std::distance((BidiIterator)this->first, (BidiIterator)this->second) : 0; ------------------ | Branch (44:27): [True: 52.5k, False: 0] ------------------ 45| 52.5k| return n; 46| 52.5k| } LLVMFuzzerTestOneInput: 36| 1.69k|{ 37| 1.69k| FuzzedDataProvider fdp(Data, Size); 38| 1.69k| std::string format_string = fdp.ConsumeRemainingBytesAsString(); 39| 1.69k| try{ 40| 1.69k| e1.assign(expression_text); 41| 1.69k| e2.assign(pre_expression); 42| 1.69k| std::string in; 43| 1.69k| in.assign(match_against); 44| 1.69k| std::ostringstream t(std::ios::out | std::ios::binary); 45| 1.69k| std::ostream_iterator oi(t); 46| 1.69k| boost::regex_replace(oi, in.begin(), in.end(), 47| 1.69k| e2, format_string, boost::match_default | boost::format_all); 48| 1.69k| std::string s(t.str()); 49| |#ifdef DEBUG 50| | std::cout << s << std::endl; 51| |#endif 52| 1.69k| } catch(...) { 53| 0| } 54| 1.69k| return 0; 55| 1.69k|}