From ed6115361006240e3c7b02295599e4534cc55a13 Mon Sep 17 00:00:00 2001 From: Boris Kolpackov Date: Sat, 19 Oct 2013 08:57:20 +0200 Subject: Update internal Boost subset to 1.54.0 --- .../details/boost/regex/v4/basic_regex_creator.hpp | 107 ++++++++++++--------- 1 file changed, 59 insertions(+), 48 deletions(-) (limited to 'cutl/details/boost/regex/v4/basic_regex_creator.hpp') diff --git a/cutl/details/boost/regex/v4/basic_regex_creator.hpp b/cutl/details/boost/regex/v4/basic_regex_creator.hpp index a4599f1..375d29b 100644 --- a/cutl/details/boost/regex/v4/basic_regex_creator.hpp +++ b/cutl/details/boost/regex/v4/basic_regex_creator.hpp @@ -66,7 +66,7 @@ class basic_char_set public: typedef digraph digraph_type; typedef typename traits::string_type string_type; - typedef typename traits::char_class_type mask_type; + typedef typename traits::char_class_type m_type; basic_char_set() { @@ -100,12 +100,12 @@ public: } m_empty = false; } - void add_class(mask_type m) + void add_class(m_type m) { m_classes |= m; m_empty = false; } - void add_negated_class(mask_type m) + void add_negated_class(m_type m) { m_negated_classes |= m; m_empty = false; @@ -162,11 +162,11 @@ public: { return m_equivalents.end(); } - mask_type classes()const + m_type classes()const { return m_classes; } - mask_type negated_classes()const + m_type negated_classes()const { return m_negated_classes; } @@ -179,8 +179,8 @@ private: std::vector m_ranges; // a list of end points of our ranges bool m_negate; // true if the set is to be negated bool m_has_digraphs; // true if we have digraphs present - mask_type m_classes; // character classes to match - mask_type m_negated_classes; // negated character classes to match + m_type m_classes; // character classes to match + m_type m_negated_classes; // negated character classes to match bool m_empty; // whether we've added anything yet std::vector m_equivalents; // a list of equivalence classes }; @@ -241,6 +241,7 @@ protected: unsigned m_backrefs; // bitmask of permitted backrefs cutl_details_boost::uintmax_t m_bad_repeats; // bitmask of repeats we can't deduce a startmap for; bool m_has_recursions; // set when we have recursive expresisons to fixup + std::vector m_recursion_checks; // notes which recursions we've followed while analysing this expression typename traits::char_class_type m_word_mask; // mask used to determine if a character is a word character typename traits::char_class_type m_mask_space; // mask used to determine if a character is a word character typename traits::char_class_type m_lower_mask; // mask used to determine if a character is a lowercase character @@ -366,9 +367,9 @@ re_syntax_base* basic_regex_creator::append_set( { typedef typename traits::string_type string_type; typedef typename basic_char_set::list_iterator item_iterator; - typedef typename traits::char_class_type mask_type; + typedef typename traits::char_class_type m_type; - re_set_long* result = static_cast*>(append_state(syntax_element_long_set, sizeof(re_set_long))); + re_set_long* result = static_cast*>(append_state(syntax_element_long_set, sizeof(re_set_long))); // // fill in the basics: // @@ -512,28 +513,23 @@ re_syntax_base* basic_regex_creator::append_set( // // finally reset the address of our last state: // - m_last_state = result = static_cast*>(getaddress(offset)); + m_last_state = result = static_cast*>(getaddress(offset)); return result; } -namespace{ - template inline bool char_less(T t1, T t2) { return t1 < t2; } -template<> -inline bool char_less(char t1, char t2) +inline bool char_less(char t1, char t2) { return static_cast(t1) < static_cast(t2); } -template<> -inline bool char_less(signed char t1, signed char t2) +inline bool char_less(signed char t1, signed char t2) { return static_cast(t1) < static_cast(t2); } -} template re_syntax_base* basic_regex_creator::append_set( @@ -597,7 +593,7 @@ re_syntax_base* basic_regex_creator::append_set( } else { - if(char_less(c2, c1)) + if(char_less(c2, c1)) { // Oops error: return 0; @@ -609,8 +605,8 @@ re_syntax_base* basic_regex_creator::append_set( // // and now the classes: // - typedef typename traits::char_class_type mask_type; - mask_type m = char_set.classes(); + typedef typename traits::char_class_type m_type; + m_type m = char_set.classes(); if(flags() & regbase::icase) { // adjust m as needed: @@ -712,6 +708,8 @@ void basic_regex_creator::finalize(const charT* p1, const charT* m_pdata->m_can_be_null = 0; m_bad_repeats = 0; + if(m_has_recursions) + m_recursion_checks.assign(1 + m_pdata->m_mark_count, false); create_startmap(m_pdata->m_first_state, m_pdata->m_startmap, &(m_pdata->m_can_be_null), mask_all); // get the restart type: m_pdata->m_restart_type = get_restart_type(m_pdata->m_first_state); @@ -740,14 +738,14 @@ void basic_regex_creator::fixup_pointers(re_syntax_base* state) case syntax_element_long_set_rep: // set the state_id of this repeat: static_cast(state)->state_id = m_repeater_id++; - // fall through: + BOOST_FALLTHROUGH; case syntax_element_alt: std::memset(static_cast(state)->_map, 0, sizeof(static_cast(state)->_map)); static_cast(state)->can_be_null = 0; - // fall through: + BOOST_FALLTHROUGH; case syntax_element_jump: static_cast(state)->alt.p = getaddress(static_cast(state)->alt.i, state); - // fall through again: + BOOST_FALLTHROUGH; default: if(state->next.i) state->next.p = getaddress(state->next.i, state); @@ -879,6 +877,7 @@ void basic_regex_creator::fixup_recursions(re_syntax_base* state) } } } + break; default: break; } @@ -943,14 +942,19 @@ void basic_regex_creator::create_startmaps(re_syntax_base* state) e.raise(); } } - // fall through: + BOOST_FALLTHROUGH; default: state = state->next.p; } } + // now work through our list, building all the maps as we go: while(v.size()) { + // Initialize m_recursion_checks if we need it: + if(m_has_recursions) + m_recursion_checks.assign(1 + m_pdata->m_mark_count, false); + const std::pair& p = v.back(); m_icase = p.first; state = p.second; @@ -960,6 +964,9 @@ void basic_regex_creator::create_startmaps(re_syntax_base* state) m_bad_repeats = 0; create_startmap(state->next.p, static_cast(state)->_map, &static_cast(state)->can_be_null, mask_take); m_bad_repeats = 0; + + if(m_has_recursions) + m_recursion_checks.assign(1 + m_pdata->m_mark_count, false); create_startmap(static_cast(state)->alt.p, static_cast(state)->_map, &static_cast(state)->can_be_null, mask_skip); // adjust the type of the state to allow for faster matching: state->type = this->get_repeat_type(state); @@ -971,7 +978,7 @@ void basic_regex_creator::create_startmaps(re_syntax_base* state) template int basic_regex_creator::calculate_backstep(re_syntax_base* state) { - typedef typename traits::char_class_type mask_type; + typedef typename traits::char_class_type m_type; int result = 0; while(state) { @@ -1024,10 +1031,10 @@ int basic_regex_creator::calculate_backstep(re_syntax_base* state state = rep->alt.p; continue; } - else if((state->type == syntax_element_long_set_rep)) + else if(state->type == syntax_element_long_set_rep) { BOOST_ASSERT(rep->next.p->type == syntax_element_long_set); - if(static_cast*>(rep->next.p)->singleton == 0) + if(static_cast*>(rep->next.p)->singleton == 0) return -1; if(rep->max != rep->min) return -1; @@ -1038,7 +1045,7 @@ int basic_regex_creator::calculate_backstep(re_syntax_base* state } return -1; case syntax_element_long_set: - if(static_cast*>(state)->singleton == 0) + if(static_cast*>(state)->singleton == 0) return -1; result += 1; break; @@ -1102,9 +1109,9 @@ void basic_regex_creator::create_startmap(re_syntax_base* state, if(l_map) { l_map[0] |= mask_init; - l_map['\n'] |= mask; - l_map['\r'] |= mask; - l_map['\f'] |= mask; + l_map[static_cast('\n')] |= mask; + l_map[static_cast('\r')] |= mask; + l_map[static_cast('\f')] |= mask; l_map[0x85] |= mask; } // now figure out if we can match a NULL string at this point: @@ -1114,7 +1121,11 @@ void basic_regex_creator::create_startmap(re_syntax_base* state, } case syntax_element_recurse: { - if(recursion_start == state) + if(state->type == syntax_element_startmark) + recursion_sub = static_cast(state)->index; + else + recursion_sub = 0; + if(m_recursion_checks[recursion_sub]) { // Infinite recursion!! if(0 == this->m_pdata->m_status) // update the error code if not already set @@ -1139,19 +1150,18 @@ void basic_regex_creator::create_startmap(re_syntax_base* state, recursion_start = state; recursion_restart = state->next.p; state = static_cast(state)->alt.p; - if(state->type == syntax_element_startmark) - recursion_sub = static_cast(state)->index; - else - recursion_sub = 0; + m_recursion_checks[recursion_sub] = true; break; } - // fall through, can't handle nested recursion here... + m_recursion_checks[recursion_sub] = true; + // can't handle nested recursion here... + BOOST_FALLTHROUGH; } case syntax_element_backref: // can be null, and any character can match: if(pnull) *pnull |= mask; - // fall through: + BOOST_FALLTHROUGH; case syntax_element_wild: { // can't be null, any character can match: @@ -1206,14 +1216,14 @@ void basic_regex_creator::create_startmap(re_syntax_base* state, case syntax_element_long_set: if(l_map) { - typedef typename traits::char_class_type mask_type; - if(static_cast*>(state)->singleton) + typedef typename traits::char_class_type m_type; + if(static_cast*>(state)->singleton) { l_map[0] |= mask_init; for(unsigned int i = 0; i < (1u << CHAR_BIT); ++i) { charT c = static_cast(i); - if(&c != re_is_set_member(&c, &c + 1, static_cast*>(state), *m_pdata, m_icase)) + if(&c != re_is_set_member(&c, &c + 1, static_cast*>(state), *m_pdata, l_icase)) l_map[i] |= mask; } } @@ -1289,8 +1299,8 @@ void basic_regex_creator::create_startmap(re_syntax_base* state, if(l_map) { l_map[0] |= mask_init; - l_map['\n'] |= mask; - l_map['\r'] |= mask; + l_map[static_cast('\n')] |= mask; + l_map[static_cast('\r')] |= mask; } if(pnull) *pnull |= mask; @@ -1325,7 +1335,7 @@ void basic_regex_creator::create_startmap(re_syntax_base* state, re_syntax_base* p = m_pdata->m_first_state; while(p) { - if((p->type == syntax_element_recurse)) + if(p->type == syntax_element_recurse) { re_brace* p2 = static_cast(static_cast(p)->alt.p); if((p2->type == syntax_element_startmark) && (p2->index == static_cast(state)->index)) @@ -1351,7 +1361,7 @@ void basic_regex_creator::create_startmap(re_syntax_base* state, state = state->next.p->next.p; break; } - // otherwise fall through: + BOOST_FALLTHROUGH; default: state = state->next.p; } @@ -1448,6 +1458,7 @@ void basic_regex_creator::set_bad_repeat(re_syntax_base* pt) if(state_id <= sizeof(m_bad_repeats) * CHAR_BIT) m_bad_repeats |= (one << state_id); } + break; default: break; } @@ -1456,7 +1467,7 @@ void basic_regex_creator::set_bad_repeat(re_syntax_base* pt) template syntax_element_type basic_regex_creator::get_repeat_type(re_syntax_base* state) { - typedef typename traits::char_class_type mask_type; + typedef typename traits::char_class_type m_type; if(state->type == syntax_element_rep) { // check to see if we are repeating a single state: @@ -1471,7 +1482,7 @@ syntax_element_type basic_regex_creator::get_repeat_type(re_synta case re_detail::syntax_element_set: return re_detail::syntax_element_short_set_rep; case re_detail::syntax_element_long_set: - if(static_cast*>(state->next.p)->singleton) + if(static_cast*>(state->next.p)->singleton) return re_detail::syntax_element_long_set_rep; break; default: @@ -1529,7 +1540,7 @@ void basic_regex_creator::probe_leading_repeat(re_syntax_base* st case syntax_element_long_set_rep: if(this->m_has_backrefs == 0) static_cast(state)->leading = true; - // fall through: + BOOST_FALLTHROUGH; default: return; } -- cgit v1.1