diff options
Diffstat (limited to 'cutl/details/boost/regex/v4')
| -rw-r--r-- | cutl/details/boost/regex/v4/basic_regex.hpp | 19 | ||||
| -rw-r--r-- | cutl/details/boost/regex/v4/basic_regex_creator.hpp | 107 | ||||
| -rw-r--r-- | cutl/details/boost/regex/v4/basic_regex_parser.hpp | 125 | ||||
| -rw-r--r-- | cutl/details/boost/regex/v4/cpp_regex_traits.hpp | 17 | ||||
| -rw-r--r-- | cutl/details/boost/regex/v4/instances.hpp | 7 | ||||
| -rw-r--r-- | cutl/details/boost/regex/v4/match_results.hpp | 5 | ||||
| -rw-r--r-- | cutl/details/boost/regex/v4/perl_matcher.hpp | 5 | ||||
| -rw-r--r-- | cutl/details/boost/regex/v4/perl_matcher_common.hpp | 6 | ||||
| -rw-r--r-- | cutl/details/boost/regex/v4/perl_matcher_non_recursive.hpp | 11 | ||||
| -rw-r--r-- | cutl/details/boost/regex/v4/regex_format.hpp | 25 | ||||
| -rw-r--r-- | cutl/details/boost/regex/v4/regex_iterator.hpp | 2 | ||||
| -rw-r--r-- | cutl/details/boost/regex/v4/regex_split.hpp | 2 | ||||
| -rw-r--r-- | cutl/details/boost/regex/v4/regex_traits_defaults.hpp | 34 | ||||
| -rw-r--r-- | cutl/details/boost/regex/v4/u32regex_token_iterator.hpp | 6 |
14 files changed, 243 insertions, 128 deletions
diff --git a/cutl/details/boost/regex/v4/basic_regex.hpp b/cutl/details/boost/regex/v4/basic_regex.hpp index d55cea0..e238d25 100644 --- a/cutl/details/boost/regex/v4/basic_regex.hpp +++ b/cutl/details/boost/regex/v4/basic_regex.hpp @@ -1,7 +1,7 @@ /* * - * Copyright (c) 1998-2004 - * John Maddock + * Copyright (c) 1998-2004 John Maddock + * Copyright 2011 Garmin Ltd. or its subsidiaries * * Distributed under the Boost Software License, Version 1.0. * (See accompanying file LICENSE_1_0.txt or copy at @@ -36,7 +36,10 @@ namespace cutl_details_boost{ #ifdef BOOST_MSVC #pragma warning(push) -#pragma warning(disable : 4251 4231 4660 4800) +#pragma warning(disable : 4251 4231 4800) +#if BOOST_MSVC < 1600 +#pragma warning(disable : 4660) +#endif #endif namespace re_detail{ @@ -234,7 +237,7 @@ public: std::pair<const_iterator, const_iterator> BOOST_REGEX_CALL subexpression(std::size_t n)const { if(n == 0) - throw std::out_of_range("0 is not a valid subexpression index."); + cutl_details_boost::throw_exception(std::out_of_range("0 is not a valid subexpression index.")); const std::pair<std::size_t, std::size_t>& pi = this->m_subs.at(n - 1); std::pair<const_iterator, const_iterator> p(expression() + pi.first, expression() + pi.second); return p; @@ -243,11 +246,11 @@ public: // begin, end: const_iterator BOOST_REGEX_CALL begin()const { - return (!this->m_status ? 0 : this->m_expression); + return (this->m_status ? 0 : this->m_expression); } const_iterator BOOST_REGEX_CALL end()const { - return (!this->m_status ? 0 : this->m_expression + this->m_expression_len); + return (this->m_status ? 0 : this->m_expression + this->m_expression_len); } flag_type BOOST_REGEX_CALL flags()const { @@ -398,7 +401,7 @@ public: typedef typename traits::string_type seq_type; seq_type a(arg_first, arg_last); if(a.size()) - assign(&*a.begin(), &*a.begin() + a.size(), f); + assign(static_cast<const charT*>(&*a.begin()), static_cast<const charT*>(&*a.begin() + a.size()), f); else assign(static_cast<const charT*>(0), static_cast<const charT*>(0), f); } @@ -487,7 +490,7 @@ public: std::pair<const_iterator, const_iterator> BOOST_REGEX_CALL subexpression(std::size_t n)const { if(!m_pimpl.get()) - throw std::logic_error("Can't access subexpressions in an invalid regex."); + cutl_details_boost::throw_exception(std::logic_error("Can't access subexpressions in an invalid regex.")); return m_pimpl->subexpression(n); } const_iterator BOOST_REGEX_CALL begin()const 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<charT> 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<digraph_type> 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<digraph_type> 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<bool> 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<charT, traits>::append_set( { typedef typename traits::string_type string_type; typedef typename basic_char_set<charT, traits>::list_iterator item_iterator; - typedef typename traits::char_class_type mask_type; + typedef typename traits::char_class_type m_type; - re_set_long<mask_type>* result = static_cast<re_set_long<mask_type>*>(append_state(syntax_element_long_set, sizeof(re_set_long<mask_type>))); + re_set_long<m_type>* result = static_cast<re_set_long<m_type>*>(append_state(syntax_element_long_set, sizeof(re_set_long<m_type>))); // // fill in the basics: // @@ -512,28 +513,23 @@ re_syntax_base* basic_regex_creator<charT, traits>::append_set( // // finally reset the address of our last state: // - m_last_state = result = static_cast<re_set_long<mask_type>*>(getaddress(offset)); + m_last_state = result = static_cast<re_set_long<m_type>*>(getaddress(offset)); return result; } -namespace{ - template<class T> inline bool char_less(T t1, T t2) { return t1 < t2; } -template<> -inline bool char_less<char>(char t1, char t2) +inline bool char_less(char t1, char t2) { return static_cast<unsigned char>(t1) < static_cast<unsigned char>(t2); } -template<> -inline bool char_less<signed char>(signed char t1, signed char t2) +inline bool char_less(signed char t1, signed char t2) { return static_cast<unsigned char>(t1) < static_cast<unsigned char>(t2); } -} template <class charT, class traits> re_syntax_base* basic_regex_creator<charT, traits>::append_set( @@ -597,7 +593,7 @@ re_syntax_base* basic_regex_creator<charT, traits>::append_set( } else { - if(char_less<charT>(c2, c1)) + if(char_less(c2, c1)) { // Oops error: return 0; @@ -609,8 +605,8 @@ re_syntax_base* basic_regex_creator<charT, traits>::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<charT, traits>::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<charT, traits>::fixup_pointers(re_syntax_base* state) case syntax_element_long_set_rep: // set the state_id of this repeat: static_cast<re_repeat*>(state)->state_id = m_repeater_id++; - // fall through: + BOOST_FALLTHROUGH; case syntax_element_alt: std::memset(static_cast<re_alt*>(state)->_map, 0, sizeof(static_cast<re_alt*>(state)->_map)); static_cast<re_alt*>(state)->can_be_null = 0; - // fall through: + BOOST_FALLTHROUGH; case syntax_element_jump: static_cast<re_jump*>(state)->alt.p = getaddress(static_cast<re_jump*>(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<charT, traits>::fixup_recursions(re_syntax_base* state) } } } + break; default: break; } @@ -943,14 +942,19 @@ void basic_regex_creator<charT, traits>::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<bool, re_syntax_base*>& p = v.back(); m_icase = p.first; state = p.second; @@ -960,6 +964,9 @@ void basic_regex_creator<charT, traits>::create_startmaps(re_syntax_base* state) m_bad_repeats = 0; create_startmap(state->next.p, static_cast<re_alt*>(state)->_map, &static_cast<re_alt*>(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<re_alt*>(state)->alt.p, static_cast<re_alt*>(state)->_map, &static_cast<re_alt*>(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<charT, traits>::create_startmaps(re_syntax_base* state) template <class charT, class traits> int basic_regex_creator<charT, traits>::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<charT, traits>::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<re_set_long<mask_type>*>(rep->next.p)->singleton == 0) + if(static_cast<re_set_long<m_type>*>(rep->next.p)->singleton == 0) return -1; if(rep->max != rep->min) return -1; @@ -1038,7 +1045,7 @@ int basic_regex_creator<charT, traits>::calculate_backstep(re_syntax_base* state } return -1; case syntax_element_long_set: - if(static_cast<re_set_long<mask_type>*>(state)->singleton == 0) + if(static_cast<re_set_long<m_type>*>(state)->singleton == 0) return -1; result += 1; break; @@ -1102,9 +1109,9 @@ void basic_regex_creator<charT, traits>::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<unsigned>('\n')] |= mask; + l_map[static_cast<unsigned>('\r')] |= mask; + l_map[static_cast<unsigned>('\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<charT, traits>::create_startmap(re_syntax_base* state, } case syntax_element_recurse: { - if(recursion_start == state) + if(state->type == syntax_element_startmark) + recursion_sub = static_cast<re_brace*>(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<charT, traits>::create_startmap(re_syntax_base* state, recursion_start = state; recursion_restart = state->next.p; state = static_cast<re_jump*>(state)->alt.p; - if(state->type == syntax_element_startmark) - recursion_sub = static_cast<re_brace*>(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<charT, traits>::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<re_set_long<mask_type>*>(state)->singleton) + typedef typename traits::char_class_type m_type; + if(static_cast<re_set_long<m_type>*>(state)->singleton) { l_map[0] |= mask_init; for(unsigned int i = 0; i < (1u << CHAR_BIT); ++i) { charT c = static_cast<charT>(i); - if(&c != re_is_set_member(&c, &c + 1, static_cast<re_set_long<mask_type>*>(state), *m_pdata, m_icase)) + if(&c != re_is_set_member(&c, &c + 1, static_cast<re_set_long<m_type>*>(state), *m_pdata, l_icase)) l_map[i] |= mask; } } @@ -1289,8 +1299,8 @@ void basic_regex_creator<charT, traits>::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<unsigned>('\n')] |= mask; + l_map[static_cast<unsigned>('\r')] |= mask; } if(pnull) *pnull |= mask; @@ -1325,7 +1335,7 @@ void basic_regex_creator<charT, traits>::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<re_brace*>(static_cast<re_jump*>(p)->alt.p); if((p2->type == syntax_element_startmark) && (p2->index == static_cast<re_brace*>(state)->index)) @@ -1351,7 +1361,7 @@ void basic_regex_creator<charT, traits>::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<charT, traits>::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<charT, traits>::set_bad_repeat(re_syntax_base* pt) template <class charT, class traits> syntax_element_type basic_regex_creator<charT, traits>::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<charT, traits>::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<re_detail::re_set_long<mask_type>*>(state->next.p)->singleton) + if(static_cast<re_detail::re_set_long<m_type>*>(state->next.p)->singleton) return re_detail::syntax_element_long_set_rep; break; default: @@ -1529,7 +1540,7 @@ void basic_regex_creator<charT, traits>::probe_leading_repeat(re_syntax_base* st case syntax_element_long_set_rep: if(this->m_has_backrefs == 0) static_cast<re_repeat*>(state)->leading = true; - // fall through: + BOOST_FALLTHROUGH; default: return; } diff --git a/cutl/details/boost/regex/v4/basic_regex_parser.hpp b/cutl/details/boost/regex/v4/basic_regex_parser.hpp index 63475e8..9182da2 100644 --- a/cutl/details/boost/regex/v4/basic_regex_parser.hpp +++ b/cutl/details/boost/regex/v4/basic_regex_parser.hpp @@ -191,6 +191,7 @@ void basic_regex_parser<charT, traits>::fail(regex_constants::error_type error_c this->m_pdata->m_status = error_code; m_position = m_end; // don't bother parsing anything else +#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS // // Augment error message with the regular expression text: // @@ -200,9 +201,9 @@ void basic_regex_parser<charT, traits>::fail(regex_constants::error_type error_c if(error_code != regex_constants::error_empty) { if((start_pos != 0) || (end_pos != (m_end - m_base))) - message += " The error occured while parsing the regular expression fragment: '"; + message += " The error occurred while parsing the regular expression fragment: '"; else - message += " The error occured while parsing the regular expression: '"; + message += " The error occurred while parsing the regular expression: '"; if(start_pos != end_pos) { message += std::string(m_base + start_pos, m_base + position); @@ -211,6 +212,7 @@ void basic_regex_parser<charT, traits>::fail(regex_constants::error_type error_c } message += "'."; } +#endif #ifndef BOOST_NO_EXCEPTIONS if(0 == (this->flags() & regex_constants::no_except)) @@ -367,7 +369,7 @@ bool basic_regex_parser<charT, traits>::parse_extended() while((m_position != m_end) && !is_separator(*m_position++)){} return true; } - // Otherwise fall through: + BOOST_FALLTHROUGH; default: result = parse_literal(); break; @@ -621,7 +623,7 @@ bool basic_regex_parser<charT, traits>::parse_basic_escape() { case 'w': negate = false; - // fall through: + BOOST_FALLTHROUGH; case 'W': { basic_char_set<charT, traits> char_set; @@ -638,7 +640,7 @@ bool basic_regex_parser<charT, traits>::parse_basic_escape() } case 's': negate = false; - // fall through: + BOOST_FALLTHROUGH; case 'S': return add_emacs_code(negate); case 'c': @@ -660,17 +662,22 @@ template <class charT, class traits> bool basic_regex_parser<charT, traits>::parse_extended_escape() { ++m_position; + if(m_position == m_end) + { + fail(regex_constants::error_escape, m_position - m_base, "Incomplete escape sequence found."); + return false; + } bool negate = false; // in case this is a character class escape: \w \d etc switch(this->m_traits.escape_syntax_type(*m_position)) { case regex_constants::escape_type_not_class: negate = true; - // fall through: + BOOST_FALLTHROUGH; case regex_constants::escape_type_class: { escape_type_class_jump: - typedef typename traits::char_class_type mask_type; - mask_type m = this->m_traits.lookup_classname(m_position, m_position+1); + typedef typename traits::char_class_type m_type; + m_type m = this->m_traits.lookup_classname(m_position, m_position+1); if(m != 0) { basic_char_set<charT, traits> char_set; @@ -735,7 +742,7 @@ escape_type_class_jump: break; case regex_constants::escape_type_not_property: negate = true; - // fall through: + BOOST_FALLTHROUGH; case regex_constants::escape_type_property: { ++m_position; @@ -894,7 +901,7 @@ escape_type_class_jump: case regex_constants::escape_type_control_v: if(0 == (this->flags() & (regbase::main_option_type | regbase::no_perl_ex))) goto escape_type_class_jump; - // fallthrough: + BOOST_FALLTHROUGH; default: this->append_literal(unescape_character()); break; @@ -941,7 +948,8 @@ bool basic_regex_parser<charT, traits>::parse_repeat(std::size_t low, std::size_ ++m_position; } // for perl regexes only check for pocessive ++ repeats. - if((0 == (this->flags() & regbase::main_option_type)) + if((m_position != m_end) + && (0 == (this->flags() & regbase::main_option_type)) && (this->m_traits.syntax_type(*m_position) == regex_constants::syntax_plus)) { pocessive = true; @@ -1025,13 +1033,14 @@ bool basic_regex_parser<charT, traits>::parse_repeat(std::size_t low, std::size_ { // // Check for illegal following quantifier, we have to do this here, because - // the extra states we insert below circumvents are usual error checking :-( + // the extra states we insert below circumvents our usual error checking :-( // switch(this->m_traits.syntax_type(*m_position)) { case regex_constants::syntax_star: case regex_constants::syntax_plus: case regex_constants::syntax_question: + case regex_constants::syntax_open_brace: fail(regex_constants::error_badrepeat, m_position - m_base); return false; } @@ -1061,26 +1070,46 @@ bool basic_regex_parser<charT, traits>::parse_repeat_range(bool isbasic) // skip whitespace: while((m_position != m_end) && this->m_traits.isctype(*m_position, this->m_mask_space)) ++m_position; - // fail if at end: if(this->m_position == this->m_end) { - fail(regex_constants::error_brace, this->m_position - this->m_base, incomplete_message); - return false; + if(this->flags() & (regbase::main_option_type | regbase::no_perl_ex)) + { + fail(regex_constants::error_brace, this->m_position - this->m_base, incomplete_message); + return false; + } + // Treat the opening '{' as a literal character, rewind to start of error: + --m_position; + while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_brace) --m_position; + return parse_literal(); } // get min: v = this->m_traits.toi(m_position, m_end, 10); // skip whitespace: - while((m_position != m_end) && this->m_traits.isctype(*m_position, this->m_mask_space)) - ++m_position; if(v < 0) { - fail(regex_constants::error_badbrace, this->m_position - this->m_base); - return false; + if(this->flags() & (regbase::main_option_type | regbase::no_perl_ex)) + { + fail(regex_constants::error_brace, this->m_position - this->m_base, incomplete_message); + return false; + } + // Treat the opening '{' as a literal character, rewind to start of error: + --m_position; + while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_brace) --m_position; + return parse_literal(); } - else if(this->m_position == this->m_end) + while((m_position != m_end) && this->m_traits.isctype(*m_position, this->m_mask_space)) + ++m_position; + if(this->m_position == this->m_end) { - fail(regex_constants::error_brace, this->m_position - this->m_base, incomplete_message); - return false; + if(this->flags() & (regbase::main_option_type | regbase::no_perl_ex)) + { + fail(regex_constants::error_brace, this->m_position - this->m_base, incomplete_message); + return false; + } + // Treat the opening '{' as a literal character, rewind to start of error: + --m_position; + while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_brace) --m_position; + return parse_literal(); } min = v; // see if we have a comma: @@ -1093,12 +1122,19 @@ bool basic_regex_parser<charT, traits>::parse_repeat_range(bool isbasic) ++m_position; if(this->m_position == this->m_end) { - fail(regex_constants::error_brace, this->m_position - this->m_base, incomplete_message); - return false; + if(this->flags() & (regbase::main_option_type | regbase::no_perl_ex)) + { + fail(regex_constants::error_brace, this->m_position - this->m_base, incomplete_message); + return false; + } + // Treat the opening '{' as a literal character, rewind to start of error: + --m_position; + while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_brace) --m_position; + return parse_literal(); } // get the value if any: v = this->m_traits.toi(m_position, m_end, 10); - max = (v >= 0) ? v : (std::numeric_limits<std::size_t>::max)(); + max = (v >= 0) ? (std::size_t)v : (std::numeric_limits<std::size_t>::max)(); } else { @@ -1111,8 +1147,15 @@ bool basic_regex_parser<charT, traits>::parse_repeat_range(bool isbasic) // OK now check trailing }: if(this->m_position == this->m_end) { - fail(regex_constants::error_brace, this->m_position - this->m_base, incomplete_message); - return false; + if(this->flags() & (regbase::main_option_type | regbase::no_perl_ex)) + { + fail(regex_constants::error_brace, this->m_position - this->m_base, incomplete_message); + return false; + } + // Treat the opening '{' as a literal character, rewind to start of error: + --m_position; + while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_brace) --m_position; + return parse_literal(); } if(isbasic) { @@ -1135,8 +1178,10 @@ bool basic_regex_parser<charT, traits>::parse_repeat_range(bool isbasic) ++m_position; else { - fail(regex_constants::error_brace, this->m_position - this->m_base, incomplete_message); - return false; + // Treat the opening '{' as a literal character, rewind to start of error: + --m_position; + while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_brace) --m_position; + return parse_literal(); } // // finally go and add the repeat, unless error: @@ -1381,8 +1426,8 @@ bool basic_regex_parser<charT, traits>::parse_inner_set(basic_char_set<charT, tr ++name_first; negated = true; } - typedef typename traits::char_class_type mask_type; - mask_type m = this->m_traits.lookup_classname(name_first, name_last); + typedef typename traits::char_class_type m_type; + m_type m = this->m_traits.lookup_classname(name_first, name_last); if(m == 0) { if(char_set.empty() && (name_last - name_first == 1)) @@ -1950,7 +1995,7 @@ bool basic_regex_parser<charT, traits>::parse_perl_extension() { case regex_constants::syntax_or: m_mark_reset = m_mark_count; - // fall through: + BOOST_FALLTHROUGH; case regex_constants::syntax_colon: // // a non-capturing mark: @@ -2087,6 +2132,14 @@ insert_recursion: return false; } v = this->m_traits.toi(m_position, m_end, 10); + if(m_position == m_end) + { + // Rewind to start of (? sequence: + --m_position; + while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; + fail(regex_constants::error_perl_extension, m_position - m_base); + return false; + } if(*m_position == charT('R')) { if(++m_position == m_end) @@ -2490,9 +2543,11 @@ option_group_jump: this->m_pdata->m_data.align(); re_jump* jmp = static_cast<re_jump*>(this->getaddress(jump_offset)); jmp->alt.i = this->m_pdata->m_data.size() - this->getoffset(jmp); - if(this->m_last_state == jmp) + if((this->m_last_state == jmp) && (markid != -2)) { - // Oops... we didn't have anything inside the assertion: + // Oops... we didn't have anything inside the assertion. + // Note we don't get here for negated forward lookahead as (?!) + // does have some uses. // Rewind to start of (? sequence: --m_position; while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position; @@ -2711,6 +2766,8 @@ regex_constants::syntax_option_type basic_regex_parser<charT, traits>::parse_opt } } while(!breakout); + + breakout = false; if(*m_position == static_cast<charT>('-')) { diff --git a/cutl/details/boost/regex/v4/cpp_regex_traits.hpp b/cutl/details/boost/regex/v4/cpp_regex_traits.hpp index 7281e84..654f668 100644 --- a/cutl/details/boost/regex/v4/cpp_regex_traits.hpp +++ b/cutl/details/boost/regex/v4/cpp_regex_traits.hpp @@ -1,7 +1,7 @@ /* * - * Copyright (c) 2004 - * John Maddock + * Copyright (c) 2004 John Maddock + * Copyright 2011 Garmin Ltd. or its subsidiaries * * Use, modification and distribution are subject to the * Boost Software License, Version 1.0. (See accompanying file @@ -20,6 +20,7 @@ #define BOOST_CPP_REGEX_TRAITS_HPP_INCLUDED #include <cutl/details/boost/config.hpp> +#include <cutl/details/boost/integer.hpp> #ifndef BOOST_NO_STD_LOCALE @@ -107,12 +108,14 @@ template<class charT, class traits> typename parser_buf<charT, traits>::pos_type parser_buf<charT, traits>::seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which) { + typedef typename cutl_details_boost::int_t<sizeof(way) * CHAR_BIT>::least cast_type; + if(which & ::std::ios_base::out) return pos_type(off_type(-1)); std::ptrdiff_t size = this->egptr() - this->eback(); std::ptrdiff_t pos = this->gptr() - this->eback(); charT* g = this->eback(); - switch(way) + switch(static_cast<cast_type>(way)) { case ::std::ios_base::beg: if((off < 0) || (off > size)) @@ -511,7 +514,9 @@ typename cpp_regex_traits_implementation<charT>::string_type // however at least one std lib will always throw // std::bad_alloc for certain arguments... // +#ifndef BOOST_NO_EXCEPTIONS try{ +#endif // // What we do here depends upon the format of the sort key returned by // sort key returned by this->transform: @@ -546,7 +551,9 @@ typename cpp_regex_traits_implementation<charT>::string_type result.erase(i); break; } +#ifndef BOOST_NO_EXCEPTIONS }catch(...){} +#endif while(result.size() && (charT(0) == *result.rbegin())) result.erase(result.size() - 1); if(result.empty()) @@ -576,7 +583,9 @@ typename cpp_regex_traits_implementation<charT>::string_type // std::bad_alloc for certain arguments... // string_type result; +#ifndef BOOST_NO_EXCEPTIONS try{ +#endif result = this->m_pcollate->transform(p1, p2); // // Borland's STLPort version returns a NULL-terminated @@ -593,10 +602,12 @@ typename cpp_regex_traits_implementation<charT>::string_type result.erase(result.size() - 1); #endif BOOST_ASSERT(std::find(result.begin(), result.end(), charT(0)) == result.end()); +#ifndef BOOST_NO_EXCEPTIONS } catch(...) { } +#endif return result; } diff --git a/cutl/details/boost/regex/v4/instances.hpp b/cutl/details/boost/regex/v4/instances.hpp index 0ebf5c9..831d6ad 100644 --- a/cutl/details/boost/regex/v4/instances.hpp +++ b/cutl/details/boost/regex/v4/instances.hpp @@ -84,7 +84,10 @@ template class BOOST_REGEX_DECL ::cutl_details_boost::re_detail::perl_matcher<BO # ifdef BOOST_MSVC # pragma warning(push) -# pragma warning(disable : 4251 4231 4660) +# pragma warning(disable : 4251 4231) +# if BOOST_MSVC < 1600 +# pragma warning(disable : 4660) +# endif # endif template class BOOST_REGEX_TEMPLATE_DECL basic_regex< BOOST_REGEX_CHAR_T BOOST_REGEX_TRAITS_T >; @@ -118,7 +121,7 @@ template class BOOST_REGEX_TEMPLATE_DECL ::cutl_details_boost::re_detail::perl_m #undef BOOST_REGEX_TEMPLATE_DECL -#elif (defined(__GNUC__) && (__GNUC__ >= 3)) || !defined(BOOST_NO_EXTERN_TEMPLATE) +#elif (defined(__GNUC__) && (__GNUC__ >= 3)) || !defined(BOOST_NO_CXX11_EXTERN_TEMPLATE) # ifndef BOOST_REGEX_INSTANTIATE # ifdef __GNUC__ diff --git a/cutl/details/boost/regex/v4/match_results.hpp b/cutl/details/boost/regex/v4/match_results.hpp index 4cdeb3c..8046cfd 100644 --- a/cutl/details/boost/regex/v4/match_results.hpp +++ b/cutl/details/boost/regex/v4/match_results.hpp @@ -33,7 +33,10 @@ namespace cutl_details_boost{ #ifdef BOOST_MSVC #pragma warning(push) -#pragma warning(disable : 4251 4231 4660) +#pragma warning(disable : 4251 4231) +# if BOOST_MSVC < 1600 +# pragma warning(disable : 4660) +# endif #endif namespace re_detail{ diff --git a/cutl/details/boost/regex/v4/perl_matcher.hpp b/cutl/details/boost/regex/v4/perl_matcher.hpp index 8da8bed..3ef87be 100644 --- a/cutl/details/boost/regex/v4/perl_matcher.hpp +++ b/cutl/details/boost/regex/v4/perl_matcher.hpp @@ -344,7 +344,10 @@ struct recursion_info #ifdef BOOST_MSVC #pragma warning(push) -#pragma warning(disable : 4251 4231 4660) +#pragma warning(disable : 4251 4231) +# if BOOST_MSVC < 1600 +# pragma warning(disable : 4660) +# endif #endif template <class BidiIterator, class Allocator, class traits> diff --git a/cutl/details/boost/regex/v4/perl_matcher_common.hpp b/cutl/details/boost/regex/v4/perl_matcher_common.hpp index d7c9a85..e5dbfd2 100644 --- a/cutl/details/boost/regex/v4/perl_matcher_common.hpp +++ b/cutl/details/boost/regex/v4/perl_matcher_common.hpp @@ -65,6 +65,8 @@ void perl_matcher<BidiIterator, Allocator, traits>::construct_init(const basic_r m_match_flags |= match_perl; else if((re_f & (regbase::main_option_type|regbase::emacs_ex)) == (regbase::basic_syntax_group|regbase::emacs_ex)) m_match_flags |= match_perl; + else if((re_f & (regbase::main_option_type|regbase::literal)) == (regbase::literal)) + m_match_flags |= match_perl; else m_match_flags |= match_posix; } @@ -326,6 +328,10 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_prefix() m_has_found_match = true; m_presult->set_second(last, 0, false); position = last; + if((m_match_flags & match_posix) == match_posix) + { + m_result.maybe_assign(*m_presult); + } } #ifdef BOOST_REGEX_MATCH_EXTRA if(m_has_found_match && (match_extra & m_match_flags)) diff --git a/cutl/details/boost/regex/v4/perl_matcher_non_recursive.hpp b/cutl/details/boost/regex/v4/perl_matcher_non_recursive.hpp index e4b1e1e..9e3d74d 100644 --- a/cutl/details/boost/regex/v4/perl_matcher_non_recursive.hpp +++ b/cutl/details/boost/regex/v4/perl_matcher_non_recursive.hpp @@ -828,9 +828,9 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_long_set_repeat() #ifdef __BORLANDC__ #pragma option push -w-8008 -w-8066 -w-8004 #endif - typedef typename traits::char_class_type mask_type; + typedef typename traits::char_class_type m_type; const re_repeat* rep = static_cast<const re_repeat*>(pstate); - const re_set_long<mask_type>* set = static_cast<const re_set_long<mask_type>*>(pstate->next.p); + const re_set_long<m_type>* set = static_cast<const re_set_long<m_type>*>(pstate->next.p); std::size_t count = 0; // // start by working out how much we can skip: @@ -1268,6 +1268,9 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_fast_dot_repeat(bool }while((count < rep->max) && (position != last) && !can_start(*position, rep->_map, mask_skip)); } + // remember where we got to if this is a leading repeat: + if((rep->leading) && (count < rep->max)) + restart = position; if(position == last) { // can't repeat any more, remove the pushed state: @@ -1434,7 +1437,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_short_set_repeat(bool template <class BidiIterator, class Allocator, class traits> bool perl_matcher<BidiIterator, Allocator, traits>::unwind_long_set_repeat(bool r) { - typedef typename traits::char_class_type mask_type; + typedef typename traits::char_class_type m_type; saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state); // if we have a match, just discard this state: @@ -1447,7 +1450,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_long_set_repeat(bool const re_repeat* rep = pmp->rep; std::size_t count = pmp->count; pstate = rep->next.p; - const re_set_long<mask_type>* set = static_cast<const re_set_long<mask_type>*>(pstate); + const re_set_long<m_type>* set = static_cast<const re_set_long<m_type>*>(pstate); position = pmp->last_position; BOOST_ASSERT(rep->type == syntax_element_long_set_rep); diff --git a/cutl/details/boost/regex/v4/regex_format.hpp b/cutl/details/boost/regex/v4/regex_format.hpp index 211859f..c4a60f9 100644 --- a/cutl/details/boost/regex/v4/regex_format.hpp +++ b/cutl/details/boost/regex/v4/regex_format.hpp @@ -180,8 +180,14 @@ private: } inline int toi(ForwardIter& i, ForwardIter j, int base) { +#if defined(_MSC_VER) && defined(__INTEL_COMPILER) && ((__INTEL_COMPILER == 9999) || (__INTEL_COMPILER == 1210)) + // Workaround for Intel support issue #656654. + // See also https://svn.boost.org/trac/boost/ticket/6359 + return toi(i, j, base, mpl::false_()); +#else typedef typename cutl_details_boost::is_convertible<ForwardIter, const char_type*&>::type tag_type; return toi(i, j, base, tag_type()); +#endif } const traits& m_traits; // the traits class for localised formatting operations @@ -277,7 +283,8 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format format_perl(); break; } - // fall through, not a special character: + // not a special character: + BOOST_FALLTHROUGH; default: put(*m_position); ++m_position; @@ -348,7 +355,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format case '{': have_brace = true; ++m_position; - // fall through.... + BOOST_FALLTHROUGH; default: // see if we have a number: { @@ -842,7 +849,15 @@ OutputIterator regex_format_imp(OutputIterator out, BOOST_MPL_HAS_XXX_TRAIT_DEF(const_iterator) -struct any_type { any_type(...); }; +struct any_type +{ + template <class T> + any_type(const T&); + template <class T, class U> + any_type(const T&, const U&); + template <class T, class U, class V> + any_type(const T&, const U&, const V&); +}; typedef char no_type; typedef char (&unary_type)[2]; typedef char (&binary_type)[3]; @@ -1050,7 +1065,7 @@ struct format_functor_c_string template <class OutputIter> OutputIter operator()(const Match& m, OutputIter i, cutl_details_boost::regex_constants::match_flag_type f, const Traits& t = Traits()) { - typedef typename Match::char_type char_type; + //typedef typename Match::char_type char_type; const charT* end = func; while(*end) ++end; return regex_format_imp(i, m, func, end, f, t); @@ -1069,7 +1084,7 @@ struct format_functor_container template <class OutputIter> OutputIter operator()(const Match& m, OutputIter i, cutl_details_boost::regex_constants::match_flag_type f, const Traits& t = Traits()) { - typedef typename Match::char_type char_type; + //typedef typename Match::char_type char_type; return re_detail::regex_format_imp(i, m, func.begin(), func.end(), f, t); } private: diff --git a/cutl/details/boost/regex/v4/regex_iterator.hpp b/cutl/details/boost/regex/v4/regex_iterator.hpp index daf8d22..82d0d09 100644 --- a/cutl/details/boost/regex/v4/regex_iterator.hpp +++ b/cutl/details/boost/regex/v4/regex_iterator.hpp @@ -68,7 +68,7 @@ public: // flags |= match_prev_avail; BidirectionalIterator next_start = what[0].second; match_flag_type f(flags); - if(!what.length()) + if(!what.length() || (f & regex_constants::match_posix)) f |= regex_constants::match_not_initial_null; //if(base != next_start) // f |= regex_constants::match_not_bob; diff --git a/cutl/details/boost/regex/v4/regex_split.hpp b/cutl/details/boost/regex/v4/regex_split.hpp index c90e0d4..db1bac0 100644 --- a/cutl/details/boost/regex/v4/regex_split.hpp +++ b/cutl/details/boost/regex/v4/regex_split.hpp @@ -107,7 +107,7 @@ std::size_t regex_split(OutputIterator out, std::size_t max_split) { typedef typename std::basic_string<charT, Traits1, Alloc1>::const_iterator ci_t; - typedef typename match_results<ci_t>::allocator_type match_allocator; + //typedef typename match_results<ci_t>::allocator_type match_allocator; ci_t last = s.begin(); std::size_t init_size = max_split; re_detail::split_pred<OutputIterator, charT, Traits1, Alloc1> pred(&last, &out, &max_split); diff --git a/cutl/details/boost/regex/v4/regex_traits_defaults.hpp b/cutl/details/boost/regex/v4/regex_traits_defaults.hpp index 457d0ff..eeb0f2e 100644 --- a/cutl/details/boost/regex/v4/regex_traits_defaults.hpp +++ b/cutl/details/boost/regex/v4/regex_traits_defaults.hpp @@ -3,12 +3,12 @@ * Copyright (c) 2004 * John Maddock * - * Use, modification and distribution are subject to the - * Boost Software License, Version 1.0. (See accompanying file + * Use, modification and distribution are subject to the + * Boost Software License, Version 1.0. (See accompanying file * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) * */ - + /* * LOCATION: see http://www.boost.org for most recent version. * FILE regex_traits_defaults.hpp @@ -85,7 +85,7 @@ inline bool is_combining<unsigned char>(unsigned char) return false; } #if !defined(__hpux) && !defined(__WINSCW__) // can't use WCHAR_MAX/MIN in pp-directives -#ifdef _MSC_VER +#ifdef _MSC_VER template<> inline bool is_combining<wchar_t>(wchar_t c) { @@ -115,11 +115,11 @@ template <class charT> inline bool is_separator(charT c) { return BOOST_REGEX_MAKE_BOOL( - (c == static_cast<charT>('\n')) - || (c == static_cast<charT>('\r')) - || (c == static_cast<charT>('\f')) - || (static_cast<cutl_details_boost::uint16_t>(c) == 0x2028u) - || (static_cast<cutl_details_boost::uint16_t>(c) == 0x2029u) + (c == static_cast<charT>('\n')) + || (c == static_cast<charT>('\r')) + || (c == static_cast<charT>('\f')) + || (static_cast<cutl_details_boost::uint16_t>(c) == 0x2028u) + || (static_cast<cutl_details_boost::uint16_t>(c) == 0x2029u) || (static_cast<cutl_details_boost::uint16_t>(c) == 0x85u)); } template <> @@ -177,7 +177,7 @@ int get_default_class_id(const charT* p1, const charT* p2) 'x', 'd', 'i', 'g', 'i', 't', }; - static const character_pointer_range<charT> ranges[21] = + static const character_pointer_range<charT> ranges[21] = { {data+0, data+5,}, // alnum {data+5, data+10,}, // alpha @@ -203,7 +203,7 @@ int get_default_class_id(const charT* p1, const charT* p2) }; static const character_pointer_range<charT>* ranges_begin = ranges; static const character_pointer_range<charT>* ranges_end = ranges + (sizeof(ranges)/sizeof(ranges[0])); - + character_pointer_range<charT> t = { p1, p2, }; const character_pointer_range<charT>* p = std::lower_bound(ranges_begin, ranges_end, t); if((p != ranges_end) && (t == *p)) @@ -324,15 +324,15 @@ inline const charT* get_escape_R_string() # pragma warning(push) # pragma warning(disable:4309 4245) #endif - static const charT e1[] = { '(', '?', '>', '\x0D', '\x0A', '?', - '|', '[', '\x0A', '\x0B', '\x0C', '\x85', '\\', 'x', '{', '2', '0', '2', '8', '}', + static const charT e1[] = { '(', '?', '>', '\x0D', '\x0A', '?', + '|', '[', '\x0A', '\x0B', '\x0C', static_cast<unsigned char>('\x85'), '\\', 'x', '{', '2', '0', '2', '8', '}', '\\', 'x', '{', '2', '0', '2', '9', '}', ']', ')', '\0' }; - static const charT e2[] = { '(', '?', '>', '\x0D', '\x0A', '?', - '|', '[', '\x0A', '\x0B', '\x0C', '\x85', ']', ')', '\0' }; + static const charT e2[] = { '(', '?', '>', '\x0D', '\x0A', '?', + '|', '[', '\x0A', '\x0B', '\x0C', static_cast<unsigned char>('\x85'), ']', ')', '\0' }; charT c = static_cast<charT>(0x2029u); bool b = (static_cast<unsigned>(c) == 0x2029u); - + return (b ? e1 : e2); #ifdef BOOST_MSVC # pragma warning(pop) @@ -346,7 +346,7 @@ inline const char* get_escape_R_string<char>() # pragma warning(push) # pragma warning(disable:4309) #endif - static const char e2[] = { '(', '?', '>', '\x0D', '\x0A', '?', + static const char e2[] = { '(', '?', '>', '\x0D', '\x0A', '?', '|', '[', '\x0A', '\x0B', '\x0C', '\x85', ']', ')', '\0' }; return e2; #ifdef BOOST_MSVC diff --git a/cutl/details/boost/regex/v4/u32regex_token_iterator.hpp b/cutl/details/boost/regex/v4/u32regex_token_iterator.hpp index 755f65e..0c7a533 100644 --- a/cutl/details/boost/regex/v4/u32regex_token_iterator.hpp +++ b/cutl/details/boost/regex/v4/u32regex_token_iterator.hpp @@ -317,14 +317,14 @@ inline u32regex_token_iterator<const wchar_t*> make_u32regex_token_iterator(cons template <std::size_t N> inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const UChar* p, const u32regex& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default) { - return u32regex_token_iterator<const UChar*>(p, p+u_strlen(p), e, m); + return u32regex_token_iterator<const UChar*>(p, p+u_strlen(p), e, submatch, m); } #endif template <class charT, class Traits, class Alloc, std::size_t N> inline u32regex_token_iterator<typename std::basic_string<charT, Traits, Alloc>::const_iterator> make_u32regex_token_iterator(const std::basic_string<charT, Traits, Alloc>& p, const u32regex& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default) { typedef typename std::basic_string<charT, Traits, Alloc>::const_iterator iter_type; - return u32regex_token_iterator<iter_type>(p.begin(), p.end(), e, m); + return u32regex_token_iterator<iter_type>(p.begin(), p.end(), e, submatch, m); } template <std::size_t N> inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const U_NAMESPACE_QUALIFIER UnicodeString& s, const u32regex& e, const int (&submatch)[N], regex_constants::match_flag_type m = regex_constants::match_default) @@ -354,7 +354,7 @@ template <class charT, class Traits, class Alloc> inline u32regex_token_iterator<typename std::basic_string<charT, Traits, Alloc>::const_iterator> make_u32regex_token_iterator(const std::basic_string<charT, Traits, Alloc>& p, const u32regex& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default) { typedef typename std::basic_string<charT, Traits, Alloc>::const_iterator iter_type; - return u32regex_token_iterator<iter_type>(p.begin(), p.end(), e, m); + return u32regex_token_iterator<iter_type>(p.begin(), p.end(), e, submatch, m); } inline u32regex_token_iterator<const UChar*> make_u32regex_token_iterator(const U_NAMESPACE_QUALIFIER UnicodeString& s, const u32regex& e, const std::vector<int>& submatch, regex_constants::match_flag_type m = regex_constants::match_default) { |