boostorg/regex
1
0
Fork 1
mirror of https://github.com/boostorg/regex.git synced 2025-07-23 00:57:19 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge warning fixes from Trunk.

Browse Source 
Merge Documentation fixes from Trunk.
Merge updated makefiles from Trunk.

[SVN r78577]
This commit is contained in:
John Maddock
2012-05-24 10:03:48 +00:00
parent 090520dbb4
commit 5964976b93
107 changed files with 3817 additions and 3747 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/boost/regex/concepts.hpp
View File

@ -63,6 +63,8 @@ struct char_architype
// conversion to integral type:
operator long()const;
};
inline long hash_value(char_architype val)
{ return val; }
//
// char_architype can not be used with basic_string:
//

2
include/boost/regex/pending/object_cache.hpp
View File

@ -151,7 +151,7 @@ boost::shared_ptr<Object const> object_cache<Key, Object>::do_get(const Key& k,
--s;
}
else
--pos;
++pos;
}
BOOST_ASSERT(s_data.index[k]->first.get() == result.get());
BOOST_ASSERT(&(s_data.index.find(k)->first) == s_data.cont.back().second);

65
include/boost/regex/v4/basic_regex_creator.hpp
View File

@ -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
};
@ -367,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:
//
@ -513,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(
@ -598,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;
@ -610,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:
@ -982,7 +977,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)
{
@ -1035,10 +1030,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;
@ -1049,7 +1044,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;
@ -1113,9 +1108,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:
@ -1219,14 +1214,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, l_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;
}
}
@ -1302,8 +1297,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;
@ -1338,7 +1333,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))
@ -1469,7 +1464,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:
@ -1484,7 +1479,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:

14
include/boost/regex/v4/basic_regex_parser.hpp
View File

@ -669,8 +669,8 @@ bool basic_regex_parser<charT, traits>::parse_extended_escape()
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;
@ -1383,8 +1383,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))
@ -2492,9 +2492,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;

8
include/boost/regex/v4/perl_matcher_non_recursive.hpp
View File

@ -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:
@ -1434,7 +1434,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 +1447,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);

6
include/boost/regex/v4/regex_format.hpp
View File

@ -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 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