* with MSVC and the /Zc:wchar_t option we place some extra unsigned short versions

* of the non-inline functions in the library, so that users can still link to the lib,

* irrespective of whether their own code is built with /Zc:wchar_t.

*/

# define BOOST_REGEX_HAS_OTHER_WCHAR_T

# ifdef BOOST_MSVC

# pragma warning(push)

# endif

# if defined(_DLL) && defined(BOOST_MSVC) && (BOOST_MSVC < 1600)

# include <string>

****************************************************************************/

#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1200) && defined(_MSC_EXTENSIONS)

# define BOOST_REGEX_CALL __cdecl

#else

# define BOOST_REGEX_CALL __fastcall

const boost::mpl::int_<1>*)

{

typedef boost::u8_to_u32_iterator<InputIterator, UChar32> conv_type;

}

template <class InputIterator>

const boost::mpl::int_<2>*)

{

typedef boost::u16_to_u32_iterator<InputIterator, UChar32> conv_type;

}

template <class InputIterator>

typedef boost::u8_to_u32_iterator<InputIterator, UChar32> conv_type;

typedef std::vector<UChar32> vector_type;

vector_type v;

while(a != b)

{

v.push_back(*a);

typedef boost::u16_to_u32_iterator<InputIterator, UChar32> conv_type;

typedef std::vector<UChar32> vector_type;

vector_type v;

while(a != b)

{

v.push_back(*a);

typedef match_results<conv_type> match_type;

typedef typename match_type::allocator_type alloc_type;

match_type what;

// copy results across to m:

if(result) copy_results(m, what);

return result;

typedef match_results<conv_type> match_type;

typedef typename match_type::allocator_type alloc_type;

match_type what;

// copy results across to m:

if(result) copy_results(m, what);

return result;

typedef match_results<conv_type> match_type;

typedef typename match_type::allocator_type alloc_type;

match_type what;

// copy results across to m:

if(result) copy_results(m, what);

return result;

typedef match_results<conv_type> match_type;

typedef typename match_type::allocator_type alloc_type;

match_type what;

// copy results across to m:

if(result) copy_results(m, what);

return result;

inline std::pair< boost::u8_to_u32_iterator<I>, boost::u8_to_u32_iterator<I> >

make_utf32_seq(I i, I j, mpl::int_<1> const*)

{

}

template <class I>

inline std::pair< boost::u16_to_u32_iterator<I>, boost::u16_to_u32_iterator<I> >

make_utf32_seq(I i, I j, mpl::int_<2> const*)

{

}

template <class I>

inline std::pair< I, I >

inline std::pair< boost::u8_to_u32_iterator<const charT*>, boost::u8_to_u32_iterator<const charT*> >

make_utf32_seq(const charT* p, mpl::int_<1> const*)

{

}

template <class charT>

inline std::pair< boost::u16_to_u32_iterator<const charT*>, boost::u16_to_u32_iterator<const charT*> >

make_utf32_seq(const charT* p, mpl::int_<2> const*)

{

}

template <class charT>

inline std::pair< const charT*, const charT* >

// for now just throw, but we should never really get here...

//

::boost::throw_exception(std::runtime_error("Error in thread safety code: could not acquire a lock"));

return boost::shared_ptr<Object>();

#endif

#else

--s;

}

else

}

BOOST_ASSERT(s_data.index[k]->first.get() == result.get());

BOOST_ASSERT(&(s_data.index.find(k)->first) == s_data.cont.back().second);

inline bool is_high_surrogate(::boost::uint16_t v)

{

}

inline bool is_low_surrogate(::boost::uint16_t v)

{

}

template <class T>

inline bool is_surrogate(T v)

{

}

inline unsigned utf8_byte_count(boost::uint8_t c)

return utf8_byte_count(c) - 1;

}

inline void invalid_utf32_code_point(::boost::uint32_t val)

{

#ifndef BOOST_NO_STD_LOCALE

#endif

boost::throw_exception(e);

}

} // namespace detail

{

m_value = pending_read;

}

private:

static void invalid_code_point(::boost::uint16_t val)

{

while((*--m_position & 0xC0u) == 0x80u) ++count;

// now check that the sequence was valid:

if(count != detail::utf8_trailing_byte_count(*m_position))

m_value = pending_read;

}

BaseIterator base()const

{

m_value = pending_read;

}

private:

{

std::out_of_range e("Invalid UTF-8 sequence encountered while trying to encode UTF-32 character");

boost::throw_exception(e);

m_value = static_cast<U32Type>(static_cast< ::boost::uint8_t>(*m_position));

// we must not have a continuation character:

if((m_value & 0xC0u) == 0x80u)

// see how many extra byts we have:

unsigned extra = detail::utf8_trailing_byte_count(*m_position);

// extract the extra bits, 6 from each extra byte:

m_value &= masks[extra];

// check the result:

if(m_value > static_cast<U32Type>(0x10FFFFu))

}

BaseIterator m_position;

mutable U32Type m_value;

// define this if you want to enable support for Unicode via ICU.

// #define BOOST_HAS_ICU

/*

*

*

* Distributed under the Boost Software License, Version 1.0.

* (See accompanying file LICENSE_1_0.txt or copy at

namespace boost{

#ifdef BOOST_MSVC

#pragma warning(push)

#endif

namespace re_detail{

std::pair<const_iterator, const_iterator> BOOST_REGEX_CALL subexpression(std::size_t n)const

{

if(n == 0)

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;

// begin, end:

const_iterator BOOST_REGEX_CALL begin()const

{

}

const_iterator BOOST_REGEX_CALL end()const

{

}

flag_type BOOST_REGEX_CALL flags()const

{

typedef typename traits::string_type seq_type;

seq_type a(arg_first, arg_last);

if(a.size())

else

assign(static_cast<const charT*>(0), static_cast<const charT*>(0), f);

}

std::pair<const_iterator, const_iterator> BOOST_REGEX_CALL subexpression(std::size_t n)const

{

if(!m_pimpl.get())

return m_pimpl->subexpression(n);

}

const_iterator BOOST_REGEX_CALL begin()const

public:

typedef digraph<charT> digraph_type;

typedef typename traits::string_type string_type;

basic_char_set()

{

}

m_empty = false;

}

{

m_classes |= m;

m_empty = false;

}

{

m_negated_classes |= m;

m_empty = false;

{

return m_equivalents.end();

}

{

return m_classes;

}

{

return m_negated_classes;

}

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

bool m_empty; // whether we've added anything yet

std::vector<digraph_type> m_equivalents; // a list of equivalence classes

};

unsigned m_backrefs; // bitmask of permitted backrefs

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

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

{

typedef typename traits::string_type string_type;

typedef typename basic_char_set<charT, traits>::list_iterator item_iterator;

//

// fill in the basics:

//

//

// finally reset the address of our last state:

//

return result;

}

template<class T>

inline bool char_less(T t1, T t2)

{

return t1 < t2;

}

{

return static_cast<unsigned char>(t1) < static_cast<unsigned 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(

}

else

{

{

// Oops error:

return 0;

//

// and now the classes:

//

if(flags() & regbase::icase)

{

// adjust m as needed:

m_pdata->m_can_be_null = 0;

m_bad_repeats = 0;

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);

state = state->next.p;

}

}

// now work through our list, building all the maps as we go:

while(v.size())

{

const std::pair<bool, re_syntax_base*>& p = v.back();

m_icase = p.first;

state = p.second;

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;

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);

template <class charT, class traits>

int basic_regex_creator<charT, traits>::calculate_backstep(re_syntax_base* state)

{

int result = 0;

while(state)

{

state = rep->alt.p;

continue;

}

{

BOOST_ASSERT(rep->next.p->type == syntax_element_long_set);

return -1;

if(rep->max != rep->min)

return -1;

}

return -1;

case syntax_element_long_set:

return -1;

result += 1;

break;

if(l_map)

{

l_map[0] |= mask_init;

l_map[0x85] |= mask;

}

// now figure out if we can match a NULL string at this point:

}

case syntax_element_recurse:

{

{

// Infinite recursion!!

if(0 == this->m_pdata->m_status) // update the error code if not already set

recursion_start = state;

recursion_restart = state->next.p;

state = static_cast<re_jump*>(state)->alt.p;

break;

}

// fall through, can't handle nested recursion here...

}

case syntax_element_backref:

case syntax_element_long_set:

if(l_map)

{

{

l_map[0] |= mask_init;

for(unsigned int i = 0; i < (1u << CHAR_BIT); ++i)

{

charT c = static_cast<charT>(i);

l_map[i] |= mask;

}

}

if(l_map)

{

l_map[0] |= mask_init;

}

if(pnull)

*pnull |= mask;

re_syntax_base* p = m_pdata->m_first_state;

while(p)

{

{

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

template <class charT, class traits>

syntax_element_type basic_regex_creator<charT, traits>::get_repeat_type(re_syntax_base* state)

{

if(state->type == syntax_element_rep)

{

// check to see if we are repeating a single state:

case re_detail::syntax_element_set:

return re_detail::syntax_element_short_set_rep;

case re_detail::syntax_element_long_set:

return re_detail::syntax_element_long_set_rep;

break;

default:

this->m_pdata->m_status = error_code;

m_position = m_end; // don't bother parsing anything else

//

// Augment error message with the regular expression text:

//

if(error_code != regex_constants::error_empty)

{

if((start_pos != 0) || (end_pos != (m_end - m_base)))

else

if(start_pos != end_pos)

{

message += std::string(m_base + start_pos, m_base + position);

}

message += "'.";

}

#ifndef BOOST_NO_EXCEPTIONS

if(0 == (this->flags() & regex_constants::no_except))

bool basic_regex_parser<charT, traits>::parse_extended_escape()

{

++m_position;

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_class:

{

escape_type_class_jump:

if(m != 0)

{

basic_char_set<charT, traits> char_set;

++m_position;

}

// for perl regexes only check for pocessive ++ repeats.

&& (this->m_traits.syntax_type(*m_position) == regex_constants::syntax_plus))

{

pocessive = true;

{

//

// Check for illegal following quantifier, we have to do this here, because

//

switch(this->m_traits.syntax_type(*m_position))

{

case regex_constants::syntax_star:

case regex_constants::syntax_plus:

case regex_constants::syntax_question:

fail(regex_constants::error_badrepeat, m_position - m_base);

return false;

}

++name_first;

negated = true;

}

if(m == 0)

{

if(char_set.empty() && (name_last - name_first == 1))

return false;

}

v = this->m_traits.toi(m_position, m_end, 10);

if(*m_position == charT('R'))

{

if(++m_position == m_end)

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);

{

// Rewind to start of (? sequence:

--m_position;

while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;

}

}

while(!breakout);

if(*m_position == static_cast<charT>('-'))

{

/*

*

*

* Use, modification and distribution are subject to the

* Boost Software License, Version 1.0. (See accompanying file

// however at least one std lib will always throw

// std::bad_alloc for certain arguments...

//

try{

//

// What we do here depends upon the format of the sort key returned by

// sort key returned by this->transform:

result.erase(i);

break;

}

}catch(...){}

while(result.size() && (charT(0) == *result.rbegin()))

result.erase(result.size() - 1);

if(result.empty())

// std::bad_alloc for certain arguments...

//

string_type result;

try{

result = this->m_pcollate->transform(p1, p2);

//

// Borland's STLPort version returns a NULL-terminated

result.erase(result.size() - 1);

#endif

BOOST_ASSERT(std::find(result.begin(), result.end(), charT(0)) == result.end());

}

catch(...)

{

}

return result;

}

# ifdef BOOST_MSVC

# pragma warning(push)

# endif

template class BOOST_REGEX_TEMPLATE_DECL basic_regex< BOOST_REGEX_CHAR_T BOOST_REGEX_TRAITS_T >;

namespace boost{

#ifdef BOOST_MSVC

#pragma warning(push)

#endif

namespace re_detail{

#ifdef BOOST_MSVC

#pragma warning(push)

#endif

template <class BidiIterator, class Allocator, class traits>

#ifdef __BORLANDC__

#pragma option push -w-8008 -w-8066 -w-8004

#endif

const re_repeat* rep = static_cast<const re_repeat*>(pstate);

std::size_t count = 0;

//

// start by working out how much we can skip:

template <class BidiIterator, class Allocator, class traits>

bool perl_matcher<BidiIterator, Allocator, traits>::unwind_long_set_repeat(bool r)

{

saved_single_repeat<BidiIterator>* pmp = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);

// if we have a match, just discard this state:

const re_repeat* rep = pmp->rep;

std::size_t count = pmp->count;

pstate = rep->next.p;

position = pmp->last_position;

BOOST_ASSERT(rep->type == syntax_element_long_set_rep);

}

inline int toi(ForwardIter& i, ForwardIter j, int base)

{

typedef typename boost::is_convertible<ForwardIter, const char_type*&>::type tag_type;

return toi(i, j, base, tag_type());

}

const traits& m_traits; // the traits class for localised formatting operations

BOOST_MPL_HAS_XXX_TRAIT_DEF(const_iterator)

typedef char no_type;

typedef char (&unary_type)[2];

typedef char (&binary_type)[3];

// flags |= match_prev_avail;

BidirectionalIterator next_start = what[0].second;

match_flag_type f(flags);

f |= regex_constants::match_not_initial_null;

//if(base != next_start)

// f |= regex_constants::match_not_bob;

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)

{

}

#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;

}

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)

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;

}

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)

{