-/*

- *

- * Copyright (c) 1998-2004

- * John Maddock

- *

- * Distributed under 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 basic_regex.cpp

- * VERSION see <boost/version.hpp>

- * DESCRIPTION: Declares template class basic_regex.

- */

-

-#ifndef BOOST_REGEX_V4_BASIC_REGEX_HPP

-#define BOOST_REGEX_V4_BASIC_REGEX_HPP

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_PREFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-namespace boost{

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable : 4251 4231 4660 4800)

-#endif

-

-namespace re_detail{

-

-//

-// forward declaration, we will need this one later:

-//

-template <class charT, class traits>

-class basic_regex_parser;

-

-//

-// class regex_data:

-// represents the data we wish to expose to the matching algorithms.

-//

-template <class charT, class traits>

-struct regex_data

-{

- typedef regex_constants::syntax_option_type flag_type;

- typedef std::size_t size_type;

-

- regex_data(const ::boost::shared_ptr<

- ::boost::regex_traits_wrapper<traits> >& t)

- : m_ptraits(t), m_expression(0), m_expression_len(0) {}

- regex_data()

- : m_ptraits(new ::boost::regex_traits_wrapper<traits>()), m_expression(0), m_expression_len(0) {}

-

- ::boost::shared_ptr<

- ::boost::regex_traits_wrapper<traits>

- > m_ptraits; // traits class instance

- flag_type m_flags; // flags with which we were compiled

- int m_status; // error code (0 implies OK).

- const charT* m_expression; // the original expression

- std::ptrdiff_t m_expression_len; // the length of the original expression

- size_type m_mark_count; // the number of marked sub-expressions

- re_detail::re_syntax_base* m_first_state; // the first state of the machine

- unsigned m_restart_type; // search optimisation type

- unsigned char m_startmap[1 << CHAR_BIT]; // which characters can start a match

- unsigned int m_can_be_null; // whether we can match a null string

- re_detail::raw_storage m_data; // the buffer in which our states are constructed

- typename traits::char_class_type m_word_mask; // mask used to determine if a character is a word character

- std::vector<

- std::pair<

- std::size_t, std::size_t> > m_subs; // Position of sub-expressions within the *string*.

-};

-//

-// class basic_regex_implementation

-// pimpl implementation class for basic_regex.

-//

-template <class charT, class traits>

-class basic_regex_implementation

- : public regex_data<charT, traits>

-{

-public:

- typedef regex_constants::syntax_option_type flag_type;

- typedef std::ptrdiff_t difference_type;

- typedef std::size_t size_type;

- typedef typename traits::locale_type locale_type;

- typedef const charT* const_iterator;

-

- basic_regex_implementation(){}

- basic_regex_implementation(const ::boost::shared_ptr<

- ::boost::regex_traits_wrapper<traits> >& t)

- : regex_data<charT, traits>(t) {}

- void assign(const charT* arg_first,

- const charT* arg_last,

- flag_type f)

- {

- regex_data<charT, traits>* pdat = this;

- basic_regex_parser<charT, traits> parser(pdat);

- parser.parse(arg_first, arg_last, f);

- }

-

- locale_type BOOST_REGEX_CALL imbue(locale_type l)

- {

- return this->m_ptraits->imbue(l);

- }

- locale_type BOOST_REGEX_CALL getloc()const

- {

- return this->m_ptraits->getloc();

- }

- std::basic_string<charT> BOOST_REGEX_CALL str()const

- {

- std::basic_string<charT> result;

- if(this->m_status == 0)

- result = std::basic_string<charT>(this->m_expression, this->m_expression_len);

- return result;

- }

- const_iterator BOOST_REGEX_CALL expression()const

- {

- return this->m_expression;

- }

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

- 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

- {

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

- }

- flag_type BOOST_REGEX_CALL flags()const

- {

- return this->m_flags;

- }

- size_type BOOST_REGEX_CALL size()const

- {

- return this->m_expression_len;

- }

- int BOOST_REGEX_CALL status()const

- {

- return this->m_status;

- }

- size_type BOOST_REGEX_CALL mark_count()const

- {

- return this->m_mark_count;

- }

- const re_detail::re_syntax_base* get_first_state()const

- {

- return this->m_first_state;

- }

- unsigned get_restart_type()const

- {

- return this->m_restart_type;

- }

- const unsigned char* get_map()const

- {

- return this->m_startmap;

- }

- const ::boost::regex_traits_wrapper<traits>& get_traits()const

- {

- return *(this->m_ptraits);

- }

- bool can_be_null()const

- {

- return this->m_can_be_null;

- }

- const regex_data<charT, traits>& get_data()const

- {

- basic_regex_implementation<charT, traits> const* p = this;

- return *static_cast<const regex_data<charT, traits>*>(p);

- }

-};

-

-} // namespace re_detail

-//

-// class basic_regex:

-// represents the compiled

-// regular expression:

-//

-

-#ifdef BOOST_REGEX_NO_FWD

-template <class charT, class traits = regex_traits<charT> >

-#else

-template <class charT, class traits >

-#endif

-class basic_regex : public regbase

-{

-public:

- // typedefs:

- typedef std::size_t traits_size_type;

- typedef typename traits::string_type traits_string_type;

- typedef charT char_type;

- typedef traits traits_type;

-

- typedef charT value_type;

- typedef charT& reference;

- typedef const charT& const_reference;

- typedef const charT* const_iterator;

- typedef const_iterator iterator;

- typedef std::ptrdiff_t difference_type;

- typedef std::size_t size_type;

- typedef regex_constants::syntax_option_type flag_type;

- // locale_type

- // placeholder for actual locale type used by the

- // traits class to localise *this.

- typedef typename traits::locale_type locale_type;

-

-public:

- explicit basic_regex(){}

- explicit basic_regex(const charT* p, flag_type f = regex_constants::normal)

- {

- assign(p, f);

- }

- basic_regex(const charT* p1, const charT* p2, flag_type f = regex_constants::normal)

- {

- assign(p1, p2, f);

- }

- basic_regex(const charT* p, size_type len, flag_type f)

- {

- assign(p, len, f);

- }

- basic_regex(const basic_regex& that)

- : m_pimpl(that.m_pimpl) {}

- ~basic_regex(){}

- basic_regex& BOOST_REGEX_CALL operator=(const basic_regex& that)

- {

- return assign(that);

- }

- basic_regex& BOOST_REGEX_CALL operator=(const charT* ptr)

- {

- return assign(ptr);

- }

-

- //

- // assign:

- basic_regex& assign(const basic_regex& that)

- {

- m_pimpl = that.m_pimpl;

- return *this;

- }

- basic_regex& assign(const charT* p, flag_type f = regex_constants::normal)

- {

- return assign(p, p + traits::length(p), f);

- }

- basic_regex& assign(const charT* p, size_type len, flag_type f)

- {

- return assign(p, p + len, f);

- }

-private:

- basic_regex& do_assign(const charT* p1,

- const charT* p2,

- flag_type f);

-public:

- basic_regex& assign(const charT* p1,

- const charT* p2,

- flag_type f = regex_constants::normal)

- {

- return do_assign(p1, p2, f);

- }

-#if !defined(BOOST_NO_MEMBER_TEMPLATES)

-

- template <class ST, class SA>

- unsigned int BOOST_REGEX_CALL set_expression(const std::basic_string<charT, ST, SA>& p, flag_type f = regex_constants::normal)

- {

- return set_expression(p.data(), p.data() + p.size(), f);

- }

-

- template <class ST, class SA>

- explicit basic_regex(const std::basic_string<charT, ST, SA>& p, flag_type f = regex_constants::normal)

- {

- assign(p, f);

- }

-

- template <class InputIterator>

- basic_regex(InputIterator arg_first, InputIterator arg_last, flag_type f = regex_constants::normal)

- {

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

- else

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

- }

-

- template <class ST, class SA>

- basic_regex& BOOST_REGEX_CALL operator=(const std::basic_string<charT, ST, SA>& p)

- {

- return assign(p.data(), p.data() + p.size(), regex_constants::normal);

- }

-

- template <class string_traits, class A>

- basic_regex& BOOST_REGEX_CALL assign(

- const std::basic_string<charT, string_traits, A>& s,

- flag_type f = regex_constants::normal)

- {

- return assign(s.data(), s.data() + s.size(), f);

- }

-

- template <class InputIterator>

- basic_regex& BOOST_REGEX_CALL assign(InputIterator arg_first,

- InputIterator arg_last,

- flag_type f = regex_constants::normal)

- {

- typedef typename traits::string_type seq_type;

- seq_type a(arg_first, arg_last);

- if(a.size())

- {

- const charT* p1 = &*a.begin();

- const charT* p2 = &*a.begin() + a.size();

- return assign(p1, p2, f);

- }

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

- }

-#else

- unsigned int BOOST_REGEX_CALL set_expression(const std::basic_string<charT>& p, flag_type f = regex_constants::normal)

- {

- return set_expression(p.data(), p.data() + p.size(), f);

- }

-

- basic_regex(const std::basic_string<charT>& p, flag_type f = regex_constants::normal)

- {

- assign(p, f);

- }

-

- basic_regex& BOOST_REGEX_CALL operator=(const std::basic_string<charT>& p)

- {

- return assign(p.data(), p.data() + p.size(), regex_constants::normal);

- }

-

- basic_regex& BOOST_REGEX_CALL assign(

- const std::basic_string<charT>& s,

- flag_type f = regex_constants::normal)

- {

- return assign(s.data(), s.data() + s.size(), f);

- }

-

-#endif

-

- //

- // locale:

- locale_type BOOST_REGEX_CALL imbue(locale_type l);

- locale_type BOOST_REGEX_CALL getloc()const

- {

- return m_pimpl.get() ? m_pimpl->getloc() : locale_type();

- }

- //

- // getflags:

- // retained for backwards compatibility only, "flags"

- // is now the preferred name:

- flag_type BOOST_REGEX_CALL getflags()const

- {

- return flags();

- }

- flag_type BOOST_REGEX_CALL flags()const

- {

- return m_pimpl.get() ? m_pimpl->flags() : 0;

- }

- //

- // str:

- std::basic_string<charT> BOOST_REGEX_CALL str()const

- {

- return m_pimpl.get() ? m_pimpl->str() : std::basic_string<charT>();

- }

- //

- // begin, end, subexpression:

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

- return m_pimpl->subexpression(n);

- }

- const_iterator BOOST_REGEX_CALL begin()const

- {

- return (m_pimpl.get() ? m_pimpl->begin() : 0);

- }

- const_iterator BOOST_REGEX_CALL end()const

- {

- return (m_pimpl.get() ? m_pimpl->end() : 0);

- }

- //

- // swap:

- void BOOST_REGEX_CALL swap(basic_regex& that)throw()

- {

- m_pimpl.swap(that.m_pimpl);

- }

- //

- // size:

- size_type BOOST_REGEX_CALL size()const

- {

- return (m_pimpl.get() ? m_pimpl->size() : 0);

- }

- //

- // max_size:

- size_type BOOST_REGEX_CALL max_size()const

- {

- return UINT_MAX;

- }

- //

- // empty:

- bool BOOST_REGEX_CALL empty()const

- {

- return (m_pimpl.get() ? 0 != m_pimpl->status() : true);

- }

-

- size_type BOOST_REGEX_CALL mark_count()const

- {

- return (m_pimpl.get() ? m_pimpl->mark_count() : 0);

- }

-

- int status()const

- {

- return (m_pimpl.get() ? m_pimpl->status() : regex_constants::error_empty);

- }

-

- int BOOST_REGEX_CALL compare(const basic_regex& that) const

- {

- if(m_pimpl.get() == that.m_pimpl.get())

- return 0;

- if(!m_pimpl.get())

- return -1;

- if(!that.m_pimpl.get())

- return 1;

- if(status() != that.status())

- return status() - that.status();

- if(flags() != that.flags())

- return flags() - that.flags();

- return str().compare(that.str());

- }

- bool BOOST_REGEX_CALL operator==(const basic_regex& e)const

- {

- return compare(e) == 0;

- }

- bool BOOST_REGEX_CALL operator != (const basic_regex& e)const

- {

- return compare(e) != 0;

- }

- bool BOOST_REGEX_CALL operator<(const basic_regex& e)const

- {

- return compare(e) < 0;

- }

- bool BOOST_REGEX_CALL operator>(const basic_regex& e)const

- {

- return compare(e) > 0;

- }

- bool BOOST_REGEX_CALL operator<=(const basic_regex& e)const

- {

- return compare(e) <= 0;

- }

- bool BOOST_REGEX_CALL operator>=(const basic_regex& e)const

- {

- return compare(e) >= 0;

- }

-

- //

- // The following are deprecated as public interfaces

- // but are available for compatibility with earlier versions.

- const charT* BOOST_REGEX_CALL expression()const

- {

- return (m_pimpl.get() && !m_pimpl->status() ? m_pimpl->expression() : 0);

- }

- unsigned int BOOST_REGEX_CALL set_expression(const charT* p1, const charT* p2, flag_type f = regex_constants::normal)

- {

- assign(p1, p2, f | regex_constants::no_except);

- return status();

- }

- unsigned int BOOST_REGEX_CALL set_expression(const charT* p, flag_type f = regex_constants::normal)

- {

- assign(p, f | regex_constants::no_except);

- return status();

- }

- unsigned int BOOST_REGEX_CALL error_code()const

- {

- return status();

- }

- //

- // private access methods:

- //

- const re_detail::re_syntax_base* get_first_state()const

- {

- BOOST_ASSERT(0 != m_pimpl.get());

- return m_pimpl->get_first_state();

- }

- unsigned get_restart_type()const

- {

- BOOST_ASSERT(0 != m_pimpl.get());

- return m_pimpl->get_restart_type();

- }

- const unsigned char* get_map()const

- {

- BOOST_ASSERT(0 != m_pimpl.get());

- return m_pimpl->get_map();

- }

- const ::boost::regex_traits_wrapper<traits>& get_traits()const

- {

- BOOST_ASSERT(0 != m_pimpl.get());

- return m_pimpl->get_traits();

- }

- bool can_be_null()const

- {

- BOOST_ASSERT(0 != m_pimpl.get());

- return m_pimpl->can_be_null();

- }

- const re_detail::regex_data<charT, traits>& get_data()const

- {

- BOOST_ASSERT(0 != m_pimpl.get());

- return m_pimpl->get_data();

- }

-

-private:

- shared_ptr<re_detail::basic_regex_implementation<charT, traits> > m_pimpl;

-};

-

-//

-// out of line members;

-// these are the only members that mutate the basic_regex object,

-// and are designed to provide the strong exception guarentee

-// (in the event of a throw, the state of the object remains unchanged).

-//

-template <class charT, class traits>

-basic_regex<charT, traits>& basic_regex<charT, traits>::do_assign(const charT* p1,

- const charT* p2,

- flag_type f)

-{

- shared_ptr<re_detail::basic_regex_implementation<charT, traits> > temp;

- if(!m_pimpl.get())

- {

- temp = shared_ptr<re_detail::basic_regex_implementation<charT, traits> >(new re_detail::basic_regex_implementation<charT, traits>());

- }

- else

- {

- temp = shared_ptr<re_detail::basic_regex_implementation<charT, traits> >(new re_detail::basic_regex_implementation<charT, traits>(m_pimpl->m_ptraits));

- }

- temp->assign(p1, p2, f);

- temp.swap(m_pimpl);

- return *this;

-}

-

-template <class charT, class traits>

-typename basic_regex<charT, traits>::locale_type BOOST_REGEX_CALL basic_regex<charT, traits>::imbue(locale_type l)

-{

- shared_ptr<re_detail::basic_regex_implementation<charT, traits> > temp(new re_detail::basic_regex_implementation<charT, traits>());

- locale_type result = temp->imbue(l);

- temp.swap(m_pimpl);

- return result;

-}

-

-//

-// non-members:

-//

-template <class charT, class traits>

-void swap(basic_regex<charT, traits>& e1, basic_regex<charT, traits>& e2)

-{

- e1.swap(e2);

-}

-

-#ifndef BOOST_NO_STD_LOCALE

-template <class charT, class traits, class traits2>

-std::basic_ostream<charT, traits>&

- operator << (std::basic_ostream<charT, traits>& os,

- const basic_regex<charT, traits2>& e)

-{

- return (os << e.str());

-}

-#else

-template <class traits>

-std::ostream& operator << (std::ostream& os, const basic_regex<char, traits>& e)

-{

- return (os << e.str());

-}

-#endif

-

-//

-// class reg_expression:

-// this is provided for backwards compatibility only,

-// it is deprecated, no not use!

-//

-#ifdef BOOST_REGEX_NO_FWD

-template <class charT, class traits = regex_traits<charT> >

-#else

-template <class charT, class traits >

-#endif

-class reg_expression : public basic_regex<charT, traits>

-{

-public:

- typedef typename basic_regex<charT, traits>::flag_type flag_type;

- typedef typename basic_regex<charT, traits>::size_type size_type;

- explicit reg_expression(){}

- explicit reg_expression(const charT* p, flag_type f = regex_constants::normal)

- : basic_regex<charT, traits>(p, f){}

- reg_expression(const charT* p1, const charT* p2, flag_type f = regex_constants::normal)

- : basic_regex<charT, traits>(p1, p2, f){}

- reg_expression(const charT* p, size_type len, flag_type f)

- : basic_regex<charT, traits>(p, len, f){}

- reg_expression(const reg_expression& that)

- : basic_regex<charT, traits>(that) {}

- ~reg_expression(){}

- reg_expression& BOOST_REGEX_CALL operator=(const reg_expression& that)

- {

- return this->assign(that);

- }

-

-#if !defined(BOOST_NO_MEMBER_TEMPLATES)

- template <class ST, class SA>

- explicit reg_expression(const std::basic_string<charT, ST, SA>& p, flag_type f = regex_constants::normal)

- : basic_regex<charT, traits>(p, f)

- {

- }

-

- template <class InputIterator>

- reg_expression(InputIterator arg_first, InputIterator arg_last, flag_type f = regex_constants::normal)

- : basic_regex<charT, traits>(arg_first, arg_last, f)

- {

- }

-

- template <class ST, class SA>

- reg_expression& BOOST_REGEX_CALL operator=(const std::basic_string<charT, ST, SA>& p)

- {

- this->assign(p);

- return *this;

- }

-#else

- explicit reg_expression(const std::basic_string<charT>& p, flag_type f = regex_constants::normal)

- : basic_regex<charT, traits>(p, f)

- {

- }

-

- reg_expression& BOOST_REGEX_CALL operator=(const std::basic_string<charT>& p)

- {

- this->assign(p);

- return *this;

- }

-#endif

-

-};

-

-#ifdef BOOST_MSVC

-#pragma warning (pop)

-#endif

-

-} // namespace boost

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_SUFFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-#endif

-

-/*

- *

- * Copyright (c) 2004

- * John Maddock

- *

- * 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 basic_regex_creator.cpp

- * VERSION see <boost/version.hpp>

- * DESCRIPTION: Declares template class basic_regex_creator which fills in

- * the data members of a regex_data object.

- */

-

-#ifndef BOOST_REGEX_V4_BASIC_REGEX_CREATOR_HPP

-#define BOOST_REGEX_V4_BASIC_REGEX_CREATOR_HPP

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_PREFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-#ifdef BOOST_MSVC

-# pragma warning(push)

-# pragma warning(disable: 4800)

-#endif

-

-namespace boost{

-

-namespace re_detail{

-

-template <class charT>

-struct digraph : public std::pair<charT, charT>

-{

- digraph() : std::pair<charT, charT>(0, 0){}

- digraph(charT c1) : std::pair<charT, charT>(c1, 0){}

- digraph(charT c1, charT c2) : std::pair<charT, charT>(c1, c2)

- {}

-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)

- digraph(const digraph<charT>& d) : std::pair<charT, charT>(d.first, d.second){}

-#endif

- template <class Seq>

- digraph(const Seq& s) : std::pair<charT, charT>()

- {

- BOOST_ASSERT(s.size() <= 2);

- BOOST_ASSERT(s.size());

- this->first = s[0];

- this->second = (s.size() > 1) ? s[1] : 0;

- }

-};

-

-template <class charT, class traits>

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

-

- basic_char_set()

- {

- m_negate = false;

- m_has_digraphs = false;

- m_classes = 0;

- m_negated_classes = 0;

- m_empty = true;

- }

-

- void add_single(const digraph_type& s)

- {

- m_singles.insert(m_singles.end(), s);

- if(s.second)

- m_has_digraphs = true;

- m_empty = false;

- }

- void add_range(const digraph_type& first, const digraph_type& end)

- {

- m_ranges.insert(m_ranges.end(), first);

- m_ranges.insert(m_ranges.end(), end);

- if(first.second)

- {

- m_has_digraphs = true;

- add_single(first);

- }

- if(end.second)

- {

- m_has_digraphs = true;

- add_single(end);

- }

- m_empty = false;

- }

- void add_class(mask_type m)

- {

- m_classes |= m;

- m_empty = false;

- }

- void add_negated_class(mask_type m)

- {

- m_negated_classes |= m;

- m_empty = false;

- }

- void add_equivalent(const digraph_type& s)

- {

- m_equivalents.insert(m_equivalents.end(), s);

- if(s.second)

- {

- m_has_digraphs = true;

- add_single(s);

- }

- m_empty = false;

- }

- void negate()

- {

- m_negate = true;

- //m_empty = false;

- }

-

- //

- // accessor functions:

- //

- bool has_digraphs()const

- {

- return m_has_digraphs;

- }

- bool is_negated()const

- {

- return m_negate;

- }

- typedef typename std::vector<digraph_type>::const_iterator list_iterator;

- list_iterator singles_begin()const

- {

- return m_singles.begin();

- }

- list_iterator singles_end()const

- {

- return m_singles.end();

- }

- list_iterator ranges_begin()const

- {

- return m_ranges.begin();

- }

- list_iterator ranges_end()const

- {

- return m_ranges.end();

- }

- list_iterator equivalents_begin()const

- {

- return m_equivalents.begin();

- }

- list_iterator equivalents_end()const

- {

- return m_equivalents.end();

- }

- mask_type classes()const

- {

- return m_classes;

- }

- mask_type negated_classes()const

- {

- return m_negated_classes;

- }

- bool empty()const

- {

- return m_empty;

- }

-private:

- std::vector<digraph_type> m_singles; // a list of single characters to match

- 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

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

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

-};

-

-template <class charT, class traits>

-class basic_regex_creator

-{

-public:

- basic_regex_creator(regex_data<charT, traits>* data);

- std::ptrdiff_t getoffset(void* addr)

- {

- return getoffset(addr, m_pdata->m_data.data());

- }

- std::ptrdiff_t getoffset(const void* addr, const void* base)

- {

- return static_cast<const char*>(addr) - static_cast<const char*>(base);

- }

- re_syntax_base* getaddress(std::ptrdiff_t off)

- {

- return getaddress(off, m_pdata->m_data.data());

- }

- re_syntax_base* getaddress(std::ptrdiff_t off, void* base)

- {

- return static_cast<re_syntax_base*>(static_cast<void*>(static_cast<char*>(base) + off));

- }

- void init(unsigned l_flags)

- {

- m_pdata->m_flags = l_flags;

- m_icase = l_flags & regex_constants::icase;

- }

- regbase::flag_type flags()

- {

- return m_pdata->m_flags;

- }

- void flags(regbase::flag_type f)

- {

- m_pdata->m_flags = f;

- if(m_icase != static_cast<bool>(f & regbase::icase))

- {

- m_icase = static_cast<bool>(f & regbase::icase);

- }

- }

- re_syntax_base* append_state(syntax_element_type t, std::size_t s = sizeof(re_syntax_base));

- re_syntax_base* insert_state(std::ptrdiff_t pos, syntax_element_type t, std::size_t s = sizeof(re_syntax_base));

- re_literal* append_literal(charT c);

- re_syntax_base* append_set(const basic_char_set<charT, traits>& char_set);

- re_syntax_base* append_set(const basic_char_set<charT, traits>& char_set, mpl::false_*);

- re_syntax_base* append_set(const basic_char_set<charT, traits>& char_set, mpl::true_*);

- void finalize(const charT* p1, const charT* p2);

-protected:

- regex_data<charT, traits>* m_pdata; // pointer to the basic_regex_data struct we are filling in

- const ::boost::regex_traits_wrapper<traits>&

- m_traits; // convenience reference to traits class

- re_syntax_base* m_last_state; // the last state we added

- bool m_icase; // true for case insensitive matches

- unsigned m_repeater_id; // the state_id of the next repeater

- bool m_has_backrefs; // true if there are actually any backrefs

- unsigned m_backrefs; // bitmask of permitted backrefs

- boost::uintmax_t m_bad_repeats; // bitmask of repeats we can't deduce a startmap for;

- 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

- typename traits::char_class_type m_upper_mask; // mask used to determine if a character is an uppercase character

- typename traits::char_class_type m_alpha_mask; // mask used to determine if a character is an alphabetic character

-private:

- basic_regex_creator& operator=(const basic_regex_creator&);

- basic_regex_creator(const basic_regex_creator&);

-

- void fixup_pointers(re_syntax_base* state);

- void create_startmaps(re_syntax_base* state);

- int calculate_backstep(re_syntax_base* state);

- void create_startmap(re_syntax_base* state, unsigned char* l_map, unsigned int* pnull, unsigned char mask);

- unsigned get_restart_type(re_syntax_base* state);

- void set_all_masks(unsigned char* bits, unsigned char);

- bool is_bad_repeat(re_syntax_base* pt);

- void set_bad_repeat(re_syntax_base* pt);

- syntax_element_type get_repeat_type(re_syntax_base* state);

- void probe_leading_repeat(re_syntax_base* state);

-};

-

-template <class charT, class traits>

-basic_regex_creator<charT, traits>::basic_regex_creator(regex_data<charT, traits>* data)

- : m_pdata(data), m_traits(*(data->m_ptraits)), m_last_state(0), m_repeater_id(0), m_has_backrefs(false), m_backrefs(0)

-{

- m_pdata->m_data.clear();

- m_pdata->m_status = ::boost::regex_constants::error_ok;

- static const charT w = 'w';

- static const charT s = 's';

- static const charT l[5] = { 'l', 'o', 'w', 'e', 'r', };

- static const charT u[5] = { 'u', 'p', 'p', 'e', 'r', };

- static const charT a[5] = { 'a', 'l', 'p', 'h', 'a', };

- m_word_mask = m_traits.lookup_classname(&w, &w +1);

- m_mask_space = m_traits.lookup_classname(&s, &s +1);

- m_lower_mask = m_traits.lookup_classname(l, l + 5);

- m_upper_mask = m_traits.lookup_classname(u, u + 5);

- m_alpha_mask = m_traits.lookup_classname(a, a + 5);

- m_pdata->m_word_mask = m_word_mask;

- BOOST_ASSERT(m_word_mask != 0);

- BOOST_ASSERT(m_mask_space != 0);

- BOOST_ASSERT(m_lower_mask != 0);

- BOOST_ASSERT(m_upper_mask != 0);

- BOOST_ASSERT(m_alpha_mask != 0);

-}

-

-template <class charT, class traits>

-re_syntax_base* basic_regex_creator<charT, traits>::append_state(syntax_element_type t, std::size_t s)

-{

- // if the state is a backref then make a note of it:

- if(t == syntax_element_backref)

- this->m_has_backrefs = true;

- // append a new state, start by aligning our last one:

- m_pdata->m_data.align();

- // set the offset to the next state in our last one:

- if(m_last_state)

- m_last_state->next.i = m_pdata->m_data.size() - getoffset(m_last_state);

- // now actually extent our data:

- m_last_state = static_cast<re_syntax_base*>(m_pdata->m_data.extend(s));

- // fill in boilerplate options in the new state:

- m_last_state->next.i = 0;

- m_last_state->type = t;

- return m_last_state;

-}

-

-template <class charT, class traits>

-re_syntax_base* basic_regex_creator<charT, traits>::insert_state(std::ptrdiff_t pos, syntax_element_type t, std::size_t s)

-{

- // append a new state, start by aligning our last one:

- m_pdata->m_data.align();

- // set the offset to the next state in our last one:

- if(m_last_state)

- m_last_state->next.i = m_pdata->m_data.size() - getoffset(m_last_state);

- // remember the last state position:

- std::ptrdiff_t off = getoffset(m_last_state) + s;

- // now actually insert our data:

- re_syntax_base* new_state = static_cast<re_syntax_base*>(m_pdata->m_data.insert(pos, s));

- // fill in boilerplate options in the new state:

- new_state->next.i = s;

- new_state->type = t;

- m_last_state = getaddress(off);

- return new_state;

-}

-

-template <class charT, class traits>

-re_literal* basic_regex_creator<charT, traits>::append_literal(charT c)

-{

- re_literal* result;

- // start by seeing if we have an existing re_literal we can extend:

- if((0 == m_last_state) || (m_last_state->type != syntax_element_literal))

- {

- // no existing re_literal, create a new one:

- result = static_cast<re_literal*>(append_state(syntax_element_literal, sizeof(re_literal) + sizeof(charT)));

- result->length = 1;

- *static_cast<charT*>(static_cast<void*>(result+1)) = m_traits.translate(c, m_icase);

- }

- else

- {

- // we have an existing re_literal, extend it:

- std::ptrdiff_t off = getoffset(m_last_state);

- m_pdata->m_data.extend(sizeof(charT));

- m_last_state = result = static_cast<re_literal*>(getaddress(off));

- charT* characters = static_cast<charT*>(static_cast<void*>(result+1));

- characters[result->length] = m_traits.translate(c, m_icase);

- ++(result->length);

- }

- return result;

-}

-

-template <class charT, class traits>

-inline re_syntax_base* basic_regex_creator<charT, traits>::append_set(

- const basic_char_set<charT, traits>& char_set)

-{

- typedef mpl::bool_< (sizeof(charT) == 1) > truth_type;

- return char_set.has_digraphs()

- ? append_set(char_set, static_cast<mpl::false_*>(0))

- : append_set(char_set, static_cast<truth_type*>(0));

-}

-

-template <class charT, class traits>

-re_syntax_base* basic_regex_creator<charT, traits>::append_set(

- const basic_char_set<charT, traits>& char_set, mpl::false_*)

-{

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

-

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

- //

- // fill in the basics:

- //

- result->csingles = static_cast<unsigned int>(::boost::re_detail::distance(char_set.singles_begin(), char_set.singles_end()));

- result->cranges = static_cast<unsigned int>(::boost::re_detail::distance(char_set.ranges_begin(), char_set.ranges_end())) / 2;

- result->cequivalents = static_cast<unsigned int>(::boost::re_detail::distance(char_set.equivalents_begin(), char_set.equivalents_end()));

- result->cclasses = char_set.classes();

- result->cnclasses = char_set.negated_classes();

- if(flags() & regbase::icase)

- {

- // adjust classes as needed:

- if(((result->cclasses & m_lower_mask) == m_lower_mask) || ((result->cclasses & m_upper_mask) == m_upper_mask))

- result->cclasses |= m_alpha_mask;

- if(((result->cnclasses & m_lower_mask) == m_lower_mask) || ((result->cnclasses & m_upper_mask) == m_upper_mask))

- result->cnclasses |= m_alpha_mask;

- }

-

- result->isnot = char_set.is_negated();

- result->singleton = !char_set.has_digraphs();

- //

- // remember where the state is for later:

- //

- std::ptrdiff_t offset = getoffset(result);

- //

- // now extend with all the singles:

- //

- item_iterator first, last;

- first = char_set.singles_begin();

- last = char_set.singles_end();

- while(first != last)

- {

- charT* p = static_cast<charT*>(this->m_pdata->m_data.extend(sizeof(charT) * (first->second ? 3 : 2)));

- p[0] = m_traits.translate(first->first, m_icase);

- if(first->second)

- {

- p[1] = m_traits.translate(first->second, m_icase);

- p[2] = 0;

- }

- else

- p[1] = 0;

- ++first;

- }

- //

- // now extend with all the ranges:

- //

- first = char_set.ranges_begin();

- last = char_set.ranges_end();

- while(first != last)

- {

- // first grab the endpoints of the range:

- digraph<charT> c1 = *first;

- c1.first = this->m_traits.translate(c1.first, this->m_icase);

- c1.second = this->m_traits.translate(c1.second, this->m_icase);

- ++first;

- digraph<charT> c2 = *first;

- c2.first = this->m_traits.translate(c2.first, this->m_icase);

- c2.second = this->m_traits.translate(c2.second, this->m_icase);

- ++first;

- string_type s1, s2;

- // different actions now depending upon whether collation is turned on:

- if(flags() & regex_constants::collate)

- {

- // we need to transform our range into sort keys:

-#if BOOST_WORKAROUND(__GNUC__, < 3)

- string_type in(3, charT(0));

- in[0] = c1.first;

- in[1] = c1.second;

- s1 = this->m_traits.transform(in.c_str(), (in[1] ? in.c_str()+2 : in.c_str()+1));

- in[0] = c2.first;

- in[1] = c2.second;

- s2 = this->m_traits.transform(in.c_str(), (in[1] ? in.c_str()+2 : in.c_str()+1));

-#else

- charT a1[3] = { c1.first, c1.second, charT(0), };

- charT a2[3] = { c2.first, c2.second, charT(0), };

- s1 = this->m_traits.transform(a1, (a1[1] ? a1+2 : a1+1));

- s2 = this->m_traits.transform(a2, (a2[1] ? a2+2 : a2+1));

-#endif

- if(s1.size() == 0)

- s1 = string_type(1, charT(0));

- if(s2.size() == 0)

- s2 = string_type(1, charT(0));

- }

- else

- {

- if(c1.second)

- {

- s1.insert(s1.end(), c1.first);

- s1.insert(s1.end(), c1.second);

- }

- else

- s1 = string_type(1, c1.first);

- if(c2.second)

- {

- s2.insert(s2.end(), c2.first);

- s2.insert(s2.end(), c2.second);

- }

- else

- s2.insert(s2.end(), c2.first);

- }

- if(s1 > s2)

- {

- // Oops error:

- return 0;

- }

- charT* p = static_cast<charT*>(this->m_pdata->m_data.extend(sizeof(charT) * (s1.size() + s2.size() + 2) ) );

- re_detail::copy(s1.begin(), s1.end(), p);

- p[s1.size()] = charT(0);

- p += s1.size() + 1;

- re_detail::copy(s2.begin(), s2.end(), p);

- p[s2.size()] = charT(0);

- }

- //

- // now process the equivalence classes:

- //

- first = char_set.equivalents_begin();

- last = char_set.equivalents_end();

- while(first != last)

- {

- string_type s;

- if(first->second)

- {

-#if BOOST_WORKAROUND(__GNUC__, < 3)

- string_type in(3, charT(0));

- in[0] = first->first;

- in[1] = first->second;

- s = m_traits.transform_primary(in.c_str(), in.c_str()+2);

-#else

- charT cs[3] = { first->first, first->second, charT(0), };

- s = m_traits.transform_primary(cs, cs+2);

-#endif

- }

- else

- s = m_traits.transform_primary(&first->first, &first->first+1);

- if(s.empty())

- return 0; // invalid or unsupported equivalence class

- charT* p = static_cast<charT*>(this->m_pdata->m_data.extend(sizeof(charT) * (s.size()+1) ) );

- re_detail::copy(s.begin(), s.end(), p);

- p[s.size()] = charT(0);

- ++first;

- }

- //

- // finally reset the address of our last state:

- //

- m_last_state = result = static_cast<re_set_long<mask_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)

-{

- return static_cast<unsigned char>(t1) < static_cast<unsigned char>(t2);

-}

-template<>

-inline bool char_less<signed char>(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(

- const basic_char_set<charT, traits>& char_set, mpl::true_*)

-{

- typedef typename traits::string_type string_type;

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

-

- re_set* result = static_cast<re_set*>(append_state(syntax_element_set, sizeof(re_set)));

- bool negate = char_set.is_negated();

- std::memset(result->_map, 0, sizeof(result->_map));

- //

- // handle singles first:

- //

- item_iterator first, last;

- first = char_set.singles_begin();

- last = char_set.singles_end();

- while(first != last)

- {

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

- {

- if(this->m_traits.translate(static_cast<charT>(i), this->m_icase)

- == this->m_traits.translate(first->first, this->m_icase))

- result->_map[i] = true;

- }

- ++first;

- }

- //

- // OK now handle ranges:

- //

- first = char_set.ranges_begin();

- last = char_set.ranges_end();

- while(first != last)

- {

- // first grab the endpoints of the range:

- charT c1 = this->m_traits.translate(first->first, this->m_icase);

- ++first;

- charT c2 = this->m_traits.translate(first->first, this->m_icase);

- ++first;

- // different actions now depending upon whether collation is turned on:

- if(flags() & regex_constants::collate)

- {

- // we need to transform our range into sort keys:

- charT c3[2] = { c1, charT(0), };

- string_type s1 = this->m_traits.transform(c3, c3+1);

- c3[0] = c2;

- string_type s2 = this->m_traits.transform(c3, c3+1);

- if(s1 > s2)

- {

- // Oops error:

- return 0;

- }

- BOOST_ASSERT(c3[1] == charT(0));

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

- {

- c3[0] = static_cast<charT>(i);

- string_type s3 = this->m_traits.transform(c3, c3 +1);

- if((s1 <= s3) && (s3 <= s2))

- result->_map[i] = true;

- }

- }

- else

- {

- if(char_less<charT>(c2, c1))

- {

- // Oops error:

- return 0;

- }

- // everything in range matches:

- std::memset(result->_map + static_cast<unsigned char>(c1), true, 1 + static_cast<unsigned char>(c2) - static_cast<unsigned char>(c1));

- }

- }

- //

- // and now the classes:

- //

- typedef typename traits::char_class_type mask_type;

- mask_type m = char_set.classes();

- if(flags() & regbase::icase)

- {

- // adjust m as needed:

- if(((m & m_lower_mask) == m_lower_mask) || ((m & m_upper_mask) == m_upper_mask))

- m |= m_alpha_mask;

- }

- if(m != 0)

- {

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

- {

- if(this->m_traits.isctype(static_cast<charT>(i), m))

- result->_map[i] = true;

- }

- }

- //

- // and now the negated classes:

- //

- m = char_set.negated_classes();

- if(flags() & regbase::icase)

- {

- // adjust m as needed:

- if(((m & m_lower_mask) == m_lower_mask) || ((m & m_upper_mask) == m_upper_mask))

- m |= m_alpha_mask;

- }

- if(m != 0)

- {

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

- {

- if(0 == this->m_traits.isctype(static_cast<charT>(i), m))

- result->_map[i] = true;

- }

- }

- //

- // now process the equivalence classes:

- //

- first = char_set.equivalents_begin();

- last = char_set.equivalents_end();

- while(first != last)

- {

- string_type s;

- BOOST_ASSERT(static_cast<charT>(0) == first->second);

- s = m_traits.transform_primary(&first->first, &first->first+1);

- if(s.empty())

- return 0; // invalid or unsupported equivalence class

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

- {

- charT c[2] = { (static_cast<charT>(i)), charT(0), };

- string_type s2 = this->m_traits.transform_primary(c, c+1);

- if(s == s2)

- result->_map[i] = true;

- }

- ++first;

- }

- if(negate)

- {

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

- {

- result->_map[i] = !(result->_map[i]);

- }

- }

- return result;

-}

-

-template <class charT, class traits>

-void basic_regex_creator<charT, traits>::finalize(const charT* p1, const charT* p2)

-{

- // we've added all the states we need, now finish things off.

- // start by adding a terminating state:

- append_state(syntax_element_match);

- // extend storage to store original expression:

- std::ptrdiff_t len = p2 - p1;

- m_pdata->m_expression_len = len;

- charT* ps = static_cast<charT*>(m_pdata->m_data.extend(sizeof(charT) * (1 + (p2 - p1))));

- m_pdata->m_expression = ps;

- re_detail::copy(p1, p2, ps);

- ps[p2 - p1] = 0;

- // fill in our other data...

- // successful parsing implies a zero status:

- m_pdata->m_status = 0;

- // get the first state of the machine:

- m_pdata->m_first_state = static_cast<re_syntax_base*>(m_pdata->m_data.data());

- // fixup pointers in the machine:

- fixup_pointers(m_pdata->m_first_state);

- // create nested startmaps:

- create_startmaps(m_pdata->m_first_state);

- // create main startmap:

- std::memset(m_pdata->m_startmap, 0, sizeof(m_pdata->m_startmap));

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

- // optimise a leading repeat if there is one:

- probe_leading_repeat(m_pdata->m_first_state);

-}

-

-template <class charT, class traits>

-void basic_regex_creator<charT, traits>::fixup_pointers(re_syntax_base* state)

-{

- while(state)

- {

- switch(state->type)

- {

- case syntax_element_rep:

- case syntax_element_dot_rep:

- case syntax_element_char_rep:

- case syntax_element_short_set_rep:

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

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

- case syntax_element_jump:

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

- // fall through again:

- default:

- if(state->next.i)

- state->next.p = getaddress(state->next.i, state);

- else

- state->next.p = 0;

- }

- state = state->next.p;

- }

-}

-

-template <class charT, class traits>

-void basic_regex_creator<charT, traits>::create_startmaps(re_syntax_base* state)

-{

- // non-recursive implementation:

- // create the last map in the machine first, so that earlier maps

- // can make use of the result...

- //

- // This was originally a recursive implementation, but that caused stack

- // overflows with complex expressions on small stacks (think COM+).

-

- // start by saving the case setting:

- bool l_icase = m_icase;

- std::vector<std::pair<bool, re_syntax_base*> > v;

-

- while(state)

- {

- switch(state->type)

- {

- case syntax_element_toggle_case:

- // we need to track case changes here:

- m_icase = static_cast<re_case*>(state)->icase;

- state = state->next.p;

- continue;

- case syntax_element_alt:

- case syntax_element_rep:

- case syntax_element_dot_rep:

- case syntax_element_char_rep:

- case syntax_element_short_set_rep:

- case syntax_element_long_set_rep:

- // just push the state onto our stack for now:

- v.push_back(std::pair<bool, re_syntax_base*>(m_icase, state));

- state = state->next.p;

- break;

- case syntax_element_backstep:

- // we need to calculate how big the backstep is:

- static_cast<re_brace*>(state)->index

- = this->calculate_backstep(state->next.p);

- if(static_cast<re_brace*>(state)->index < 0)

- {

- // Oops error:

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

- this->m_pdata->m_status = boost::regex_constants::error_bad_pattern;

- //

- // clear the expression, we should be empty:

- //

- this->m_pdata->m_expression = 0;

- this->m_pdata->m_expression_len = 0;

- //

- // and throw if required:

- //

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

- {

- std::string message = this->m_pdata->m_ptraits->error_string(boost::regex_constants::error_bad_pattern);

- boost::regex_error e(message, boost::regex_constants::error_bad_pattern, 0);

- e.raise();

- }

- }

- // fall through:

- default:

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

- v.pop_back();

-

- // Build maps:

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

- }

- // restore case sensitivity:

- m_icase = l_icase;

-}

-

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

- int result = 0;

- while(state)

- {

- switch(state->type)

- {

- case syntax_element_startmark:

- if((static_cast<re_brace*>(state)->index == -1)

- || (static_cast<re_brace*>(state)->index == -2))

- {

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

- continue;

- }

- else if(static_cast<re_brace*>(state)->index == -3)

- {

- state = state->next.p->next.p;

- continue;

- }

- break;

- case syntax_element_endmark:

- if((static_cast<re_brace*>(state)->index == -1)

- || (static_cast<re_brace*>(state)->index == -2))

- return result;

- break;

- case syntax_element_literal:

- result += static_cast<re_literal*>(state)->length;

- break;

- case syntax_element_wild:

- case syntax_element_set:

- result += 1;

- break;

- case syntax_element_dot_rep:

- case syntax_element_char_rep:

- case syntax_element_short_set_rep:

- case syntax_element_backref:

- case syntax_element_rep:

- case syntax_element_combining:

- case syntax_element_long_set_rep:

- case syntax_element_backstep:

- {

- re_repeat* rep = static_cast<re_repeat *>(state);

- // adjust the type of the state to allow for faster matching:

- state->type = this->get_repeat_type(state);

- if((state->type == syntax_element_dot_rep)

- || (state->type == syntax_element_char_rep)

- || (state->type == syntax_element_short_set_rep))

- {

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

- return -1;

- result += static_cast<int>(rep->min);

- state = rep->alt.p;

- continue;

- }

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

- return -1;

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

- return -1;

- result += static_cast<int>(rep->min);

- state = rep->alt.p;

- continue;

- }

- }

- return -1;

- case syntax_element_long_set:

- if(static_cast<re_set_long<mask_type>*>(state)->singleton == 0)

- return -1;

- result += 1;

- break;

- case syntax_element_jump:

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

- continue;

- default:

- break;

- }

- state = state->next.p;

- }

- return -1;

-}

-

-template <class charT, class traits>

-void basic_regex_creator<charT, traits>::create_startmap(re_syntax_base* state, unsigned char* l_map, unsigned int* pnull, unsigned char mask)

-{

- int not_last_jump = 1;

-

- // track case sensitivity:

- bool l_icase = m_icase;

-

- while(state)

- {

- switch(state->type)

- {

- case syntax_element_toggle_case:

- l_icase = static_cast<re_case*>(state)->icase;

- state = state->next.p;

- break;

- case syntax_element_literal:

- {

- // don't set anything in *pnull, set each element in l_map

- // that could match the first character in the literal:

- if(l_map)

- {

- l_map[0] |= mask_init;

- charT first_char = *static_cast<charT*>(static_cast<void*>(static_cast<re_literal*>(state) + 1));

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

- {

- if(m_traits.translate(static_cast<charT>(i), l_icase) == first_char)

- l_map[i] |= mask;

- }

- }

- return;

- }

- case syntax_element_end_line:

- {

- // next character must be a line separator (if there is one):

- if(l_map)

- {

- l_map[0] |= mask_init;

- l_map['\n'] |= mask;

- l_map['\r'] |= mask;

- l_map['\f'] |= mask;

- l_map[0x85] |= mask;

- }

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

- if(pnull)

- create_startmap(state->next.p, 0, pnull, mask);

- return;

- }

- case syntax_element_backref:

- // can be null, and any character can match:

- if(pnull)

- *pnull |= mask;

- // fall through:

- case syntax_element_wild:

- {

- // can't be null, any character can match:

- set_all_masks(l_map, mask);

- return;

- }

- case syntax_element_match:

- {

- // must be null, any character can match:

- set_all_masks(l_map, mask);

- if(pnull)

- *pnull |= mask;

- return;

- }

- case syntax_element_word_start:

- {

- // recurse, then AND with all the word characters:

- create_startmap(state->next.p, l_map, pnull, mask);

- if(l_map)

- {

- l_map[0] |= mask_init;

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

- {

- if(!m_traits.isctype(static_cast<charT>(i), m_word_mask))

- l_map[i] &= static_cast<unsigned char>(~mask);

- }

- }

- return;

- }

- case syntax_element_word_end:

- {

- // recurse, then AND with all the word characters:

- create_startmap(state->next.p, l_map, pnull, mask);

- if(l_map)

- {

- l_map[0] |= mask_init;

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

- {

- if(m_traits.isctype(static_cast<charT>(i), m_word_mask))

- l_map[i] &= static_cast<unsigned char>(~mask);

- }

- }

- return;

- }

- case syntax_element_buffer_end:

- {

- // we *must be null* :

- if(pnull)

- *pnull |= mask;

- return;

- }

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

- {

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

- l_map[i] |= mask;

- }

- }

- else

- set_all_masks(l_map, mask);

- }

- return;

- case syntax_element_set:

- if(l_map)

- {

- l_map[0] |= mask_init;

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

- {

- if(static_cast<re_set*>(state)->_map[

- static_cast<unsigned char>(m_traits.translate(static_cast<charT>(i), l_icase))])

- l_map[i] |= mask;

- }

- }

- return;

- case syntax_element_jump:

- // take the jump:

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

- not_last_jump = -1;

- break;

- case syntax_element_alt:

- case syntax_element_rep:

- case syntax_element_dot_rep:

- case syntax_element_char_rep:

- case syntax_element_short_set_rep:

- case syntax_element_long_set_rep:

- {

- re_alt* rep = static_cast<re_alt*>(state);

- if(rep->_map[0] & mask_init)

- {

- if(l_map)

- {

- // copy previous results:

- l_map[0] |= mask_init;

- for(unsigned int i = 0; i <= UCHAR_MAX; ++i)

- {

- if(rep->_map[i] & mask_any)

- l_map[i] |= mask;

- }

- }

- if(pnull)

- {

- if(rep->can_be_null & mask_any)

- *pnull |= mask;

- }

- }

- else

- {

- // we haven't created a startmap for this alternative yet

- // so take the union of the two options:

- if(is_bad_repeat(state))

- {

- set_all_masks(l_map, mask);

- if(pnull)

- *pnull |= mask;

- return;

- }

- set_bad_repeat(state);

- create_startmap(state->next.p, l_map, pnull, mask);

- if((state->type == syntax_element_alt)

- || (static_cast<re_repeat*>(state)->min == 0)

- || (not_last_jump == 0))

- create_startmap(rep->alt.p, l_map, pnull, mask);

- }

- }

- return;

- case syntax_element_soft_buffer_end:

- // match newline or null:

- if(l_map)

- {

- l_map[0] |= mask_init;

- l_map['\n'] |= mask;

- l_map['\r'] |= mask;

- }

- if(pnull)

- *pnull |= mask;

- return;

- case syntax_element_endmark:

- // need to handle independent subs as a special case:

- if(static_cast<re_brace*>(state)->index < 0)

- {

- // can be null, any character can match:

- set_all_masks(l_map, mask);

- if(pnull)

- *pnull |= mask;

- return;

- }

- else

- {

- state = state->next.p;

- break;

- }

-

- case syntax_element_startmark:

- // need to handle independent subs as a special case:

- if(static_cast<re_brace*>(state)->index == -3)

- {

- state = state->next.p->next.p;

- break;

- }

- // otherwise fall through:

- default:

- state = state->next.p;

- }

- ++not_last_jump;

- }

-}

-

-template <class charT, class traits>

-unsigned basic_regex_creator<charT, traits>::get_restart_type(re_syntax_base* state)

-{

- //

- // find out how the machine starts, so we can optimise the search:

- //

- while(state)

- {

- switch(state->type)

- {

- case syntax_element_startmark:

- case syntax_element_endmark:

- state = state->next.p;

- continue;

- case syntax_element_start_line:

- return regbase::restart_line;

- case syntax_element_word_start:

- return regbase::restart_word;

- case syntax_element_buffer_start:

- return regbase::restart_buf;

- case syntax_element_restart_continue:

- return regbase::restart_continue;

- default:

- state = 0;

- continue;

- }

- }

- return regbase::restart_any;

-}

-

-template <class charT, class traits>

-void basic_regex_creator<charT, traits>::set_all_masks(unsigned char* bits, unsigned char mask)

-{

- //

- // set mask in all of bits elements,

- // if bits[0] has mask_init not set then we can

- // optimise this to a call to memset:

- //

- if(bits)

- {

- if(bits[0] == 0)

- (std::memset)(bits, mask, 1u << CHAR_BIT);

- else

- {

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

- bits[i] |= mask;

- }

- bits[0] |= mask_init;

- }

-}

-

-template <class charT, class traits>

-bool basic_regex_creator<charT, traits>::is_bad_repeat(re_syntax_base* pt)

-{

- switch(pt->type)

- {

- case syntax_element_rep:

- case syntax_element_dot_rep:

- case syntax_element_char_rep:

- case syntax_element_short_set_rep:

- case syntax_element_long_set_rep:

- {

- unsigned state_id = static_cast<re_repeat*>(pt)->state_id;

- if(state_id > sizeof(m_bad_repeats) * CHAR_BIT)

- return true; // run out of bits, assume we can't traverse this one.

- static const boost::uintmax_t one = 1uL;

- return m_bad_repeats & (one << state_id);

- }

- default:

- return false;

- }

-}

-

-template <class charT, class traits>

-void basic_regex_creator<charT, traits>::set_bad_repeat(re_syntax_base* pt)

-{

- switch(pt->type)

- {

- case syntax_element_rep:

- case syntax_element_dot_rep:

- case syntax_element_char_rep:

- case syntax_element_short_set_rep:

- case syntax_element_long_set_rep:

- {

- unsigned state_id = static_cast<re_repeat*>(pt)->state_id;

- static const boost::uintmax_t one = 1uL;

- if(state_id <= sizeof(m_bad_repeats) * CHAR_BIT)

- m_bad_repeats |= (one << state_id);

- }

- default:

- break;

- }

-}

-

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

- if(state->type == syntax_element_rep)

- {

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

- if(state->next.p->next.p->next.p == static_cast<re_alt*>(state)->alt.p)

- {

- switch(state->next.p->type)

- {

- case re_detail::syntax_element_wild:

- return re_detail::syntax_element_dot_rep;

- case re_detail::syntax_element_literal:

- return re_detail::syntax_element_char_rep;

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

- return re_detail::syntax_element_long_set_rep;

- break;

- default:

- break;

- }

- }

- }

- return state->type;

-}

-

-template <class charT, class traits>

-void basic_regex_creator<charT, traits>::probe_leading_repeat(re_syntax_base* state)

-{

- // enumerate our states, and see if we have a leading repeat

- // for which failed search restarts can be optimised;

- do

- {

- switch(state->type)

- {

- case syntax_element_startmark:

- if(static_cast<re_brace*>(state)->index >= 0)

- {

- state = state->next.p;

- continue;

- }

- if((static_cast<re_brace*>(state)->index == -1)

- || (static_cast<re_brace*>(state)->index == -2))

- {

- // skip past the zero width assertion:

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

- continue;

- }

- if(static_cast<re_brace*>(state)->index == -3)

- {

- // Have to skip the leading jump state:

- state = state->next.p->next.p;

- continue;

- }

- return;

- case syntax_element_endmark:

- case syntax_element_start_line:

- case syntax_element_end_line:

- case syntax_element_word_boundary:

- case syntax_element_within_word:

- case syntax_element_word_start:

- case syntax_element_word_end:

- case syntax_element_buffer_start:

- case syntax_element_buffer_end:

- case syntax_element_restart_continue:

- state = state->next.p;

- break;

- case syntax_element_dot_rep:

- case syntax_element_char_rep:

- case syntax_element_short_set_rep:

- case syntax_element_long_set_rep:

- if(this->m_has_backrefs == 0)

- static_cast<re_repeat*>(state)->leading = true;

- // fall through:

- default:

- return;

- }

- }while(state);

-}

-

-

-} // namespace re_detail

-

-} // namespace boost

-

-#ifdef BOOST_MSVC

-# pragma warning(pop)

-#endif

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_SUFFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-#endif

-/*

- *

- * Copyright (c) 2004

- * John Maddock

- *

- * 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 basic_regex_parser.cpp

- * VERSION see <boost/version.hpp>

- * DESCRIPTION: Declares template class basic_regex_parser.

- */

-

-#ifndef BOOST_REGEX_V4_BASIC_REGEX_PARSER_HPP

-#define BOOST_REGEX_V4_BASIC_REGEX_PARSER_HPP

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_PREFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-namespace boost{

-namespace re_detail{

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable:4244 4800)

-#endif

-

-template <class charT, class traits>

-class basic_regex_parser : public basic_regex_creator<charT, traits>

-{

-public:

- basic_regex_parser(regex_data<charT, traits>* data);

- void parse(const charT* p1, const charT* p2, unsigned flags);

- void fail(regex_constants::error_type error_code, std::ptrdiff_t position);

-

- bool parse_all();

- bool parse_basic();

- bool parse_extended();

- bool parse_literal();

- bool parse_open_paren();

- bool parse_basic_escape();

- bool parse_extended_escape();

- bool parse_match_any();

- bool parse_repeat(std::size_t low = 0, std::size_t high = (std::numeric_limits<std::size_t>::max)());

- bool parse_repeat_range(bool isbasic);

- bool parse_alt();

- bool parse_set();

- bool parse_backref();

- void parse_set_literal(basic_char_set<charT, traits>& char_set);

- bool parse_inner_set(basic_char_set<charT, traits>& char_set);

- bool parse_QE();

- bool parse_perl_extension();

- bool add_emacs_code(bool negate);

- bool unwind_alts(std::ptrdiff_t last_paren_start);

- digraph<charT> get_next_set_literal(basic_char_set<charT, traits>& char_set);

- charT unescape_character();

- regex_constants::syntax_option_type parse_options();

-

-private:

- typedef bool (basic_regex_parser::*parser_proc_type)();

- typedef typename traits::string_type string_type;

- typedef typename traits::char_class_type char_class_type;

- parser_proc_type m_parser_proc; // the main parser to use

- const charT* m_base; // the start of the string being parsed

- const charT* m_end; // the end of the string being parsed

- const charT* m_position; // our current parser position

- unsigned m_mark_count; // how many sub-expressions we have

- std::ptrdiff_t m_paren_start; // where the last seen ')' began (where repeats are inserted).

- std::ptrdiff_t m_alt_insert_point; // where to insert the next alternative

- bool m_has_case_change; // true if somewhere in the current block the case has changed

-#if defined(BOOST_MSVC) && defined(_M_IX86)

- // This is an ugly warning suppression workaround (for warnings *inside* std::vector

- // that can not otherwise be suppressed)...

- BOOST_STATIC_ASSERT(sizeof(long) >= sizeof(void*));

- std::vector<long> m_alt_jumps; // list of alternative in the current scope.

-#else

- std::vector<std::ptrdiff_t> m_alt_jumps; // list of alternative in the current scope.

-#endif

-

- basic_regex_parser& operator=(const basic_regex_parser&);

- basic_regex_parser(const basic_regex_parser&);

-};

-

-template <class charT, class traits>

-basic_regex_parser<charT, traits>::basic_regex_parser(regex_data<charT, traits>* data)

- : basic_regex_creator<charT, traits>(data), m_mark_count(0), m_paren_start(0), m_alt_insert_point(0), m_has_case_change(false)

-{

-}

-

-template <class charT, class traits>

-void basic_regex_parser<charT, traits>::parse(const charT* p1, const charT* p2, unsigned l_flags)

-{

- // pass l_flags on to base class:

- this->init(l_flags);

- // set up pointers:

- m_position = m_base = p1;

- m_end = p2;

- // empty strings are errors:

- if((p1 == p2) &&

- (

- ((l_flags & regbase::main_option_type) != regbase::perl_syntax_group)

- || (l_flags & regbase::no_empty_expressions)

- )

- )

- {

- fail(regex_constants::error_empty, 0);

- return;

- }

- // select which parser to use:

- switch(l_flags & regbase::main_option_type)

- {

- case regbase::perl_syntax_group:

- m_parser_proc = &basic_regex_parser<charT, traits>::parse_extended;

- break;

- case regbase::basic_syntax_group:

- m_parser_proc = &basic_regex_parser<charT, traits>::parse_basic;

- break;

- case regbase::literal:

- m_parser_proc = &basic_regex_parser<charT, traits>::parse_literal;

- break;

- }

-

- // parse all our characters:

- bool result = parse_all();

- //

- // Unwind our alternatives:

- //

- unwind_alts(-1);

- // reset l_flags as a global scope (?imsx) may have altered them:

- this->flags(l_flags);

- // if we haven't gobbled up all the characters then we must

- // have had an unexpected ')' :

- if(!result)

- {

- fail(regex_constants::error_paren, ::boost::re_detail::distance(m_base, m_position));

- return;

- }

- // if an error has been set then give up now:

- if(this->m_pdata->m_status)

- return;

- // fill in our sub-expression count:

- this->m_pdata->m_mark_count = 1 + m_mark_count;

- this->finalize(p1, p2);

-}

-

-template <class charT, class traits>

-void basic_regex_parser<charT, traits>::fail(regex_constants::error_type error_code, std::ptrdiff_t position)

-{

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

- this->m_pdata->m_status = error_code;

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

- // get the error message:

- std::string message = this->m_pdata->m_ptraits->error_string(error_code);

- // and raise the exception, this will do nothing if exceptions are disabled:

-#ifndef BOOST_NO_EXCEPTIONS

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

- {

- boost::regex_error e(message, error_code, position);

- e.raise();

- }

-#else

- (void)position; // suppress warnings.

-#endif

-}

-

-template <class charT, class traits>

-bool basic_regex_parser<charT, traits>::parse_all()

-{

- bool result = true;

- while(result && (m_position != m_end))

- {

- result = (this->*m_parser_proc)();

- }

- return result;

-}

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable:4702)

-#endif

-template <class charT, class traits>

-bool basic_regex_parser<charT, traits>::parse_basic()

-{

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

- {

- case regex_constants::syntax_escape:

- return parse_basic_escape();

- case regex_constants::syntax_dot:

- return parse_match_any();

- case regex_constants::syntax_caret:

- ++m_position;

- this->append_state(syntax_element_start_line);

- break;

- case regex_constants::syntax_dollar:

- ++m_position;

- this->append_state(syntax_element_end_line);

- break;

- case regex_constants::syntax_star:

- if(!(this->m_last_state) || (this->m_last_state->type == syntax_element_start_line))

- return parse_literal();

- else

- {

- ++m_position;

- return parse_repeat();

- }

- case regex_constants::syntax_plus:

- if(!(this->m_last_state) || (this->m_last_state->type == syntax_element_start_line) || !(this->flags() & regbase::emacs_ex))

- return parse_literal();

- else

- {

- ++m_position;

- return parse_repeat(1);

- }

- case regex_constants::syntax_question:

- if(!(this->m_last_state) || (this->m_last_state->type == syntax_element_start_line) || !(this->flags() & regbase::emacs_ex))

- return parse_literal();

- else

- {

- ++m_position;

- return parse_repeat(0, 1);

- }

- case regex_constants::syntax_open_set:

- return parse_set();

- case regex_constants::syntax_newline:

- if(this->flags() & regbase::newline_alt)

- return parse_alt();

- else

- return parse_literal();

- default:

- return parse_literal();

- }

- return true;

-}

-

-template <class charT, class traits>

-bool basic_regex_parser<charT, traits>::parse_extended()

-{

- bool result = true;

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

- {

- case regex_constants::syntax_open_mark:

- return parse_open_paren();

- case regex_constants::syntax_close_mark:

- return false;

- case regex_constants::syntax_escape:

- return parse_extended_escape();

- case regex_constants::syntax_dot:

- return parse_match_any();

- case regex_constants::syntax_caret:

- ++m_position;

- this->append_state(

- (this->flags() & regex_constants::no_mod_m ? syntax_element_buffer_start : syntax_element_start_line));

- break;

- case regex_constants::syntax_dollar:

- ++m_position;

- this->append_state(

- (this->flags() & regex_constants::no_mod_m ? syntax_element_buffer_end : syntax_element_end_line));

- break;

- case regex_constants::syntax_star:

- if(m_position == this->m_base)

- {

- fail(regex_constants::error_badrepeat, 0);

- return false;

- }

- ++m_position;

- return parse_repeat();

- case regex_constants::syntax_question:

- if(m_position == this->m_base)

- {

- fail(regex_constants::error_badrepeat, 0);

- return false;

- }

- ++m_position;

- return parse_repeat(0,1);

- case regex_constants::syntax_plus:

- if(m_position == this->m_base)

- {

- fail(regex_constants::error_badrepeat, 0);

- return false;

- }

- ++m_position;

- return parse_repeat(1);

- case regex_constants::syntax_open_brace:

- ++m_position;

- return parse_repeat_range(false);

- case regex_constants::syntax_close_brace:

- fail(regex_constants::error_brace, this->m_position - this->m_end);

- return false;

- case regex_constants::syntax_or:

- return parse_alt();

- case regex_constants::syntax_open_set:

- return parse_set();

- case regex_constants::syntax_newline:

- if(this->flags() & regbase::newline_alt)

- return parse_alt();

- else

- return parse_literal();

- case regex_constants::syntax_hash:

- //

- // If we have a mod_x flag set, then skip until

- // we get to a newline character:

- //

- if((this->flags()

- & (regbase::no_perl_ex|regbase::mod_x))

- == regbase::mod_x)

- {

- while((m_position != m_end) && !is_separator(*m_position++)){}

- return true;

- }

- // Otherwise fall through:

- default:

- result = parse_literal();

- break;

- }

- return result;

-}

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-template <class charT, class traits>

-bool basic_regex_parser<charT, traits>::parse_literal()

-{

- // append this as a literal provided it's not a space character

- // or the perl option regbase::mod_x is not set:

- if(

- ((this->flags()

- & (regbase::main_option_type|regbase::mod_x|regbase::no_perl_ex))

- != regbase::mod_x)

- || !this->m_traits.isctype(*m_position, this->m_mask_space))

- this->append_literal(*m_position);

- ++m_position;

- return true;

-}

-

-template <class charT, class traits>

-bool basic_regex_parser<charT, traits>::parse_open_paren()

-{

- //

- // skip the '(' and error check:

- //

- if(++m_position == m_end)

- {

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

- return false;

- }

- //

- // begin by checking for a perl-style (?...) extension:

- //

- if(

- ((this->flags() & (regbase::main_option_type | regbase::no_perl_ex)) == 0)

- || ((this->flags() & (regbase::main_option_type | regbase::emacs_ex)) == (regbase::basic_syntax_group|regbase::emacs_ex))

- )

- {

- if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_question)

- return parse_perl_extension();

- }

- //

- // update our mark count, and append the required state:

- //

- unsigned markid = 0;

- if(0 == (this->flags() & regbase::nosubs))

- {

- markid = ++m_mark_count;

- if(this->flags() & regbase::save_subexpression_location)

- this->m_pdata->m_subs.push_back(std::pair<std::size_t, std::size_t>(std::distance(m_base, m_position) - 1, 0));

- }

- re_brace* pb = static_cast<re_brace*>(this->append_state(syntax_element_startmark, sizeof(re_brace)));

- pb->index = markid;

- std::ptrdiff_t last_paren_start = this->getoffset(pb);

- // back up insertion point for alternations, and set new point:

- std::ptrdiff_t last_alt_point = m_alt_insert_point;

- this->m_pdata->m_data.align();

- m_alt_insert_point = this->m_pdata->m_data.size();

- //

- // back up the current flags in case we have a nested (?imsx) group:

- //

- regex_constants::syntax_option_type opts = this->flags();

- bool old_case_change = m_has_case_change;

- m_has_case_change = false; // no changes to this scope as yet...

- //

- // now recursively add more states, this will terminate when we get to a

- // matching ')' :

- //

- parse_all();

- //

- // Unwind pushed alternatives:

- //

- if(0 == unwind_alts(last_paren_start))

- return false;

- //

- // restore flags:

- //

- if(m_has_case_change)

- {

- // the case has changed in one or more of the alternatives

- // within the scoped (...) block: we have to add a state

- // to reset the case sensitivity:

- static_cast<re_case*>(

- this->append_state(syntax_element_toggle_case, sizeof(re_case))

- )->icase = opts & regbase::icase;

- }

- this->flags(opts);

- m_has_case_change = old_case_change;

- //

- // we either have a ')' or we have run out of characters prematurely:

- //

- if(m_position == m_end)

- {

- this->fail(regex_constants::error_paren, ::boost::re_detail::distance(m_base, m_end));

- return false;

- }

- BOOST_ASSERT(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark);

- if(markid && (this->flags() & regbase::save_subexpression_location))

- this->m_pdata->m_subs.at(markid - 1).second = std::distance(m_base, m_position);

- ++m_position;

- //

- // append closing parenthesis state:

- //

- pb = static_cast<re_brace*>(this->append_state(syntax_element_endmark, sizeof(re_brace)));

- pb->index = markid;

- this->m_paren_start = last_paren_start;

- //

- // restore the alternate insertion point:

- //

- this->m_alt_insert_point = last_alt_point;

- //

- // allow backrefs to this mark:

- //

- if((markid > 0) && (markid < sizeof(unsigned) * CHAR_BIT))

- this->m_backrefs |= 1u << (markid - 1);

-

- return true;

-}

-

-template <class charT, class traits>

-bool basic_regex_parser<charT, traits>::parse_basic_escape()

-{

- ++m_position;

- bool result = true;

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

- {

- case regex_constants::syntax_open_mark:

- return parse_open_paren();

- case regex_constants::syntax_close_mark:

- return false;

- case regex_constants::syntax_plus:

- if(this->flags() & regex_constants::bk_plus_qm)

- {

- ++m_position;

- return parse_repeat(1);

- }

- else

- return parse_literal();

- case regex_constants::syntax_question:

- if(this->flags() & regex_constants::bk_plus_qm)

- {

- ++m_position;

- return parse_repeat(0, 1);

- }

- else

- return parse_literal();

- case regex_constants::syntax_open_brace:

- if(this->flags() & regbase::no_intervals)

- return parse_literal();

- ++m_position;

- return parse_repeat_range(true);

- case regex_constants::syntax_close_brace:

- if(this->flags() & regbase::no_intervals)

- return parse_literal();

- fail(regex_constants::error_brace, this->m_position - this->m_base);

- return false;

- case regex_constants::syntax_or:

- if(this->flags() & regbase::bk_vbar)

- return parse_alt();

- else

- result = parse_literal();

- break;

- case regex_constants::syntax_digit:

- return parse_backref();

- case regex_constants::escape_type_start_buffer:

- if(this->flags() & regbase::emacs_ex)

- {

- ++m_position;

- this->append_state(syntax_element_buffer_start);

- }

- else

- result = parse_literal();

- break;

- case regex_constants::escape_type_end_buffer:

- if(this->flags() & regbase::emacs_ex)

- {

- ++m_position;

- this->append_state(syntax_element_buffer_end);

- }

- else

- result = parse_literal();

- break;

- case regex_constants::escape_type_word_assert:

- if(this->flags() & regbase::emacs_ex)

- {

- ++m_position;

- this->append_state(syntax_element_word_boundary);

- }

- else

- result = parse_literal();

- break;

- case regex_constants::escape_type_not_word_assert:

- if(this->flags() & regbase::emacs_ex)

- {

- ++m_position;

- this->append_state(syntax_element_within_word);

- }

- else

- result = parse_literal();

- break;

- case regex_constants::escape_type_left_word:

- if(this->flags() & regbase::emacs_ex)

- {

- ++m_position;

- this->append_state(syntax_element_word_start);

- }

- else

- result = parse_literal();

- break;

- case regex_constants::escape_type_right_word:

- if(this->flags() & regbase::emacs_ex)

- {

- ++m_position;

- this->append_state(syntax_element_word_end);

- }

- else

- result = parse_literal();

- break;

- default:

- if(this->flags() & regbase::emacs_ex)

- {

- bool negate = true;

- switch(*m_position)

- {

- case 'w':

- negate = false;

- // fall through:

- case 'W':

- {

- basic_char_set<charT, traits> char_set;

- if(negate)

- char_set.negate();

- char_set.add_class(this->m_word_mask);

- if(0 == this->append_set(char_set))

- {

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

- return false;

- }

- ++m_position;

- return true;

- }

- case 's':

- negate = false;

- // fall through:

- case 'S':

- return add_emacs_code(negate);

- case 'c':

- case 'C':

- // not supported yet:

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

- return false;

- default:

- break;

- }

- }

- result = parse_literal();

- break;

- }

- return result;

-}

-

-template <class charT, class traits>

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

- negate = true;

- // fall through:

- case regex_constants::escape_type_class:

- {

- typedef typename traits::char_class_type mask_type;

- mask_type m = this->m_traits.lookup_classname(m_position, m_position+1);

- if(m != 0)

- {

- basic_char_set<charT, traits> char_set;

- if(negate)

- char_set.negate();

- char_set.add_class(m);

- if(0 == this->append_set(char_set))

- {

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

- return false;

- }

- ++m_position;

- return true;

- }

- //

- // not a class, just a regular unknown escape:

- //

- this->append_literal(unescape_character());

- break;

- }

- case regex_constants::syntax_digit:

- return parse_backref();

- case regex_constants::escape_type_left_word:

- ++m_position;

- this->append_state(syntax_element_word_start);

- break;

- case regex_constants::escape_type_right_word:

- ++m_position;

- this->append_state(syntax_element_word_end);

- break;

- case regex_constants::escape_type_start_buffer:

- ++m_position;

- this->append_state(syntax_element_buffer_start);

- break;

- case regex_constants::escape_type_end_buffer:

- ++m_position;

- this->append_state(syntax_element_buffer_end);

- break;

- case regex_constants::escape_type_word_assert:

- ++m_position;

- this->append_state(syntax_element_word_boundary);

- break;

- case regex_constants::escape_type_not_word_assert:

- ++m_position;

- this->append_state(syntax_element_within_word);

- break;

- case regex_constants::escape_type_Z:

- ++m_position;

- this->append_state(syntax_element_soft_buffer_end);

- break;

- case regex_constants::escape_type_Q:

- return parse_QE();

- case regex_constants::escape_type_C:

- return parse_match_any();

- case regex_constants::escape_type_X:

- ++m_position;

- this->append_state(syntax_element_combining);

- break;

- case regex_constants::escape_type_G:

- ++m_position;

- this->append_state(syntax_element_restart_continue);

- break;

- case regex_constants::escape_type_not_property:

- negate = true;

- // fall through:

- case regex_constants::escape_type_property:

- {

- ++m_position;

- char_class_type m;

- if(m_position == m_end)

- {

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

- return false;

- }

- // maybe have \p{ddd}

- if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_open_brace)

- {

- const charT* base = m_position;

- // skip forward until we find enclosing brace:

- while((m_position != m_end) && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_brace))

- ++m_position;

- if(m_position == m_end)

- {

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

- return false;

- }

- m = this->m_traits.lookup_classname(++base, m_position++);

- }

- else

- {

- m = this->m_traits.lookup_classname(m_position, m_position+1);

- ++m_position;

- }

- if(m != 0)

- {

- basic_char_set<charT, traits> char_set;

- if(negate)

- char_set.negate();

- char_set.add_class(m);

- if(0 == this->append_set(char_set))

- {

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

- return false;

- }

- return true;

- }

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

- }

- default:

- this->append_literal(unescape_character());

- break;

- }

- return true;

-}

-

-template <class charT, class traits>

-bool basic_regex_parser<charT, traits>::parse_match_any()

-{

- //

- // we have a '.' that can match any character:

- //

- ++m_position;

- static_cast<re_dot*>(

- this->append_state(syntax_element_wild, sizeof(re_dot))

- )->mask = static_cast<unsigned char>(this->flags() & regbase::no_mod_s

- ? re_detail::force_not_newline

- : this->flags() & regbase::mod_s ?

- re_detail::force_newline : re_detail::dont_care);

- return true;

-}

-

-template <class charT, class traits>

-bool basic_regex_parser<charT, traits>::parse_repeat(std::size_t low, std::size_t high)

-{

- bool greedy = true;

- std::size_t insert_point;

- //

- // when we get to here we may have a non-greedy ? mark still to come:

- //

- if((m_position != m_end)

- && (

- (0 == (this->flags() & (regbase::main_option_type | regbase::no_perl_ex)))

- || ((regbase::basic_syntax_group|regbase::emacs_ex) == (this->flags() & (regbase::main_option_type | regbase::emacs_ex)))

- )

- )

- {

- // OK we have a perl regex, check for a '?':

- if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_question)

- {

- greedy = false;

- ++m_position;

- }

- }

- if(0 == this->m_last_state)

- {

- fail(regex_constants::error_badrepeat, ::boost::re_detail::distance(m_base, m_position));

- return false;

- }

- if(this->m_last_state->type == syntax_element_endmark)

- {

- // insert a repeat before the '(' matching the last ')':

- insert_point = this->m_paren_start;

- }

- else if((this->m_last_state->type == syntax_element_literal) && (static_cast<re_literal*>(this->m_last_state)->length > 1))

- {

- // the last state was a literal with more than one character, split it in two:

- re_literal* lit = static_cast<re_literal*>(this->m_last_state);

- charT c = (static_cast<charT*>(static_cast<void*>(lit+1)))[lit->length - 1];

- --(lit->length);

- // now append new state:

- lit = static_cast<re_literal*>(this->append_state(syntax_element_literal, sizeof(re_literal) + sizeof(charT)));

- lit->length = 1;

- (static_cast<charT*>(static_cast<void*>(lit+1)))[0] = c;

- insert_point = this->getoffset(this->m_last_state);

- }

- else

- {

- // repeat the last state whatever it was, need to add some error checking here:

- switch(this->m_last_state->type)

- {

- case syntax_element_start_line:

- case syntax_element_end_line:

- case syntax_element_word_boundary:

- case syntax_element_within_word:

- case syntax_element_word_start:

- case syntax_element_word_end:

- case syntax_element_buffer_start:

- case syntax_element_buffer_end:

- case syntax_element_alt:

- case syntax_element_soft_buffer_end:

- case syntax_element_restart_continue:

- case syntax_element_jump:

- case syntax_element_startmark:

- case syntax_element_backstep:

- // can't legally repeat any of the above:

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

- return false;

- default:

- // do nothing...

- break;

- }

- insert_point = this->getoffset(this->m_last_state);

- }

- //

- // OK we now know what to repeat, so insert the repeat around it:

- //

- re_repeat* rep = static_cast<re_repeat*>(this->insert_state(insert_point, syntax_element_rep, re_repeater_size));

- rep->min = low;

- rep->max = high;

- rep->greedy = greedy;

- rep->leading = false;

- // store our repeater position for later:

- std::ptrdiff_t rep_off = this->getoffset(rep);

- // and append a back jump to the repeat:

- re_jump* jmp = static_cast<re_jump*>(this->append_state(syntax_element_jump, sizeof(re_jump)));

- jmp->alt.i = rep_off - this->getoffset(jmp);

- this->m_pdata->m_data.align();

- // now fill in the alt jump for the repeat:

- rep = static_cast<re_repeat*>(this->getaddress(rep_off));

- rep->alt.i = this->m_pdata->m_data.size() - rep_off;

- return true;

-}

-

-template <class charT, class traits>

-bool basic_regex_parser<charT, traits>::parse_repeat_range(bool isbasic)

-{

- //

- // parse a repeat-range:

- //

- std::size_t min, max;

- int v;

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

- return false;

- }

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

- }

- else if(this->m_position == this->m_end)

- {

- fail(regex_constants::error_brace, this->m_position - this->m_base);

- return false;

- }

- min = v;

- // see if we have a comma:

- if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_comma)

- {

- // move on and error check:

- ++m_position;

- // skip whitespace:

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

- return false;

- }

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

- }

- else

- {

- // no comma, max = min:

- max = min;

- }

- // skip whitespace:

- while((m_position != m_end) && this->m_traits.isctype(*m_position, this->m_mask_space))

- ++m_position;

- // OK now check trailing }:

- if(this->m_position == this->m_end)

- {

- fail(regex_constants::error_brace, this->m_position - this->m_base);

- return false;

- }

- if(isbasic)

- {

- if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_escape)

- {

- ++m_position;

- if(this->m_position == this->m_end)

- {

- fail(regex_constants::error_brace, this->m_position - this->m_base);

- return false;

- }

- }

- else

- {

- fail(regex_constants::error_badbrace, this->m_position - this->m_base);

- return false;

- }

- }

- if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_brace)

- ++m_position;

- else

- {

- fail(regex_constants::error_badbrace, this->m_position - this->m_base);

- return false;

- }

- //

- // finally go and add the repeat, unless error:

- //

- if(min > max)

- {

- fail(regex_constants::error_badbrace, this->m_position - this->m_base);

- return false;

- }

- return parse_repeat(min, max);

-}

-

-template <class charT, class traits>

-bool basic_regex_parser<charT, traits>::parse_alt()

-{

- //

- // error check: if there have been no previous states,

- // or if the last state was a '(' then error:

- //

- if(

- ((this->m_last_state == 0) || (this->m_last_state->type == syntax_element_startmark))

- &&

- !(

- ((this->flags() & regbase::main_option_type) == regbase::perl_syntax_group)

- &&

- ((this->flags() & regbase::no_empty_expressions) == 0)

- )

- )

- {

- fail(regex_constants::error_empty, this->m_position - this->m_base);

- return false;

- }

- ++m_position;

- //

- // we need to append a trailing jump:

- //

- re_syntax_base* pj = this->append_state(re_detail::syntax_element_jump, sizeof(re_jump));

- std::ptrdiff_t jump_offset = this->getoffset(pj);

- //

- // now insert the alternative:

- //

- re_alt* palt = static_cast<re_alt*>(this->insert_state(this->m_alt_insert_point, syntax_element_alt, re_alt_size));

- jump_offset += re_alt_size;

- this->m_pdata->m_data.align();

- palt->alt.i = this->m_pdata->m_data.size() - this->getoffset(palt);

- //

- // update m_alt_insert_point so that the next alternate gets

- // inserted at the start of the second of the two we've just created:

- //

- this->m_alt_insert_point = this->m_pdata->m_data.size();

- //

- // the start of this alternative must have a case changes state

- // if the current block has messed around with case changes:

- //

- if(m_has_case_change)

- {

- static_cast<re_case*>(

- this->append_state(syntax_element_toggle_case, sizeof(re_case))

- )->icase = this->m_icase;

- }

- //

- // push the alternative onto our stack, a recursive

- // implementation here is easier to understand (and faster

- // as it happens), but causes all kinds of stack overflow problems

- // on programs with small stacks (COM+).

- //

- m_alt_jumps.push_back(jump_offset);

- return true;

-}

-

-template <class charT, class traits>

-bool basic_regex_parser<charT, traits>::parse_set()

-{

- ++m_position;

- if(m_position == m_end)

- {

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

- return false;

- }

- basic_char_set<charT, traits> char_set;

-

- const charT* base = m_position; // where the '[' was

- const charT* item_base = m_position; // where the '[' or '^' was

-

- while(m_position != m_end)

- {

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

- {

- case regex_constants::syntax_caret:

- if(m_position == base)

- {

- char_set.negate();

- ++m_position;

- item_base = m_position;

- }

- else

- parse_set_literal(char_set);

- break;

- case regex_constants::syntax_close_set:

- if(m_position == item_base)

- {

- parse_set_literal(char_set);

- break;

- }

- else

- {

- ++m_position;

- if(0 == this->append_set(char_set))

- {

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

- return false;

- }

- }

- return true;

- case regex_constants::syntax_open_set:

- if(parse_inner_set(char_set))

- break;

- return true;

- case regex_constants::syntax_escape:

- {

- //

- // look ahead and see if this is a character class shortcut

- // \d \w \s etc...

- //

- ++m_position;

- if(this->m_traits.escape_syntax_type(*m_position)

- == regex_constants::escape_type_class)

- {

- char_class_type m = this->m_traits.lookup_classname(m_position, m_position+1);

- if(m != 0)

- {

- char_set.add_class(m);

- ++m_position;

- break;

- }

- }

- else if(this->m_traits.escape_syntax_type(*m_position)

- == regex_constants::escape_type_not_class)

- {

- // negated character class:

- char_class_type m = this->m_traits.lookup_classname(m_position, m_position+1);

- if(m != 0)

- {

- char_set.add_negated_class(m);

- ++m_position;

- break;

- }

- }

- // not a character class, just a regular escape:

- --m_position;

- parse_set_literal(char_set);

- break;

- }

- default:

- parse_set_literal(char_set);

- break;

- }

- }

- return m_position != m_end;

-}

-

-template <class charT, class traits>

-bool basic_regex_parser<charT, traits>::parse_inner_set(basic_char_set<charT, traits>& char_set)

-{

- //

- // we have either a character class [:name:]

- // a collating element [.name.]

- // or an equivalence class [=name=]

- //

- if(m_end == ++m_position)

- {

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

- return false;

- }

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

- {

- case regex_constants::syntax_dot:

- //

- // a collating element is treated as a literal:

- //

- --m_position;

- parse_set_literal(char_set);

- return true;

- case regex_constants::syntax_colon:

- {

- // check that character classes are actually enabled:

- if((this->flags() & (regbase::main_option_type | regbase::no_char_classes))

- == (regbase::basic_syntax_group | regbase::no_char_classes))

- {

- --m_position;

- parse_set_literal(char_set);

- return true;

- }

- // skip the ':'

- if(m_end == ++m_position)

- {

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

- return false;

- }

- const charT* name_first = m_position;

- // skip at least one character, then find the matching ':]'

- if(m_end == ++m_position)

- {

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

- return false;

- }

- while((m_position != m_end)

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

- ++m_position;

- const charT* name_last = m_position;

- if(m_end == m_position)

- {

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

- return false;

- }

- if((m_end == ++m_position)

- || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_set))

- {

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

- return false;

- }

- //

- // check for negated class:

- //

- bool negated = false;

- if(this->m_traits.syntax_type(*name_first) == regex_constants::syntax_caret)

- {

- ++name_first;

- negated = true;

- }

- typedef typename traits::char_class_type mask_type;

- mask_type m = this->m_traits.lookup_classname(name_first, name_last);

- if(m == 0)

- {

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

- {

- // maybe a special case:

- ++m_position;

- if( (m_position != m_end)

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

- == regex_constants::syntax_close_set))

- {

- if(this->m_traits.escape_syntax_type(*name_first)

- == regex_constants::escape_type_left_word)

- {

- ++m_position;

- this->append_state(syntax_element_word_start);

- return false;

- }

- if(this->m_traits.escape_syntax_type(*name_first)

- == regex_constants::escape_type_right_word)

- {

- ++m_position;

- this->append_state(syntax_element_word_end);

- return false;

- }

- }

- }

- fail(regex_constants::error_ctype, name_first - m_base);

- return false;

- }

- if(negated == false)

- char_set.add_class(m);

- else

- char_set.add_negated_class(m);

- ++m_position;

- break;

- }

- case regex_constants::syntax_equal:

- {

- // skip the '='

- if(m_end == ++m_position)

- {

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

- return false;

- }

- const charT* name_first = m_position;

- // skip at least one character, then find the matching '=]'

- if(m_end == ++m_position)

- {

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

- return false;

- }

- while((m_position != m_end)

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

- ++m_position;

- const charT* name_last = m_position;

- if(m_end == m_position)

- {

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

- return false;

- }

- if((m_end == ++m_position)

- || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_set))

- {

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

- return false;

- }

- string_type m = this->m_traits.lookup_collatename(name_first, name_last);

- if((0 == m.size()) || (m.size() > 2))

- {

- fail(regex_constants::error_collate, name_first - m_base);

- return false;

- }

- digraph<charT> d;

- d.first = m[0];

- if(m.size() > 1)

- d.second = m[1];

- else

- d.second = 0;

- char_set.add_equivalent(d);

- ++m_position;

- break;

- }

- default:

- --m_position;

- parse_set_literal(char_set);

- break;

- }

- return true;

-}

-

-template <class charT, class traits>

-void basic_regex_parser<charT, traits>::parse_set_literal(basic_char_set<charT, traits>& char_set)

-{

- digraph<charT> start_range(get_next_set_literal(char_set));

- if(m_end == m_position)

- {

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

- return;

- }

- if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_dash)

- {

- // we have a range:

- if(m_end == ++m_position)

- {

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

- return;

- }

- if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_set)

- {

- digraph<charT> end_range = get_next_set_literal(char_set);

- char_set.add_range(start_range, end_range);

- if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_dash)

- {

- if(m_end == ++m_position)

- {

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

- return;

- }

- if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_set)

- {

- // trailing - :

- --m_position;

- return;

- }

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

- return;

- }

- return;

- }

- --m_position;

- }

- char_set.add_single(start_range);

-}

-

-template <class charT, class traits>

-digraph<charT> basic_regex_parser<charT, traits>::get_next_set_literal(basic_char_set<charT, traits>& char_set)

-{

- digraph<charT> result;

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

- {

- case regex_constants::syntax_dash:

- if(!char_set.empty())

- {

- // see if we are at the end of the set:

- if((++m_position == m_end) || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_set))

- {

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

- return result;

- }

- --m_position;

- }

- result.first = *m_position++;

- return result;

- case regex_constants::syntax_escape:

- // check to see if escapes are supported first:

- if(this->flags() & regex_constants::no_escape_in_lists)

- {

- result = *m_position++;

- break;

- }

- ++m_position;

- result = unescape_character();

- break;

- case regex_constants::syntax_open_set:

- {

- if(m_end == ++m_position)

- {

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

- return result;

- }

- if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_dot)

- {

- --m_position;

- result.first = *m_position;

- ++m_position;

- return result;

- }

- if(m_end == ++m_position)

- {

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

- return result;

- }

- const charT* name_first = m_position;

- // skip at least one character, then find the matching ':]'

- if(m_end == ++m_position)

- {

- fail(regex_constants::error_collate, name_first - m_base);

- return result;

- }

- while((m_position != m_end)

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

- ++m_position;

- const charT* name_last = m_position;

- if(m_end == m_position)

- {

- fail(regex_constants::error_collate, name_first - m_base);

- return result;

- }

- if((m_end == ++m_position)

- || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_set))

- {

- fail(regex_constants::error_collate, name_first - m_base);

- return result;

- }

- ++m_position;

- string_type s = this->m_traits.lookup_collatename(name_first, name_last);

- if(s.empty() || (s.size() > 2))

- {

- fail(regex_constants::error_collate, name_first - m_base);

- return result;

- }

- result.first = s[0];

- if(s.size() > 1)

- result.second = s[1];

- else

- result.second = 0;

- return result;

- }

- default:

- result = *m_position++;

- }

- return result;

-}

-

-//

-// does a value fit in the specified charT type?

-//

-template <class charT>

-bool valid_value(charT, int v, const mpl::true_&)

-{

- return (v >> (sizeof(charT) * CHAR_BIT)) == 0;

-}

-template <class charT>

-bool valid_value(charT, int, const mpl::false_&)

-{

- return true; // v will alsways fit in a charT

-}

-template <class charT>

-bool valid_value(charT c, int v)

-{

- return valid_value(c, v, mpl::bool_<(sizeof(charT) < sizeof(int))>());

-}

-

-template <class charT, class traits>

-charT basic_regex_parser<charT, traits>::unescape_character()

-{

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable:4127)

-#endif

- charT result(0);

- if(m_position == m_end)

- {

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

- return false;

- }

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

- {

- case regex_constants::escape_type_control_a:

- result = charT('\a');

- break;

- case regex_constants::escape_type_e:

- result = charT(27);

- break;

- case regex_constants::escape_type_control_f:

- result = charT('\f');

- break;

- case regex_constants::escape_type_control_n:

- result = charT('\n');

- break;

- case regex_constants::escape_type_control_r:

- result = charT('\r');

- break;

- case regex_constants::escape_type_control_t:

- result = charT('\t');

- break;

- case regex_constants::escape_type_control_v:

- result = charT('\v');

- break;

- case regex_constants::escape_type_word_assert:

- result = charT('\b');

- break;

- case regex_constants::escape_type_ascii_control:

- ++m_position;

- if(m_position == m_end)

- {

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

- return result;

- }

- /*

- if((*m_position < charT('@'))

- || (*m_position > charT(125)) )

- {

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

- return result;

- }

- */

- result = static_cast<charT>(*m_position % 32);

- break;

- case regex_constants::escape_type_hex:

- ++m_position;

- if(m_position == m_end)

- {

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

- return result;

- }

- // maybe have \x{ddd}

- if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_open_brace)

- {

- ++m_position;

- if(m_position == m_end)

- {

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

- return result;

- }

- int i = this->m_traits.toi(m_position, m_end, 16);

- if((m_position == m_end)

- || (i < 0)

- || ((std::numeric_limits<charT>::is_specialized) && (charT(i) > (std::numeric_limits<charT>::max)()))

- || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_brace))

- {

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

- return result;

- }

- ++m_position;

- result = charT(i);

- }

- else

- {

- std::ptrdiff_t len = (std::min)(static_cast<std::ptrdiff_t>(2), m_end - m_position);

- int i = this->m_traits.toi(m_position, m_position + len, 16);

- if((i < 0)

- || !valid_value(charT(0), i))

- {

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

- return result;

- }

- result = charT(i);

- }

- return result;

- case regex_constants::syntax_digit:

- {

- // an octal escape sequence, the first character must be a zero

- // followed by up to 3 octal digits:

- std::ptrdiff_t len = (std::min)(::boost::re_detail::distance(m_position, m_end), static_cast<std::ptrdiff_t>(4));

- const charT* bp = m_position;

- int val = this->m_traits.toi(bp, bp + 1, 8);

- if(val != 0)

- {

- // Oops not an octal escape after all:

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

- return result;

- }

- val = this->m_traits.toi(m_position, m_position + len, 8);

- if(val < 0)

- {

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

- return result;

- }

- return static_cast<charT>(val);

- }

- case regex_constants::escape_type_named_char:

- {

- ++m_position;

- if(m_position == m_end)

- {

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

- return false;

- }

- // maybe have \N{name}

- if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_open_brace)

- {

- const charT* base = m_position;

- // skip forward until we find enclosing brace:

- while((m_position != m_end) && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_brace))

- ++m_position;

- if(m_position == m_end)

- {

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

- return false;

- }

- string_type s = this->m_traits.lookup_collatename(++base, m_position++);

- if(s.empty())

- {

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

- return false;

- }

- if(s.size() == 1)

- {

- return s[0];

- }

- }

- // fall through is a failure:

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

- return false;

- }

- default:

- result = *m_position;

- break;

- }

- ++m_position;

- return result;

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-}

-

-template <class charT, class traits>

-bool basic_regex_parser<charT, traits>::parse_backref()

-{

- BOOST_ASSERT(m_position != m_end);

- const charT* pc = m_position;

- int i = this->m_traits.toi(pc, pc + 1, 10);

- if((i == 0) || (((this->flags() & regbase::main_option_type) == regbase::perl_syntax_group) && (this->flags() & regbase::no_bk_refs)))

- {

- // not a backref at all but an octal escape sequence:

- charT c = unescape_character();

- this->append_literal(c);

- }

- else if((i > 0) && (this->m_backrefs & (1u << (i-1))))

- {

- m_position = pc;

- re_brace* pb = static_cast<re_brace*>(this->append_state(syntax_element_backref, sizeof(re_brace)));

- pb->index = i;

- }

- else

- {

- fail(regex_constants::error_backref, m_position - m_end);

- return false;

- }

- return true;

-}

-

-template <class charT, class traits>

-bool basic_regex_parser<charT, traits>::parse_QE()

-{

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable:4127)

-#endif

- //

- // parse a \Q...\E sequence:

- //

- ++m_position; // skip the Q

- const charT* start = m_position;

- const charT* end;

- do

- {

- while((m_position != m_end)

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

- ++m_position;

- if(m_position == m_end)

- {

- // a \Q...\E sequence may terminate with the end of the expression:

- end = m_position;

- break;

- }

- if(++m_position == m_end) // skip the escape

- {

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

- return false;

- }

- // check to see if it's a \E:

- if(this->m_traits.escape_syntax_type(*m_position) == regex_constants::escape_type_E)

- {

- ++m_position;

- end = m_position - 2;

- break;

- }

- // otherwise go round again:

- }while(true);

- //

- // now add all the character between the two escapes as literals:

- //

- while(start != end)

- {

- this->append_literal(*start);

- ++start;

- }

- return true;

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-}

-

-template <class charT, class traits>

-bool basic_regex_parser<charT, traits>::parse_perl_extension()

-{

- if(++m_position == m_end)

- {

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

- return false;

- }

- //

- // treat comments as a special case, as these

- // are the only ones that don't start with a leading

- // startmark state:

- //

- if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_hash)

- {

- while((m_position != m_end)

- && (this->m_traits.syntax_type(*m_position++) != regex_constants::syntax_close_mark))

- {}

- return true;

- }

- //

- // backup some state, and prepare the way:

- //

- int markid = 0;

- std::ptrdiff_t jump_offset = 0;

- re_brace* pb = static_cast<re_brace*>(this->append_state(syntax_element_startmark, sizeof(re_brace)));

- std::ptrdiff_t last_paren_start = this->getoffset(pb);

- // back up insertion point for alternations, and set new point:

- std::ptrdiff_t last_alt_point = m_alt_insert_point;

- this->m_pdata->m_data.align();

- m_alt_insert_point = this->m_pdata->m_data.size();

- std::ptrdiff_t expected_alt_point = m_alt_insert_point;

- bool restore_flags = true;

- regex_constants::syntax_option_type old_flags = this->flags();

- bool old_case_change = m_has_case_change;

- m_has_case_change = false;

- //

- // select the actual extension used:

- //

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

- {

- case regex_constants::syntax_colon:

- //

- // a non-capturing mark:

- //

- pb->index = markid = 0;

- ++m_position;

- break;

- case regex_constants::syntax_equal:

- pb->index = markid = -1;

- ++m_position;

- jump_offset = this->getoffset(this->append_state(syntax_element_jump, sizeof(re_jump)));

- this->m_pdata->m_data.align();

- m_alt_insert_point = this->m_pdata->m_data.size();

- break;

- case regex_constants::syntax_not:

- pb->index = markid = -2;

- ++m_position;

- jump_offset = this->getoffset(this->append_state(syntax_element_jump, sizeof(re_jump)));

- this->m_pdata->m_data.align();

- m_alt_insert_point = this->m_pdata->m_data.size();

- break;

- case regex_constants::escape_type_left_word:

- {

- // a lookbehind assertion:

- if(++m_position == m_end)

- {

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

- return false;

- }

- regex_constants::syntax_type t = this->m_traits.syntax_type(*m_position);

- if(t == regex_constants::syntax_not)

- pb->index = markid = -2;

- else if(t == regex_constants::syntax_equal)

- pb->index = markid = -1;

- else

- {

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

- return false;

- }

- ++m_position;

- jump_offset = this->getoffset(this->append_state(syntax_element_jump, sizeof(re_jump)));

- this->append_state(syntax_element_backstep, sizeof(re_brace));

- this->m_pdata->m_data.align();

- m_alt_insert_point = this->m_pdata->m_data.size();

- break;

- }

- case regex_constants::escape_type_right_word:

- //

- // an independent sub-expression:

- //

- pb->index = markid = -3;

- ++m_position;

- jump_offset = this->getoffset(this->append_state(syntax_element_jump, sizeof(re_jump)));

- this->m_pdata->m_data.align();

- m_alt_insert_point = this->m_pdata->m_data.size();

- break;

- case regex_constants::syntax_open_mark:

- {

- // a conditional expression:

- pb->index = markid = -4;

- if(++m_position == m_end)

- {

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

- return false;

- }

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

- if(v > 0)

- {

- re_brace* br = static_cast<re_brace*>(this->append_state(syntax_element_assert_backref, sizeof(re_brace)));

- br->index = v;

- if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark)

- {

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

- return false;

- }

- if(++m_position == m_end)

- {

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

- return false;

- }

- }

- else

- {

- // verify that we have a lookahead or lookbehind assert:

- if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_question)

- {

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

- return false;

- }

- if(++m_position == m_end)

- {

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

- return false;

- }

- if(this->m_traits.syntax_type(*m_position) == regex_constants::escape_type_left_word)

- {

- if(++m_position == m_end)

- {

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

- return false;

- }

- if((this->m_traits.syntax_type(*m_position) != regex_constants::syntax_equal)

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

- {

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

- return false;

- }

- m_position -= 3;

- }

- else

- {

- if((this->m_traits.syntax_type(*m_position) != regex_constants::syntax_equal)

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

- {

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

- return false;

- }

- m_position -= 2;

- }

- }

- break;

- }

- case regex_constants::syntax_close_mark:

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

- return false;

- default:

- //

- // lets assume that we have a (?imsx) group and try and parse it:

- //

- regex_constants::syntax_option_type opts = parse_options();

- if(m_position == m_end)

- return false;

- // make a note of whether we have a case change:

- m_has_case_change = ((opts & regbase::icase) != (this->flags() & regbase::icase));

- pb->index = markid = 0;

- if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark)

- {

- // update flags and carry on as normal:

- this->flags(opts);

- restore_flags = false;

- old_case_change |= m_has_case_change; // defer end of scope by one ')'

- }

- else if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_colon)

- {

- // update flags and carry on until the matching ')' is found:

- this->flags(opts);

- ++m_position;

- }

- else

- {

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

- return false;

- }

-

- // finally append a case change state if we need it:

- if(m_has_case_change)

- {

- static_cast<re_case*>(

- this->append_state(syntax_element_toggle_case, sizeof(re_case))

- )->icase = opts & regbase::icase;

- }

-

- }

- //

- // now recursively add more states, this will terminate when we get to a

- // matching ')' :

- //

- parse_all();

- //

- // Unwind alternatives:

- //

- if(0 == unwind_alts(last_paren_start))

- return false;

- //

- // we either have a ')' or we have run out of characters prematurely:

- //

- if(m_position == m_end)

- {

- this->fail(regex_constants::error_paren, ::boost::re_detail::distance(m_base, m_end));

- return false;

- }

- BOOST_ASSERT(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark);

- ++m_position;

- //

- // restore the flags:

- //

- if(restore_flags)

- {

- // append a case change state if we need it:

- if(m_has_case_change)

- {

- static_cast<re_case*>(

- this->append_state(syntax_element_toggle_case, sizeof(re_case))

- )->icase = old_flags & regbase::icase;

- }

- this->flags(old_flags);

- }

- //

- // set up the jump pointer if we have one:

- //

- if(jump_offset)

- {

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

- {

- // Oops... we didn't have anything inside the assertion:

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

- return false;

- }

- }

- //

- // verify that if this is conditional expression, that we do have

- // an alternative, if not add one:

- //

- if(markid == -4)

- {

- re_syntax_base* b = this->getaddress(expected_alt_point);

- // Make sure we have exactly one alternative following this state:

- if(b->type != syntax_element_alt)

- {

- re_alt* alt = static_cast<re_alt*>(this->insert_state(expected_alt_point, syntax_element_alt, sizeof(re_alt)));

- alt->alt.i = this->m_pdata->m_data.size() - this->getoffset(alt);

- }

- else if(this->getaddress(static_cast<re_alt*>(b)->alt.i, b)->type == syntax_element_alt)

- {

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

- return false;

- }

- // check for invalid repetition of next state:

- b = this->getaddress(expected_alt_point);

- b = this->getaddress(static_cast<re_alt*>(b)->next.i, b);

- if((b->type != syntax_element_assert_backref)

- && (b->type != syntax_element_startmark))

- {

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

- return false;

- }

- }

- //

- // append closing parenthesis state:

- //

- pb = static_cast<re_brace*>(this->append_state(syntax_element_endmark, sizeof(re_brace)));

- pb->index = markid;

- this->m_paren_start = last_paren_start;

- //

- // restore the alternate insertion point:

- //

- this->m_alt_insert_point = last_alt_point;

- //

- // and the case change data:

- //

- m_has_case_change = old_case_change;

- return true;

-}

-

-template <class charT, class traits>

-bool basic_regex_parser<charT, traits>::add_emacs_code(bool negate)

-{

- //

- // parses an emacs style \sx or \Sx construct.

- //

- if(++m_position == m_end)

- {

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

- return false;

- }

- basic_char_set<charT, traits> char_set;

- if(negate)

- char_set.negate();

-

- static const charT s_punct[5] = { 'p', 'u', 'n', 'c', 't', };

-

- switch(*m_position)

- {

- case 's':

- case ' ':

- char_set.add_class(this->m_mask_space);

- break;

- case 'w':

- char_set.add_class(this->m_word_mask);

- break;

- case '_':

- char_set.add_single(digraph<charT>(charT('$')));

- char_set.add_single(digraph<charT>(charT('&')));

- char_set.add_single(digraph<charT>(charT('*')));

- char_set.add_single(digraph<charT>(charT('+')));

- char_set.add_single(digraph<charT>(charT('-')));

- char_set.add_single(digraph<charT>(charT('_')));

- char_set.add_single(digraph<charT>(charT('<')));

- char_set.add_single(digraph<charT>(charT('>')));

- break;

- case '.':

- char_set.add_class(this->m_traits.lookup_classname(s_punct, s_punct+5));

- break;

- case '(':

- char_set.add_single(digraph<charT>(charT('(')));

- char_set.add_single(digraph<charT>(charT('[')));

- char_set.add_single(digraph<charT>(charT('{')));

- break;

- case ')':

- char_set.add_single(digraph<charT>(charT(')')));

- char_set.add_single(digraph<charT>(charT(']')));

- char_set.add_single(digraph<charT>(charT('}')));

- break;

- case '"':

- char_set.add_single(digraph<charT>(charT('"')));

- char_set.add_single(digraph<charT>(charT('\'')));

- char_set.add_single(digraph<charT>(charT('`')));

- break;

- case '\'':

- char_set.add_single(digraph<charT>(charT('\'')));

- char_set.add_single(digraph<charT>(charT(',')));

- char_set.add_single(digraph<charT>(charT('#')));

- break;

- case '<':

- char_set.add_single(digraph<charT>(charT(';')));

- break;

- case '>':

- char_set.add_single(digraph<charT>(charT('\n')));

- char_set.add_single(digraph<charT>(charT('\f')));

- break;

- default:

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

- return false;

- }

- if(0 == this->append_set(char_set))

- {

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

- return false;

- }

- ++m_position;

- return true;

-}

-

-template <class charT, class traits>

-regex_constants::syntax_option_type basic_regex_parser<charT, traits>::parse_options()

-{

- // we have a (?imsx-imsx) group, convert it into a set of flags:

- regex_constants::syntax_option_type f = this->flags();

- bool breakout = false;

- do

- {

- switch(*m_position)

- {

- case 's':

- f |= regex_constants::mod_s;

- f &= ~regex_constants::no_mod_s;

- break;

- case 'm':

- f &= ~regex_constants::no_mod_m;

- break;

- case 'i':

- f |= regex_constants::icase;

- break;

- case 'x':

- f |= regex_constants::mod_x;

- break;

- default:

- breakout = true;

- continue;

- }

- if(++m_position == m_end)

- {

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

- return false;

- }

- }

- while(!breakout);

-

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

- {

- if(++m_position == m_end)

- {

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

- return false;

- }

- do

- {

- switch(*m_position)

- {

- case 's':

- f &= ~regex_constants::mod_s;

- f |= regex_constants::no_mod_s;

- break;

- case 'm':

- f |= regex_constants::no_mod_m;

- break;

- case 'i':

- f &= ~regex_constants::icase;

- break;

- case 'x':

- f &= ~regex_constants::mod_x;

- break;

- default:

- breakout = true;

- continue;

- }

- if(++m_position == m_end)

- {

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

- return false;

- }

- }

- while(!breakout);

- }

- return f;

-}

-

-template <class charT, class traits>

-bool basic_regex_parser<charT, traits>::unwind_alts(std::ptrdiff_t last_paren_start)

-{

- //

- // If we didn't actually add any states after the last

- // alternative then that's an error:

- //

- if((this->m_alt_insert_point == static_cast<std::ptrdiff_t>(this->m_pdata->m_data.size()))

- && m_alt_jumps.size() && (m_alt_jumps.back() > last_paren_start)

- &&

- !(

- ((this->flags() & regbase::main_option_type) == regbase::perl_syntax_group)

- &&

- ((this->flags() & regbase::no_empty_expressions) == 0)

- )

- )

- {

- fail(regex_constants::error_empty, this->m_position - this->m_base);

- return false;

- }

- //

- // Fix up our alternatives:

- //

- while(m_alt_jumps.size() && (m_alt_jumps.back() > last_paren_start))

- {

- //

- // fix up the jump to point to the end of the states

- // that we've just added:

- //

- std::ptrdiff_t jump_offset = m_alt_jumps.back();

- m_alt_jumps.pop_back();

- this->m_pdata->m_data.align();

- re_jump* jmp = static_cast<re_jump*>(this->getaddress(jump_offset));

- BOOST_ASSERT(jmp->type == syntax_element_jump);

- jmp->alt.i = this->m_pdata->m_data.size() - jump_offset;

- }

- return true;

-}

-

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-} // namespace re_detail

-} // namespace boost

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_SUFFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-#endif

-/*

- *

- * Copyright (c) 2004

- * John Maddock

- *

- * 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 c_regex_traits.hpp

- * VERSION see <boost/version.hpp>

- * DESCRIPTION: Declares regular expression traits class that wraps the global C locale.

- */

-

-#ifndef BOOST_C_REGEX_TRAITS_HPP_INCLUDED

-#define BOOST_C_REGEX_TRAITS_HPP_INCLUDED

-

-#ifndef BOOST_REGEX_CONFIG_HPP

-#include <boost/regex/config.hpp>

-#endif

-#ifndef BOOST_REGEX_WORKAROUND_HPP

-#include <boost/regex/v4/regex_workaround.hpp>

-#endif

-

-#include <cctype>

-

-#ifdef BOOST_NO_STDC_NAMESPACE

-namespace std{

- using ::strlen; using ::tolower;

-}

-#endif

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_PREFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-namespace boost{

-

-template <class charT>

-struct c_regex_traits;

-

-template<>

-struct BOOST_REGEX_DECL c_regex_traits<char>

-{

- c_regex_traits(){}

- typedef char char_type;

- typedef std::size_t size_type;

- typedef std::string string_type;

- struct locale_type{};

- typedef boost::uint32_t char_class_type;

-

- static size_type length(const char_type* p)

- {

- return (std::strlen)(p);

- }

-

- char translate(char c) const

- {

- return c;

- }

- char translate_nocase(char c) const

- {

- return static_cast<char>((std::tolower)(static_cast<unsigned char>(c)));

- }

-

- static string_type BOOST_REGEX_CALL transform(const char* p1, const char* p2);

- static string_type BOOST_REGEX_CALL transform_primary(const char* p1, const char* p2);

-

- static char_class_type BOOST_REGEX_CALL lookup_classname(const char* p1, const char* p2);

- static string_type BOOST_REGEX_CALL lookup_collatename(const char* p1, const char* p2);

-

- static bool BOOST_REGEX_CALL isctype(char, char_class_type);

- static int BOOST_REGEX_CALL value(char, int);

-

- locale_type imbue(locale_type l)

- { return l; }

- locale_type getloc()const

- { return locale_type(); }

-

-private:

- // this type is not copyable:

- c_regex_traits(const c_regex_traits&);

- c_regex_traits& operator=(const c_regex_traits&);

-};

-

-#ifndef BOOST_NO_WREGEX

-template<>

-struct BOOST_REGEX_DECL c_regex_traits<wchar_t>

-{

- c_regex_traits(){}

- typedef wchar_t char_type;

- typedef std::size_t size_type;

- typedef std::wstring string_type;

- struct locale_type{};

- typedef boost::uint32_t char_class_type;

-

- static size_type length(const char_type* p)

- {

- return (std::wcslen)(p);

- }

-

- wchar_t translate(wchar_t c) const

- {

- return c;

- }

- wchar_t translate_nocase(wchar_t c) const

- {

- return (std::towlower)(c);

- }

-

- static string_type BOOST_REGEX_CALL transform(const wchar_t* p1, const wchar_t* p2);

- static string_type BOOST_REGEX_CALL transform_primary(const wchar_t* p1, const wchar_t* p2);

-

- static char_class_type BOOST_REGEX_CALL lookup_classname(const wchar_t* p1, const wchar_t* p2);

- static string_type BOOST_REGEX_CALL lookup_collatename(const wchar_t* p1, const wchar_t* p2);

-

- static bool BOOST_REGEX_CALL isctype(wchar_t, char_class_type);

- static int BOOST_REGEX_CALL value(wchar_t, int);

-

- locale_type imbue(locale_type l)

- { return l; }

- locale_type getloc()const

- { return locale_type(); }

-

-private:

- // this type is not copyable:

- c_regex_traits(const c_regex_traits&);

- c_regex_traits& operator=(const c_regex_traits&);

-};

-

-#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T

-//

-// Provide an unsigned short version as well, so the user can link to this

-// no matter whether they build with /Zc:wchar_t or not (MSVC specific).

-//

-template<>

-struct BOOST_REGEX_DECL c_regex_traits<unsigned short>

-{

- c_regex_traits(){}

- typedef unsigned short char_type;

- typedef std::size_t size_type;

- typedef std::basic_string<unsigned short> string_type;

- struct locale_type{};

- typedef boost::uint32_t char_class_type;

-

- static size_type length(const char_type* p)

- {

- return (std::wcslen)((const wchar_t*)p);

- }

-

- unsigned short translate(unsigned short c) const

- {

- return c;

- }

- unsigned short translate_nocase(unsigned short c) const

- {

- return (std::towlower)((wchar_t)c);

- }

-

- static string_type BOOST_REGEX_CALL transform(const unsigned short* p1, const unsigned short* p2);

- static string_type BOOST_REGEX_CALL transform_primary(const unsigned short* p1, const unsigned short* p2);

-

- static char_class_type BOOST_REGEX_CALL lookup_classname(const unsigned short* p1, const unsigned short* p2);

- static string_type BOOST_REGEX_CALL lookup_collatename(const unsigned short* p1, const unsigned short* p2);

-

- static bool BOOST_REGEX_CALL isctype(unsigned short, char_class_type);

- static int BOOST_REGEX_CALL value(unsigned short, int);

-

- locale_type imbue(locale_type l)

- { return l; }

- locale_type getloc()const

- { return locale_type(); }

-

-private:

- // this type is not copyable:

- c_regex_traits(const c_regex_traits&);

- c_regex_traits& operator=(const c_regex_traits&);

-};

-

-#endif

-

-#endif // BOOST_NO_WREGEX

-

-}

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_SUFFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-#endif

-

-

-

-/*

- *

- * Copyright (c) 2002

- * John Maddock

- *

- * 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 char_regex_traits.cpp

- * VERSION see <boost/version.hpp>

- * DESCRIPTION: Declares deprecated traits classes char_regex_traits<>.

- */

-

-

-#ifndef BOOST_REGEX_V4_CHAR_REGEX_TRAITS_HPP

-#define BOOST_REGEX_V4_CHAR_REGEX_TRAITS_HPP

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_PREFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-namespace boost{

-

-namespace deprecated{

-//

-// class char_regex_traits_i

-// provides case insensitive traits classes (deprecated):

-template <class charT>

-class char_regex_traits_i : public regex_traits<charT> {};

-

-template<>

-class char_regex_traits_i<char> : public regex_traits<char>

-{

-public:

- typedef char char_type;

- typedef unsigned char uchar_type;

- typedef unsigned int size_type;

- typedef regex_traits<char> base_type;

-

-};

-

-#ifndef BOOST_NO_WREGEX

-template<>

-class char_regex_traits_i<wchar_t> : public regex_traits<wchar_t>

-{

-public:

- typedef wchar_t char_type;

- typedef unsigned short uchar_type;

- typedef unsigned int size_type;

- typedef regex_traits<wchar_t> base_type;

-

-};

-#endif

-} // namespace deprecated

-} // namespace boost

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_SUFFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-#endif // include

-

-/*

- *

- * Copyright (c) 2004

- * John Maddock

- *

- * 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 cpp_regex_traits.hpp

- * VERSION see <boost/version.hpp>

- * DESCRIPTION: Declares regular expression traits class cpp_regex_traits.

- */

-

-#ifndef BOOST_CPP_REGEX_TRAITS_HPP_INCLUDED

-#define BOOST_CPP_REGEX_TRAITS_HPP_INCLUDED

-

-#include <boost/config.hpp>

-

-#ifndef BOOST_NO_STD_LOCALE

-

-#ifndef BOOST_RE_PAT_EXCEPT_HPP

-#include <boost/regex/pattern_except.hpp>

-#endif

-#ifndef BOOST_REGEX_TRAITS_DEFAULTS_HPP_INCLUDED

-#include <boost/regex/v4/regex_traits_defaults.hpp>

-#endif

-#ifdef BOOST_HAS_THREADS

-#include <boost/regex/pending/static_mutex.hpp>

-#endif

-#ifndef BOOST_REGEX_PRIMARY_TRANSFORM

-#include <boost/regex/v4/primary_transform.hpp>

-#endif

-#ifndef BOOST_REGEX_OBJECT_CACHE_HPP

-#include <boost/regex/pending/object_cache.hpp>

-#endif

-

-#include <istream>

-#include <ios>

-#include <climits>

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_PREFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable:4786)

-#endif

-

-namespace boost{

-

-//

-// forward declaration is needed by some compilers:

-//

-template <class charT>

-class cpp_regex_traits;

-

-namespace re_detail{

-

-//

-// class parser_buf:

-// acts as a stream buffer which wraps around a pair of pointers:

-//

-template <class charT,

- class traits = ::std::char_traits<charT> >

-class parser_buf : public ::std::basic_streambuf<charT, traits>

-{

- typedef ::std::basic_streambuf<charT, traits> base_type;

- typedef typename base_type::int_type int_type;

- typedef typename base_type::char_type char_type;

- typedef typename base_type::pos_type pos_type;

- typedef ::std::streamsize streamsize;

- typedef typename base_type::off_type off_type;

-public:

- parser_buf() : base_type() { setbuf(0, 0); }

- const charT* getnext() { return this->gptr(); }

-protected:

- std::basic_streambuf<charT, traits>* setbuf(char_type* s, streamsize n);

- typename parser_buf<charT, traits>::pos_type seekpos(pos_type sp, ::std::ios_base::openmode which);

- typename parser_buf<charT, traits>::pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which);

-private:

- parser_buf& operator=(const parser_buf&);

- parser_buf(const parser_buf&);

-};

-

-template<class charT, class traits>

-std::basic_streambuf<charT, traits>*

-parser_buf<charT, traits>::setbuf(char_type* s, streamsize n)

-{

- this->setg(s, s, s + n);

- return this;

-}

-

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

-{

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

- {

- case ::std::ios_base::beg:

- if((off < 0) || (off > size))

- return pos_type(off_type(-1));

- else

- this->setg(g, g + off, g + size);

- break;

- case ::std::ios_base::end:

- if((off < 0) || (off > size))

- return pos_type(off_type(-1));

- else

- this->setg(g, g + size - off, g + size);

- break;

- case ::std::ios_base::cur:

- {

- std::ptrdiff_t newpos = static_cast<std::ptrdiff_t>(pos + off);

- if((newpos < 0) || (newpos > size))

- return pos_type(off_type(-1));

- else

- this->setg(g, g + newpos, g + size);

- break;

- }

- default: ;

- }

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable:4244)

-#endif

- return static_cast<pos_type>(this->gptr() - this->eback());

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-}

-

-template<class charT, class traits>

-typename parser_buf<charT, traits>::pos_type

-parser_buf<charT, traits>::seekpos(pos_type sp, ::std::ios_base::openmode which)

-{

- if(which & ::std::ios_base::out)

- return pos_type(off_type(-1));

- off_type size = static_cast<off_type>(this->egptr() - this->eback());

- charT* g = this->eback();

- if(off_type(sp) <= size)

- {

- this->setg(g, g + off_type(sp), g + size);

- }

- return pos_type(off_type(-1));

-}

-

-//

-// class cpp_regex_traits_base:

-// acts as a container for locale and the facets we are using.

-//

-template <class charT>

-struct cpp_regex_traits_base

-{

- cpp_regex_traits_base(const std::locale& l)

- { imbue(l); }

- std::locale imbue(const std::locale& l);

-

- std::locale m_locale;

- std::ctype<charT> const* m_pctype;

-#ifndef BOOST_NO_STD_MESSAGES

- std::messages<charT> const* m_pmessages;

-#endif

- std::collate<charT> const* m_pcollate;

-

- bool operator<(const cpp_regex_traits_base& b)const

- {

- if(m_pctype == b.m_pctype)

- {

-#ifndef BOOST_NO_STD_MESSAGES

- if(m_pmessages == b.m_pmessages)

- {

- }

- return m_pmessages < b.m_pmessages;

-#else

- return m_pcollate < b.m_pcollate;

-#endif

- }

- return m_pctype < b.m_pctype;

- }

- bool operator==(const cpp_regex_traits_base& b)const

- {

- return (m_pctype == b.m_pctype)

-#ifndef BOOST_NO_STD_MESSAGES

- && (m_pmessages == b.m_pmessages)

-#endif

- && (m_pcollate == b.m_pcollate);

- }

-};

-

-template <class charT>

-std::locale cpp_regex_traits_base<charT>::imbue(const std::locale& l)

-{

- std::locale result(m_locale);

- m_locale = l;

- m_pctype = &BOOST_USE_FACET(std::ctype<charT>, l);

-#ifndef BOOST_NO_STD_MESSAGES

- m_pmessages = &BOOST_USE_FACET(std::messages<charT>, l);

-#endif

- m_pcollate = &BOOST_USE_FACET(std::collate<charT>, l);

- return result;

-}

-

-//

-// class cpp_regex_traits_char_layer:

-// implements methods that require specialisation for narrow characters:

-//

-template <class charT>

-class cpp_regex_traits_char_layer : public cpp_regex_traits_base<charT>

-{

- typedef std::basic_string<charT> string_type;

- typedef std::map<charT, regex_constants::syntax_type> map_type;

- typedef typename map_type::const_iterator map_iterator_type;

-public:

- cpp_regex_traits_char_layer(const std::locale& l)

- : cpp_regex_traits_base<charT>(l)

- {

- init();

- }

- cpp_regex_traits_char_layer(const cpp_regex_traits_base<charT>& b)

- : cpp_regex_traits_base<charT>(b)

- {

- init();

- }

- void init();

-

- regex_constants::syntax_type syntax_type(charT c)const

- {

- map_iterator_type i = m_char_map.find(c);

- return ((i == m_char_map.end()) ? 0 : i->second);

- }

- regex_constants::escape_syntax_type escape_syntax_type(charT c) const

- {

- map_iterator_type i = m_char_map.find(c);

- if(i == m_char_map.end())

- {

- if(this->m_pctype->is(std::ctype_base::lower, c)) return regex_constants::escape_type_class;

- if(this->m_pctype->is(std::ctype_base::upper, c)) return regex_constants::escape_type_not_class;

- return 0;

- }

- return i->second;

- }

-

-private:

- string_type get_default_message(regex_constants::syntax_type);

- // TODO: use a hash table when available!

- map_type m_char_map;

-};

-

-template <class charT>

-void cpp_regex_traits_char_layer<charT>::init()

-{

- // we need to start by initialising our syntax map so we know which

- // character is used for which purpose:

-#ifndef BOOST_NO_STD_MESSAGES

-#ifndef __IBMCPP__

- typename std::messages<charT>::catalog cat = static_cast<std::messages<char>::catalog>(-1);

-#else

- typename std::messages<charT>::catalog cat = reinterpret_cast<std::messages<char>::catalog>(-1);

-#endif

- std::string cat_name(cpp_regex_traits<charT>::get_catalog_name());

- if(cat_name.size())

- {

- cat = this->m_pmessages->open(

- cat_name,

- this->m_locale);

- if((int)cat < 0)

- {

- std::string m("Unable to open message catalog: ");

- std::runtime_error err(m + cat_name);

- boost::re_detail::raise_runtime_error(err);

- }

- }

- //

- // if we have a valid catalog then load our messages:

- //

- if((int)cat >= 0)

- {

-#ifndef BOOST_NO_EXCEPTIONS

- try{

-#endif

- for(regex_constants::syntax_type i = 1; i < regex_constants::syntax_max; ++i)

- {

- string_type mss = this->m_pmessages->get(cat, 0, i, get_default_message(i));

- for(typename string_type::size_type j = 0; j < mss.size(); ++j)

- {

- m_char_map[mss[j]] = i;

- }

- }

- this->m_pmessages->close(cat);

-#ifndef BOOST_NO_EXCEPTIONS

- }

- catch(...)

- {

- this->m_pmessages->close(cat);

- throw;

- }

-#endif

- }

- else

- {

-#endif

- for(regex_constants::syntax_type i = 1; i < regex_constants::syntax_max; ++i)

- {

- const char* ptr = get_default_syntax(i);

- while(ptr && *ptr)

- {

- m_char_map[this->m_pctype->widen(*ptr)] = i;

- ++ptr;

- }

- }

-#ifndef BOOST_NO_STD_MESSAGES

- }

-#endif

-}

-

-template <class charT>

-typename cpp_regex_traits_char_layer<charT>::string_type

- cpp_regex_traits_char_layer<charT>::get_default_message(regex_constants::syntax_type i)

-{

- const char* ptr = get_default_syntax(i);

- string_type result;

- while(ptr && *ptr)

- {

- result.append(1, this->m_pctype->widen(*ptr));

- ++ptr;

- }

- return result;

-}

-

-//

-// specialised version for narrow characters:

-//

-template <>

-class BOOST_REGEX_DECL cpp_regex_traits_char_layer<char> : public cpp_regex_traits_base<char>

-{

- typedef std::string string_type;

-public:

- cpp_regex_traits_char_layer(const std::locale& l)

- : cpp_regex_traits_base<char>(l)

- {

- init();

- }

- cpp_regex_traits_char_layer(const cpp_regex_traits_base<char>& l)

- : cpp_regex_traits_base<char>(l)

- {

- init();

- }

-

- regex_constants::syntax_type syntax_type(char c)const

- {

- return m_char_map[static_cast<unsigned char>(c)];

- }

- regex_constants::escape_syntax_type escape_syntax_type(char c) const

- {

- return m_char_map[static_cast<unsigned char>(c)];

- }

-

-private:

- regex_constants::syntax_type m_char_map[1u << CHAR_BIT];

- void init();

-};

-

-#ifdef BOOST_REGEX_BUGGY_CTYPE_FACET

-enum

-{

- char_class_space=1<<0,

- char_class_print=1<<1,

- char_class_cntrl=1<<2,

- char_class_upper=1<<3,

- char_class_lower=1<<4,

- char_class_alpha=1<<5,

- char_class_digit=1<<6,

- char_class_punct=1<<7,

- char_class_xdigit=1<<8,

- char_class_alnum=char_class_alpha|char_class_digit,

- char_class_graph=char_class_alnum|char_class_punct,

- char_class_blank=1<<9,

- char_class_word=1<<10,

- char_class_unicode=1<<11

-};

-

-#endif

-

-//

-// class cpp_regex_traits_implementation:

-// provides pimpl implementation for cpp_regex_traits.

-//

-template <class charT>

-class cpp_regex_traits_implementation : public cpp_regex_traits_char_layer<charT>

-{

-public:

- typedef typename cpp_regex_traits<charT>::char_class_type char_class_type;

- typedef typename std::ctype<charT>::mask native_mask_type;

-#ifndef BOOST_REGEX_BUGGY_CTYPE_FACET

- BOOST_STATIC_CONSTANT(char_class_type, mask_blank = 1u << 24);

- BOOST_STATIC_CONSTANT(char_class_type, mask_word = 1u << 25);

- BOOST_STATIC_CONSTANT(char_class_type, mask_unicode = 1u << 26);

-#endif

-

- typedef std::basic_string<charT> string_type;

- typedef charT char_type;

- //cpp_regex_traits_implementation();

- cpp_regex_traits_implementation(const std::locale& l)

- : cpp_regex_traits_char_layer<charT>(l)

- {

- init();

- }

- cpp_regex_traits_implementation(const cpp_regex_traits_base<charT>& l)

- : cpp_regex_traits_char_layer<charT>(l)

- {

- init();

- }

- std::string error_string(regex_constants::error_type n) const

- {

- if(!m_error_strings.empty())

- {

- std::map<int, std::string>::const_iterator p = m_error_strings.find(n);

- return (p == m_error_strings.end()) ? std::string(get_default_error_string(n)) : p->second;

- }

- return get_default_error_string(n);

- }

- char_class_type lookup_classname(const charT* p1, const charT* p2) const

- {

- char_class_type result = lookup_classname_imp(p1, p2);

- if(result == 0)

- {

- string_type temp(p1, p2);

- this->m_pctype->tolower(&*temp.begin(), &*temp.begin() + temp.size());

- result = lookup_classname_imp(&*temp.begin(), &*temp.begin() + temp.size());

- }

- return result;

- }

- string_type lookup_collatename(const charT* p1, const charT* p2) const;

- string_type transform_primary(const charT* p1, const charT* p2) const;

- string_type transform(const charT* p1, const charT* p2) const;

-private:

- std::map<int, std::string> m_error_strings; // error messages indexed by numberic ID

- std::map<string_type, char_class_type> m_custom_class_names; // character class names

- std::map<string_type, string_type> m_custom_collate_names; // collating element names

- unsigned m_collate_type; // the form of the collation string

- charT m_collate_delim; // the collation group delimiter

- //

- // helpers:

- //

- char_class_type lookup_classname_imp(const charT* p1, const charT* p2) const;

- void init();

-#ifdef BOOST_REGEX_BUGGY_CTYPE_FACET

-public:

- bool isctype(charT c, char_class_type m)const;

-#endif

-};

-

-#ifndef BOOST_REGEX_BUGGY_CTYPE_FACET

-#if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)

-

-template <class charT>

-typename cpp_regex_traits_implementation<charT>::char_class_type const cpp_regex_traits_implementation<charT>::mask_blank;

-template <class charT>

-typename cpp_regex_traits_implementation<charT>::char_class_type const cpp_regex_traits_implementation<charT>::mask_word;

-template <class charT>

-typename cpp_regex_traits_implementation<charT>::char_class_type const cpp_regex_traits_implementation<charT>::mask_unicode;

-

-#endif

-#endif

-

-template <class charT>

-typename cpp_regex_traits_implementation<charT>::string_type

- cpp_regex_traits_implementation<charT>::transform_primary(const charT* p1, const charT* p2) const

-{

- //

- // PRECONDITIONS:

- //

- // A bug in gcc 3.2 (and maybe other versions as well) treats

- // p1 as a null terminated string, for efficiency reasons

- // we work around this elsewhere, but just assert here that

- // we adhere to gcc's (buggy) preconditions...

- //

- BOOST_ASSERT(*p2 == 0);

-

- string_type result;

- //

- // swallowing all exceptions here is a bad idea

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

- //

- switch(m_collate_type)

- {

- case sort_C:

- case sort_unknown:

- // the best we can do is translate to lower case, then get a regular sort key:

- {

- result.assign(p1, p2);

- this->m_pctype->tolower(&*result.begin(), &*result.begin() + result.size());

- result = this->m_pcollate->transform(&*result.begin(), &*result.begin() + result.size());

- break;

- }

- case sort_fixed:

- {

- // get a regular sort key, and then truncate it:

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

- result.erase(this->m_collate_delim);

- break;

- }

- case sort_delim:

- // get a regular sort key, and then truncate everything after the delim:

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

- std::size_t i;

- for(i = 0; i < result.size(); ++i)

- {

- if(result[i] == m_collate_delim)

- break;

- }

- result.erase(i);

- break;

- }

- }catch(...){}

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

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

- if(result.empty())

- {

- // character is ignorable at the primary level:

- result = string_type(1, charT(0));

- }

- return result;

-}

-

-template <class charT>

-typename cpp_regex_traits_implementation<charT>::string_type

- cpp_regex_traits_implementation<charT>::transform(const charT* p1, const charT* p2) const

-{

- //

- // PRECONDITIONS:

- //

- // A bug in gcc 3.2 (and maybe other versions as well) treats

- // p1 as a null terminated string, for efficiency reasons

- // we work around this elsewhere, but just assert here that

- // we adhere to gcc's (buggy) preconditions...

- //

- BOOST_ASSERT(*p2 == 0);

- //

- // swallowing all exceptions here is a bad idea

- // however at least one std lib will always throw

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

- // string that has garbage at the end - each call to

- // std::collate<wchar_t>::transform returns a different string!

- // So as a workaround, we'll truncate the string at the first NULL

- // which _seems_ to work....

-#if BOOST_WORKAROUND(__BORLANDC__, < 0x580)

- result.erase(result.find(charT(0)));

-#else

- //

- // some implementations (Dinkumware) append unnecessary trailing \0's:

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

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

-#endif

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

- }

- catch(...)

- {

- }

- return result;

-}

-

-

-template <class charT>

-typename cpp_regex_traits_implementation<charT>::string_type

- cpp_regex_traits_implementation<charT>::lookup_collatename(const charT* p1, const charT* p2) const

-{

- typedef typename std::map<string_type, string_type>::const_iterator iter_type;

- if(m_custom_collate_names.size())

- {

- iter_type pos = m_custom_collate_names.find(string_type(p1, p2));

- if(pos != m_custom_collate_names.end())

- return pos->second;

- }

-#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\

- && !BOOST_WORKAROUND(BOOST_MSVC, < 1300)\

- && !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)

- std::string name(p1, p2);

-#else

- std::string name;

- const charT* p0 = p1;

- while(p0 != p2)

- name.append(1, char(*p0++));

-#endif

- name = lookup_default_collate_name(name);

-#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\

- && !BOOST_WORKAROUND(BOOST_MSVC, < 1300)\

- && !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)

- if(name.size())

- return string_type(name.begin(), name.end());

-#else

- if(name.size())

- {

- string_type result;

- typedef std::string::const_iterator iter;

- iter b = name.begin();

- iter e = name.end();

- while(b != e)

- result.append(1, charT(*b++));

- return result;

- }

-#endif

- if(p2 - p1 == 1)

- return string_type(1, *p1);

- return string_type();

-}

-

-template <class charT>

-void cpp_regex_traits_implementation<charT>::init()

-{

-#ifndef BOOST_NO_STD_MESSAGES

-#ifndef __IBMCPP__

- typename std::messages<charT>::catalog cat = static_cast<std::messages<char>::catalog>(-1);

-#else

- typename std::messages<charT>::catalog cat = reinterpret_cast<std::messages<char>::catalog>(-1);

-#endif

- std::string cat_name(cpp_regex_traits<charT>::get_catalog_name());

- if(cat_name.size())

- {

- cat = this->m_pmessages->open(

- cat_name,

- this->m_locale);

- if((int)cat < 0)

- {

- std::string m("Unable to open message catalog: ");

- std::runtime_error err(m + cat_name);

- boost::re_detail::raise_runtime_error(err);

- }

- }

- //

- // if we have a valid catalog then load our messages:

- //

- if((int)cat >= 0)

- {

- //

- // Error messages:

- //

- for(boost::regex_constants::error_type i = static_cast<boost::regex_constants::error_type>(0);

- i <= boost::regex_constants::error_unknown;

- i = static_cast<boost::regex_constants::error_type>(i + 1))

- {

- const char* p = get_default_error_string(i);

- string_type default_message;

- while(*p)

- {

- default_message.append(1, this->m_pctype->widen(*p));

- ++p;

- }

- string_type s = this->m_pmessages->get(cat, 0, i+200, default_message);

- std::string result;

- for(std::string::size_type j = 0; j < s.size(); ++j)

- {

- result.append(1, this->m_pctype->narrow(s[j], 0));

- }

- m_error_strings[i] = result;

- }

- //

- // Custom class names:

- //

-#ifndef BOOST_REGEX_BUGGY_CTYPE_FACET

- static const char_class_type masks[14] =

- {

- std::ctype<charT>::alnum,

- std::ctype<charT>::alpha,

- std::ctype<charT>::cntrl,

- std::ctype<charT>::digit,

- std::ctype<charT>::graph,

- std::ctype<charT>::lower,

- std::ctype<charT>::print,

- std::ctype<charT>::punct,

- std::ctype<charT>::space,

- std::ctype<charT>::upper,

- std::ctype<charT>::xdigit,

- cpp_regex_traits_implementation<charT>::mask_blank,

- cpp_regex_traits_implementation<charT>::mask_word,

- cpp_regex_traits_implementation<charT>::mask_unicode,

- };

-#else

- static const char_class_type masks[14] =

- {

- ::boost::re_detail::char_class_alnum,

- ::boost::re_detail::char_class_alpha,

- ::boost::re_detail::char_class_cntrl,

- ::boost::re_detail::char_class_digit,

- ::boost::re_detail::char_class_graph,

- ::boost::re_detail::char_class_lower,

- ::boost::re_detail::char_class_print,

- ::boost::re_detail::char_class_punct,

- ::boost::re_detail::char_class_space,

- ::boost::re_detail::char_class_upper,

- ::boost::re_detail::char_class_xdigit,

- ::boost::re_detail::char_class_blank,

- ::boost::re_detail::char_class_word,

- ::boost::re_detail::char_class_unicode,

- };

-#endif

- static const string_type null_string;

- for(unsigned int j = 0; j <= 13; ++j)

- {

- string_type s(this->m_pmessages->get(cat, 0, j+300, null_string));

- if(s.size())

- this->m_custom_class_names[s] = masks[j];

- }

- }

-#endif

- //

- // get the collation format used by m_pcollate:

- //

- m_collate_type = re_detail::find_sort_syntax(this, &m_collate_delim);

-}

-

-template <class charT>

-typename cpp_regex_traits_implementation<charT>::char_class_type

- cpp_regex_traits_implementation<charT>::lookup_classname_imp(const charT* p1, const charT* p2) const

-{

-#ifndef BOOST_REGEX_BUGGY_CTYPE_FACET

- static const char_class_type masks[20] =

- {

- 0,

- std::ctype<char>::alnum,

- std::ctype<char>::alpha,

- cpp_regex_traits_implementation<charT>::mask_blank,

- std::ctype<char>::cntrl,

- std::ctype<char>::digit,

- std::ctype<char>::digit,

- std::ctype<char>::graph,

- std::ctype<char>::lower,

- std::ctype<char>::lower,

- std::ctype<char>::print,

- std::ctype<char>::punct,

- std::ctype<char>::space,

- std::ctype<char>::space,

- std::ctype<char>::upper,

- cpp_regex_traits_implementation<charT>::mask_unicode,

- std::ctype<char>::upper,

- std::ctype<char>::alnum | cpp_regex_traits_implementation<charT>::mask_word,

- std::ctype<char>::alnum | cpp_regex_traits_implementation<charT>::mask_word,

- std::ctype<char>::xdigit,

- };

-#else

- static const char_class_type masks[20] =

- {

- 0,

- ::boost::re_detail::char_class_alnum,

- ::boost::re_detail::char_class_alpha,

- ::boost::re_detail::char_class_blank,

- ::boost::re_detail::char_class_cntrl,

- ::boost::re_detail::char_class_digit,

- ::boost::re_detail::char_class_digit,

- ::boost::re_detail::char_class_graph,

- ::boost::re_detail::char_class_lower,

- ::boost::re_detail::char_class_lower,

- ::boost::re_detail::char_class_print,

- ::boost::re_detail::char_class_punct,

- ::boost::re_detail::char_class_space,

- ::boost::re_detail::char_class_space,

- ::boost::re_detail::char_class_upper,

- ::boost::re_detail::char_class_unicode,

- ::boost::re_detail::char_class_upper,

- ::boost::re_detail::char_class_alnum | ::boost::re_detail::char_class_word,

- ::boost::re_detail::char_class_alnum | ::boost::re_detail::char_class_word,

- ::boost::re_detail::char_class_xdigit,

- };

-#endif

- if(m_custom_class_names.size())

- {

- typedef typename std::map<std::basic_string<charT>, char_class_type>::const_iterator map_iter;

- map_iter pos = m_custom_class_names.find(string_type(p1, p2));

- if(pos != m_custom_class_names.end())

- return pos->second;

- }

- std::size_t state_id = 1 + re_detail::get_default_class_id(p1, p2);

- BOOST_ASSERT(state_id < sizeof(masks) / sizeof(masks[0]));

- return masks[state_id];

-}

-

-#ifdef BOOST_REGEX_BUGGY_CTYPE_FACET

-template <class charT>

-bool cpp_regex_traits_implementation<charT>::isctype(const charT c, char_class_type mask) const

-{

- return

- ((mask & ::boost::re_detail::char_class_space) && (m_pctype->is(std::ctype<charT>::space, c)))

- || ((mask & ::boost::re_detail::char_class_print) && (m_pctype->is(std::ctype<charT>::print, c)))

- || ((mask & ::boost::re_detail::char_class_cntrl) && (m_pctype->is(std::ctype<charT>::cntrl, c)))

- || ((mask & ::boost::re_detail::char_class_upper) && (m_pctype->is(std::ctype<charT>::upper, c)))

- || ((mask & ::boost::re_detail::char_class_lower) && (m_pctype->is(std::ctype<charT>::lower, c)))

- || ((mask & ::boost::re_detail::char_class_alpha) && (m_pctype->is(std::ctype<charT>::alpha, c)))

- || ((mask & ::boost::re_detail::char_class_digit) && (m_pctype->is(std::ctype<charT>::digit, c)))

- || ((mask & ::boost::re_detail::char_class_punct) && (m_pctype->is(std::ctype<charT>::punct, c)))

- || ((mask & ::boost::re_detail::char_class_xdigit) && (m_pctype->is(std::ctype<charT>::xdigit, c)))

- || ((mask & ::boost::re_detail::char_class_blank) && (m_pctype->is(std::ctype<charT>::space, c)) && !::boost::re_detail::is_separator(c))

- || ((mask & ::boost::re_detail::char_class_word) && (c == '_'))

- || ((mask & ::boost::re_detail::char_class_unicode) && ::boost::re_detail::is_extended(c));

-}

-#endif

-

-

-template <class charT>

-inline boost::shared_ptr<const cpp_regex_traits_implementation<charT> > create_cpp_regex_traits(const std::locale& l BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(charT))

-{

- cpp_regex_traits_base<charT> key(l);

- return ::boost::object_cache<cpp_regex_traits_base<charT>, cpp_regex_traits_implementation<charT> >::get(key, 5);

-}

-

-} // re_detail

-

-template <class charT>

-class cpp_regex_traits

-{

-private:

- typedef std::ctype<charT> ctype_type;

-public:

- typedef charT char_type;

- typedef std::size_t size_type;

- typedef std::basic_string<char_type> string_type;

- typedef std::locale locale_type;

- typedef boost::uint_least32_t char_class_type;

-

- struct boost_extensions_tag{};

-

- cpp_regex_traits()

- : m_pimpl(re_detail::create_cpp_regex_traits<charT>(std::locale()))

- { }

- static size_type length(const char_type* p)

- {

- return std::char_traits<charT>::length(p);

- }

- regex_constants::syntax_type syntax_type(charT c)const

- {

- return m_pimpl->syntax_type(c);

- }

- regex_constants::escape_syntax_type escape_syntax_type(charT c) const

- {

- return m_pimpl->escape_syntax_type(c);

- }

- charT translate(charT c) const

- {

- return c;

- }

- charT translate_nocase(charT c) const

- {

- return m_pimpl->m_pctype->tolower(c);

- }

- charT translate(charT c, bool icase) const

- {

- return icase ? m_pimpl->m_pctype->tolower(c) : c;

- }

- charT tolower(charT c) const

- {

- return m_pimpl->m_pctype->tolower(c);

- }

- charT toupper(charT c) const

- {

- return m_pimpl->m_pctype->toupper(c);

- }

- string_type transform(const charT* p1, const charT* p2) const

- {

- return m_pimpl->transform(p1, p2);

- }

- string_type transform_primary(const charT* p1, const charT* p2) const

- {

- return m_pimpl->transform_primary(p1, p2);

- }

- char_class_type lookup_classname(const charT* p1, const charT* p2) const

- {

- return m_pimpl->lookup_classname(p1, p2);

- }

- string_type lookup_collatename(const charT* p1, const charT* p2) const

- {

- return m_pimpl->lookup_collatename(p1, p2);

- }

- bool isctype(charT c, char_class_type f) const

- {

-#ifndef BOOST_REGEX_BUGGY_CTYPE_FACET

- typedef typename std::ctype<charT>::mask ctype_mask;

-

- static const ctype_mask mask_base =

- static_cast<ctype_mask>(

- std::ctype<charT>::alnum

- | std::ctype<charT>::alpha

- | std::ctype<charT>::cntrl

- | std::ctype<charT>::digit

- | std::ctype<charT>::graph

- | std::ctype<charT>::lower

- | std::ctype<charT>::print

- | std::ctype<charT>::punct

- | std::ctype<charT>::space

- | std::ctype<charT>::upper

- | std::ctype<charT>::xdigit);

-

- if((f & mask_base)

- && (m_pimpl->m_pctype->is(

- static_cast<ctype_mask>(f & mask_base), c)))

- return true;

- else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_unicode) && re_detail::is_extended(c))

- return true;

- else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_word) && (c == '_'))

- return true;

- else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_blank)

- && m_pimpl->m_pctype->is(std::ctype<charT>::space, c)

- && !re_detail::is_separator(c))

- return true;

- return false;

-#else

- return m_pimpl->isctype(c, f);

-#endif

- }

- int toi(const charT*& p1, const charT* p2, int radix)const;

- int value(charT c, int radix)const

- {

- const charT* pc = &c;

- return toi(pc, pc + 1, radix);

- }

- locale_type imbue(locale_type l)

- {

- std::locale result(getloc());

- m_pimpl = re_detail::create_cpp_regex_traits<charT>(l);

- return result;

- }

- locale_type getloc()const

- {

- return m_pimpl->m_locale;

- }

- std::string error_string(regex_constants::error_type n) const

- {

- return m_pimpl->error_string(n);

- }

-

- //

- // extension:

- // set the name of the message catalog in use (defaults to "boost_regex").

- //

- static std::string catalog_name(const std::string& name);

- static std::string get_catalog_name();

-

-private:

- boost::shared_ptr<const re_detail::cpp_regex_traits_implementation<charT> > m_pimpl;

- //

- // catalog name handler:

- //

- static std::string& get_catalog_name_inst();

-

-#ifdef BOOST_HAS_THREADS

- static static_mutex& get_mutex_inst();

-#endif

-};

-

-

-template <class charT>

-int cpp_regex_traits<charT>::toi(const charT*& first, const charT* last, int radix)const

-{

- re_detail::parser_buf<charT> sbuf; // buffer for parsing numbers.

- std::basic_istream<charT> is(&sbuf); // stream for parsing numbers.

-

- // we do NOT want to parse any thousands separators inside the stream:

- last = std::find(first, last, BOOST_USE_FACET(std::numpunct<charT>, is.getloc()).thousands_sep());

-

- sbuf.pubsetbuf(const_cast<charT*>(static_cast<const charT*>(first)), static_cast<std::streamsize>(last-first));

- is.clear();

- if(std::abs(radix) == 16) is >> std::hex;

- else if(std::abs(radix) == 8) is >> std::oct;

- else is >> std::dec;

- int val;

- if(is >> val)

- {

- first = first + ((last - first) - sbuf.in_avail());

- return val;

- }

- else

- return -1;

-}

-

-template <class charT>

-std::string cpp_regex_traits<charT>::catalog_name(const std::string& name)

-{

-#ifdef BOOST_HAS_THREADS

- static_mutex::scoped_lock lk(get_mutex_inst());

-#endif

- std::string result(get_catalog_name_inst());

- get_catalog_name_inst() = name;

- return result;

-}

-

-template <class charT>

-std::string& cpp_regex_traits<charT>::get_catalog_name_inst()

-{

- static std::string s_name;

- return s_name;

-}

-

-template <class charT>

-std::string cpp_regex_traits<charT>::get_catalog_name()

-{

-#ifdef BOOST_HAS_THREADS

- static_mutex::scoped_lock lk(get_mutex_inst());

-#endif

- std::string result(get_catalog_name_inst());

- return result;

-}

-

-#ifdef BOOST_HAS_THREADS

-template <class charT>

-static_mutex& cpp_regex_traits<charT>::get_mutex_inst()

-{

- static static_mutex s_mutex = BOOST_STATIC_MUTEX_INIT;

- return s_mutex;

-}

-#endif

-

-

-} // boost

-

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_SUFFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-#endif

-

-#endif

-

-

-/*

- *

- * Copyright (c) 1998-2002

- * John Maddock

- *

- * 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 cregex.cpp

- * VERSION see <boost/version.hpp>

- * DESCRIPTION: Declares POSIX API functions

- * + boost::RegEx high level wrapper.

- */

-

-#ifndef BOOST_RE_CREGEX_HPP_INCLUDED

-#define BOOST_RE_CREGEX_HPP_INCLUDED

-

-#ifndef BOOST_REGEX_CONFIG_HPP

-#include <boost/regex/config.hpp>

-#endif

-#include <boost/regex/v4/match_flags.hpp>

-#include <boost/regex/v4/error_type.hpp>

-

-#ifdef __cplusplus

-#include <cstddef>

-#else

-#include <stddef.h>

-#endif

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_PREFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-/* include these defs only for POSIX compatablity */

-#ifdef __cplusplus

-namespace boost{

-extern "C" {

-#endif

-

-#if defined(__cplusplus) && !defined(BOOST_NO_STDC_NAMESPACE)

-typedef std::ptrdiff_t regoff_t;

-typedef std::size_t regsize_t;

-#else

-typedef ptrdiff_t regoff_t;

-typedef size_t regsize_t;

-#endif

-

-typedef struct

-{

- unsigned int re_magic;

-#ifdef __cplusplus

- std::size_t re_nsub; /* number of parenthesized subexpressions */

-#else

- size_t re_nsub;

-#endif

- const char* re_endp; /* end pointer for REG_PEND */

- void* guts; /* none of your business :-) */

- match_flag_type eflags; /* none of your business :-) */

-} regex_tA;

-

-#ifndef BOOST_NO_WREGEX

-typedef struct

-{

- unsigned int re_magic;

-#ifdef __cplusplus

- std::size_t re_nsub; /* number of parenthesized subexpressions */

-#else

- size_t re_nsub;

-#endif

- const wchar_t* re_endp; /* end pointer for REG_PEND */

- void* guts; /* none of your business :-) */

- match_flag_type eflags; /* none of your business :-) */

-} regex_tW;

-#endif

-

-typedef struct

-{

- regoff_t rm_so; /* start of match */

- regoff_t rm_eo; /* end of match */

-} regmatch_t;

-

-/* regcomp() flags */

-typedef enum{

- REG_BASIC = 0000,

- REG_EXTENDED = 0001,

- REG_ICASE = 0002,

- REG_NOSUB = 0004,

- REG_NEWLINE = 0010,

- REG_NOSPEC = 0020,

- REG_PEND = 0040,

- REG_DUMP = 0200,

- REG_NOCOLLATE = 0400,

- REG_ESCAPE_IN_LISTS = 01000,

- REG_NEWLINE_ALT = 02000,

- REG_PERLEX = 04000,

-

- REG_PERL = REG_EXTENDED | REG_NOCOLLATE | REG_ESCAPE_IN_LISTS | REG_PERLEX,

- REG_AWK = REG_EXTENDED | REG_ESCAPE_IN_LISTS,

- REG_GREP = REG_BASIC | REG_NEWLINE_ALT,

- REG_EGREP = REG_EXTENDED | REG_NEWLINE_ALT,

-

- REG_ASSERT = 15,

- REG_INVARG = 16,

- REG_ATOI = 255, /* convert name to number (!) */

- REG_ITOA = 0400 /* convert number to name (!) */

-} reg_comp_flags;

-

-/* regexec() flags */

-typedef enum{

- REG_NOTBOL = 00001,

- REG_NOTEOL = 00002,

- REG_STARTEND = 00004

-} reg_exec_flags;

-

-//

-// POSIX error codes:

-//

-typedef unsigned reg_error_t;

-typedef reg_error_t reg_errcode_t; // backwards compatibility

-

-static const reg_error_t REG_NOERROR = 0; /* Success. */

-static const reg_error_t REG_NOMATCH = 1; /* Didn't find a match (for regexec). */

-

- /* POSIX regcomp return error codes. (In the order listed in the

- standard.) */

-static const reg_error_t REG_BADPAT = 2; /* Invalid pattern. */

-static const reg_error_t REG_ECOLLATE = 3; /* Undefined collating element. */

-static const reg_error_t REG_ECTYPE = 4; /* Invalid character class name. */

-static const reg_error_t REG_EESCAPE = 5; /* Trailing backslash. */

-static const reg_error_t REG_ESUBREG = 6; /* Invalid back reference. */

-static const reg_error_t REG_EBRACK = 7; /* Unmatched left bracket. */

-static const reg_error_t REG_EPAREN = 8; /* Parenthesis imbalance. */

-static const reg_error_t REG_EBRACE = 9; /* Unmatched \{. */

-static const reg_error_t REG_BADBR = 10; /* Invalid contents of \{\}. */

-static const reg_error_t REG_ERANGE = 11; /* Invalid range end. */

-static const reg_error_t REG_ESPACE = 12; /* Ran out of memory. */

-static const reg_error_t REG_BADRPT = 13; /* No preceding re for repetition op. */

-static const reg_error_t REG_EEND = 14; /* unexpected end of expression */

-static const reg_error_t REG_ESIZE = 15; /* expression too big */

-static const reg_error_t REG_ERPAREN = 8; /* = REG_EPAREN : unmatched right parenthesis */

-static const reg_error_t REG_EMPTY = 17; /* empty expression */

-static const reg_error_t REG_E_MEMORY = 15; /* = REG_ESIZE : out of memory */

-static const reg_error_t REG_ECOMPLEXITY = 18; /* complexity too high */

-static const reg_error_t REG_ESTACK = 19; /* out of stack space */

-static const reg_error_t REG_E_UNKNOWN = 20; /* unknown error */

-static const reg_error_t REG_ENOSYS = 20; /* = REG_E_UNKNOWN : Reserved. */

-

-BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompA(regex_tA*, const char*, int);

-BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorA(int, const regex_tA*, char*, regsize_t);

-BOOST_REGEX_DECL int BOOST_REGEX_CCALL regexecA(const regex_tA*, const char*, regsize_t, regmatch_t*, int);

-BOOST_REGEX_DECL void BOOST_REGEX_CCALL regfreeA(regex_tA*);

-

-#ifndef BOOST_NO_WREGEX

-BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompW(regex_tW*, const wchar_t*, int);

-BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int, const regex_tW*, wchar_t*, regsize_t);

-BOOST_REGEX_DECL int BOOST_REGEX_CCALL regexecW(const regex_tW*, const wchar_t*, regsize_t, regmatch_t*, int);

-BOOST_REGEX_DECL void BOOST_REGEX_CCALL regfreeW(regex_tW*);

-#endif

-

-#ifdef UNICODE

-#define regcomp regcompW

-#define regerror regerrorW

-#define regexec regexecW

-#define regfree regfreeW

-#define regex_t regex_tW

-#else

-#define regcomp regcompA

-#define regerror regerrorA

-#define regexec regexecA

-#define regfree regfreeA

-#define regex_t regex_tA

-#endif

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_SUFFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-#ifdef __cplusplus

-} // extern "C"

-} // namespace

-#endif

-

-//

-// C++ high level wrapper goes here:

-//

-#if defined(__cplusplus)

-#include <string>

-#include <vector>

-namespace boost{

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_PREFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-class RegEx;

-

-namespace re_detail{

-

-class RegExData;

-struct pred1;

-struct pred2;

-struct pred3;

-struct pred4;

-

-} // namespace re_detail

-

-#if (defined(BOOST_MSVC) || defined(__BORLANDC__)) && !defined(BOOST_DISABLE_WIN32)

-typedef bool (__cdecl *GrepCallback)(const RegEx& expression);

-typedef bool (__cdecl *GrepFileCallback)(const char* file, const RegEx& expression);

-typedef bool (__cdecl *FindFilesCallback)(const char* file);

-#else

-typedef bool (*GrepCallback)(const RegEx& expression);

-typedef bool (*GrepFileCallback)(const char* file, const RegEx& expression);

-typedef bool (*FindFilesCallback)(const char* file);

-#endif

-

-class BOOST_REGEX_DECL RegEx

-{

-private:

- re_detail::RegExData* pdata;

-public:

- RegEx();

- RegEx(const RegEx& o);

- ~RegEx();

- explicit RegEx(const char* c, bool icase = false);

- explicit RegEx(const std::string& s, bool icase = false);

- RegEx& operator=(const RegEx& o);

- RegEx& operator=(const char* p);

- RegEx& operator=(const std::string& s){ return this->operator=(s.c_str()); }

- unsigned int SetExpression(const char* p, bool icase = false);

- unsigned int SetExpression(const std::string& s, bool icase = false){ return SetExpression(s.c_str(), icase); }

- std::string Expression()const;

- unsigned int error_code()const;

- //

- // now matching operators:

- //

- bool Match(const char* p, match_flag_type flags = match_default);

- bool Match(const std::string& s, match_flag_type flags = match_default) { return Match(s.c_str(), flags); }

- bool Search(const char* p, match_flag_type flags = match_default);

- bool Search(const std::string& s, match_flag_type flags = match_default) { return Search(s.c_str(), flags); }

- unsigned int Grep(GrepCallback cb, const char* p, match_flag_type flags = match_default);

- unsigned int Grep(GrepCallback cb, const std::string& s, match_flag_type flags = match_default) { return Grep(cb, s.c_str(), flags); }

- unsigned int Grep(std::vector<std::string>& v, const char* p, match_flag_type flags = match_default);

- unsigned int Grep(std::vector<std::string>& v, const std::string& s, match_flag_type flags = match_default) { return Grep(v, s.c_str(), flags); }

- unsigned int Grep(std::vector<std::size_t>& v, const char* p, match_flag_type flags = match_default);

- unsigned int Grep(std::vector<std::size_t>& v, const std::string& s, match_flag_type flags = match_default) { return Grep(v, s.c_str(), flags); }

-#ifndef BOOST_REGEX_NO_FILEITER

- unsigned int GrepFiles(GrepFileCallback cb, const char* files, bool recurse = false, match_flag_type flags = match_default);

- unsigned int GrepFiles(GrepFileCallback cb, const std::string& files, bool recurse = false, match_flag_type flags = match_default) { return GrepFiles(cb, files.c_str(), recurse, flags); }

- unsigned int FindFiles(FindFilesCallback cb, const char* files, bool recurse = false, match_flag_type flags = match_default);

- unsigned int FindFiles(FindFilesCallback cb, const std::string& files, bool recurse = false, match_flag_type flags = match_default) { return FindFiles(cb, files.c_str(), recurse, flags); }

-#endif

-

- std::string Merge(const std::string& in, const std::string& fmt,

- bool copy = true, match_flag_type flags = match_default);

- std::string Merge(const char* in, const char* fmt,

- bool copy = true, match_flag_type flags = match_default);

-

- std::size_t Split(std::vector<std::string>& v, std::string& s, match_flag_type flags = match_default, unsigned max_count = ~0);

- //

- // now operators for returning what matched in more detail:

- //

- std::size_t Position(int i = 0)const;

- std::size_t Length(int i = 0)const;

- bool Matched(int i = 0)const;

- std::size_t Marks()const;

- std::string What(int i = 0)const;

- std::string operator[](int i)const { return What(i); }

-

- static const std::size_t npos;

-

- friend struct re_detail::pred1;

- friend struct re_detail::pred2;

- friend struct re_detail::pred3;

- friend struct re_detail::pred4;

-};

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_SUFFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-} // namespace boost

-

-#endif

-

-#endif // include guard

-

-

-

-

-

-

-

-

-

-

-/*

- *

- * Copyright (c) 2003-2005

- * John Maddock

- *

- * 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 error_type.hpp

- * VERSION see <boost/version.hpp>

- * DESCRIPTION: Declares regular expression error type enumerator.

- */

-

-#ifndef BOOST_REGEX_ERROR_TYPE_HPP

-#define BOOST_REGEX_ERROR_TYPE_HPP

-

-#ifdef __cplusplus

-namespace boost{

-#endif

-

-#ifdef __cplusplus

-namespace regex_constants{

-

-enum error_type{

-

- error_ok = 0, // not used

- error_no_match = 1, // not used

- error_bad_pattern = 2,

- error_collate = 3,

- error_ctype = 4,

- error_escape = 5,

- error_backref = 6,

- error_brack = 7,

- error_paren = 8,

- error_brace = 9,

- error_badbrace = 10,

- error_range = 11,

- error_space = 12,

- error_badrepeat = 13,

- error_end = 14, // not used

- error_size = 15,

- error_right_paren = 16, // not used

- error_empty = 17,

- error_complexity = 18,

- error_stack = 19,

- error_unknown = 20

-};

-

-}

-}

-#endif // __cplusplus

-

-#endif

-/*

- *

- * Copyright (c) 1998-2002

- * John Maddock

- *

- * 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 fileiter.hpp

- * VERSION see <boost/version.hpp>

- * DESCRIPTION: Declares various platform independent file and

- * directory iterators, plus binary file input in

- * the form of class map_file.

- */

-

-#ifndef BOOST_RE_FILEITER_HPP_INCLUDED

-#define BOOST_RE_FILEITER_HPP_INCLUDED

-

-#ifndef BOOST_REGEX_CONFIG_HPP

-#include <boost/regex/config.hpp>

-#endif

-#include <boost/assert.hpp>

-

-#ifndef BOOST_REGEX_NO_FILEITER

-

-#if (defined(__CYGWIN__) || defined(__CYGWIN32__)) && !defined(BOOST_REGEX_NO_W32)

-#error "Sorry, can't mix <windows.h> with STL code and gcc compiler: if you ran configure, try again with configure --disable-ms-windows"

-#define BOOST_REGEX_FI_WIN32_MAP

-#define BOOST_REGEX_FI_POSIX_DIR

-#elif (defined(__WIN32__) || defined(_WIN32) || defined(WIN32)) && !defined(BOOST_REGEX_NO_W32)

-#define BOOST_REGEX_FI_WIN32_MAP

-#define BOOST_REGEX_FI_WIN32_DIR

-#else

-#define BOOST_REGEX_FI_POSIX_MAP

-#define BOOST_REGEX_FI_POSIX_DIR

-#endif

-

-#if defined(BOOST_REGEX_FI_WIN32_MAP)||defined(BOOST_REGEX_FI_WIN32_DIR)

-#include <windows.h>

-#endif

-

-#if defined(BOOST_REGEX_FI_WIN32_DIR)

-

-#include <cstddef>

-

-namespace boost{

- namespace re_detail{

-

-#ifndef BOOST_NO_ANSI_APIS

-typedef WIN32_FIND_DATAA _fi_find_data;

-#else

-typedef WIN32_FIND_DATAW _fi_find_data;

-#endif

-typedef HANDLE _fi_find_handle;

-

- } // namespace re_detail

-

-} // namespace boost

-

-#define _fi_invalid_handle INVALID_HANDLE_VALUE

-#define _fi_dir FILE_ATTRIBUTE_DIRECTORY

-

-#elif defined(BOOST_REGEX_FI_POSIX_DIR)

-

-#include <cstddef>

-#include <cstdio>

-#include <cctype>

-#include <iterator>

-#include <list>

-#include <cassert>

-#include <dirent.h>

-

-#if defined(__SUNPRO_CC)

-using std::list;

-#endif

-

-#ifndef MAX_PATH

-#define MAX_PATH 256

-#endif

-

-namespace boost{

- namespace re_detail{

-

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_PREFIX

-#endif

-

-struct _fi_find_data

-{

- unsigned dwFileAttributes;

- char cFileName[MAX_PATH];

-};

-

-struct _fi_priv_data;

-

-typedef _fi_priv_data* _fi_find_handle;

-#define _fi_invalid_handle 0

-#define _fi_dir 1

-

-_fi_find_handle _fi_FindFirstFile(const char* lpFileName, _fi_find_data* lpFindFileData);

-bool _fi_FindNextFile(_fi_find_handle hFindFile, _fi_find_data* lpFindFileData);

-bool _fi_FindClose(_fi_find_handle hFindFile);

-

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_SUFFIX

-#endif

-

- } // namespace re_detail

-} // namespace boost

-

-#ifdef FindFirstFile

- #undef FindFirstFile

-#endif

-#ifdef FindNextFile

- #undef FindNextFile

-#endif

-#ifdef FindClose

- #undef FindClose

-#endif

-

-#define FindFirstFileA _fi_FindFirstFile

-#define FindNextFileA _fi_FindNextFile

-#define FindClose _fi_FindClose

-

-#endif

-

-namespace boost{

- namespace re_detail{

-

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_PREFIX

-#endif

-

-#ifdef BOOST_REGEX_FI_WIN32_MAP // win32 mapfile

-

-class BOOST_REGEX_DECL mapfile

-{

- HANDLE hfile;

- HANDLE hmap;

- const char* _first;

- const char* _last;

-public:

-

- typedef const char* iterator;

-

- mapfile(){ hfile = hmap = 0; _first = _last = 0; }

- mapfile(const char* file){ hfile = hmap = 0; _first = _last = 0; open(file); }

- ~mapfile(){ close(); }

- void open(const char* file);

- void close();

- const char* begin(){ return _first; }

- const char* end(){ return _last; }

- size_t size(){ return _last - _first; }

- bool valid(){ return (hfile != 0) && (hfile != INVALID_HANDLE_VALUE); }

-};

-

-

-#else

-

-class BOOST_REGEX_DECL mapfile_iterator;

-

-class BOOST_REGEX_DECL mapfile

-{

- typedef char* pointer;

- std::FILE* hfile;

- long int _size;

- pointer* _first;

- pointer* _last;

- mutable std::list<pointer*> condemed;

- enum sizes

- {

- buf_size = 4096

- };

- void lock(pointer* node)const;

- void unlock(pointer* node)const;

-public:

-

- typedef mapfile_iterator iterator;

-

- mapfile(){ hfile = 0; _size = 0; _first = _last = 0; }

- mapfile(const char* file){ hfile = 0; _size = 0; _first = _last = 0; open(file); }

- ~mapfile(){ close(); }

- void open(const char* file);

- void close();

- iterator begin()const;

- iterator end()const;

- unsigned long size()const{ return _size; }

- bool valid()const{ return hfile != 0; }

- friend class mapfile_iterator;

-};

-

-class BOOST_REGEX_DECL mapfile_iterator

-#if !defined(BOOST_NO_STD_ITERATOR) || defined(BOOST_MSVC_STD_ITERATOR)

-: public std::iterator<std::random_access_iterator_tag, char>

-#endif

-{

- typedef mapfile::pointer internal_pointer;

- internal_pointer* node;

- const mapfile* file;

- unsigned long offset;

- long position()const

- {

- return file ? ((node - file->_first) * mapfile::buf_size + offset) : 0;

- }

- void position(long pos)

- {

- if(file)

- {

- node = file->_first + (pos / mapfile::buf_size);

- offset = pos % mapfile::buf_size;

- }

- }

-public:

- typedef std::ptrdiff_t difference_type;

- typedef char value_type;

- typedef const char* pointer;

- typedef const char& reference;

- typedef std::random_access_iterator_tag iterator_category;

-

- mapfile_iterator() { node = 0; file = 0; offset = 0; }

- mapfile_iterator(const mapfile* f, long arg_position)

- {

- file = f;

- node = f->_first + arg_position / mapfile::buf_size;

- offset = arg_position % mapfile::buf_size;

- if(file)

- file->lock(node);

- }

- mapfile_iterator(const mapfile_iterator& i)

- {

- file = i.file;

- node = i.node;

- offset = i.offset;

- if(file)

- file->lock(node);

- }

- ~mapfile_iterator()

- {

- if(file && node)

- file->unlock(node);

- }

- mapfile_iterator& operator = (const mapfile_iterator& i);

- char operator* ()const

- {

- BOOST_ASSERT(node >= file->_first);

- BOOST_ASSERT(node < file->_last);

- return file ? *(*node + sizeof(int) + offset) : char(0);

- }

- char operator[] (long off)const

- {

- mapfile_iterator tmp(*this);

- tmp += off;

- return *tmp;

- }

- mapfile_iterator& operator++ ();

- mapfile_iterator operator++ (int);

- mapfile_iterator& operator-- ();

- mapfile_iterator operator-- (int);

-

- mapfile_iterator& operator += (long off)

- {

- position(position() + off);

- return *this;

- }

- mapfile_iterator& operator -= (long off)

- {

- position(position() - off);

- return *this;

- }

-

- friend inline bool operator==(const mapfile_iterator& i, const mapfile_iterator& j)

- {

- return (i.file == j.file) && (i.node == j.node) && (i.offset == j.offset);

- }

-

- friend inline bool operator!=(const mapfile_iterator& i, const mapfile_iterator& j)

- {

- return !(i == j);

- }

-

- friend inline bool operator<(const mapfile_iterator& i, const mapfile_iterator& j)

- {

- return i.position() < j.position();

- }

- friend inline bool operator>(const mapfile_iterator& i, const mapfile_iterator& j)

- {

- return i.position() > j.position();

- }

- friend inline bool operator<=(const mapfile_iterator& i, const mapfile_iterator& j)

- {

- return i.position() <= j.position();

- }

- friend inline bool operator>=(const mapfile_iterator& i, const mapfile_iterator& j)

- {

- return i.position() >= j.position();

- }

-

- friend mapfile_iterator operator + (const mapfile_iterator& i, long off);

- friend mapfile_iterator operator + (long off, const mapfile_iterator& i)

- {

- mapfile_iterator tmp(i);

- return tmp += off;

- }

- friend mapfile_iterator operator - (const mapfile_iterator& i, long off);

- friend inline long operator - (const mapfile_iterator& i, const mapfile_iterator& j)

- {

- return i.position() - j.position();

- }

-};

-

-#endif

-

-// _fi_sep determines the directory separator, either '\\' or '/'

-BOOST_REGEX_DECL extern const char* _fi_sep;

-

-struct file_iterator_ref

-{

- _fi_find_handle hf;

- _fi_find_data _data;

- long count;

-};

-

-

-class BOOST_REGEX_DECL file_iterator

-{

- char* _root;

- char* _path;

- char* ptr;

- file_iterator_ref* ref;

-

-public:

- typedef std::ptrdiff_t difference_type;

- typedef const char* value_type;

- typedef const char** pointer;

- typedef const char*& reference;

- typedef std::input_iterator_tag iterator_category;

-

- file_iterator();

- file_iterator(const char* wild);

- ~file_iterator();

- file_iterator(const file_iterator&);

- file_iterator& operator=(const file_iterator&);

- const char* root()const { return _root; }

- const char* path()const { return _path; }

- const char* name()const { return ptr; }

- _fi_find_data* data() { return &(ref->_data); }

- void next();

- file_iterator& operator++() { next(); return *this; }

- file_iterator operator++(int);

- const char* operator*() { return path(); }

-

- friend inline bool operator == (const file_iterator& f1, const file_iterator& f2)

- {

- return ((f1.ref->hf == _fi_invalid_handle) && (f2.ref->hf == _fi_invalid_handle));

- }

-

- friend inline bool operator != (const file_iterator& f1, const file_iterator& f2)

- {

- return !(f1 == f2);

- }

-

-};

-

-// dwa 9/13/00 - suppress unused parameter warning

-inline bool operator < (const file_iterator&, const file_iterator&)

-{

- return false;

-}

-

-

-class BOOST_REGEX_DECL directory_iterator

-{

- char* _root;

- char* _path;

- char* ptr;

- file_iterator_ref* ref;

-

-public:

- typedef std::ptrdiff_t difference_type;

- typedef const char* value_type;

- typedef const char** pointer;

- typedef const char*& reference;

- typedef std::input_iterator_tag iterator_category;

-

- directory_iterator();

- directory_iterator(const char* wild);

- ~directory_iterator();

- directory_iterator(const directory_iterator& other);

- directory_iterator& operator=(const directory_iterator& other);

-

- const char* root()const { return _root; }

- const char* path()const { return _path; }

- const char* name()const { return ptr; }

- _fi_find_data* data() { return &(ref->_data); }

- void next();

- directory_iterator& operator++() { next(); return *this; }

- directory_iterator operator++(int);

- const char* operator*() { return path(); }

-

- static const char* separator() { return _fi_sep; }

-

- friend inline bool operator == (const directory_iterator& f1, const directory_iterator& f2)

- {

- return ((f1.ref->hf == _fi_invalid_handle) && (f2.ref->hf == _fi_invalid_handle));

- }

-

-

- friend inline bool operator != (const directory_iterator& f1, const directory_iterator& f2)

- {

- return !(f1 == f2);

- }

-

- };

-

-inline bool operator < (const directory_iterator&, const directory_iterator&)

-{

- return false;

-}

-

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_SUFFIX

-#endif

-

-

-} // namespace re_detail

-using boost::re_detail::directory_iterator;

-using boost::re_detail::file_iterator;

-using boost::re_detail::mapfile;

-} // namespace boost

-

-#endif // BOOST_REGEX_NO_FILEITER

-#endif // BOOST_RE_FILEITER_HPP

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-

-/*

- *

- * Copyright (c) 1998-2002

- * John Maddock

- *

- * 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 instances.cpp

- * VERSION see <boost/version.hpp>

- * DESCRIPTION: Defines those template instances that are placed in the

- * library rather than in the users object files.

- */

-

-//

-// note no include guard, we may include this multiple times:

-//

-#ifndef BOOST_REGEX_NO_EXTERNAL_TEMPLATES

-

-namespace boost{

-

-//

-// this header can be included multiple times, each time with

-// a different character type, BOOST_REGEX_CHAR_T must be defined

-// first:

-//

-#ifndef BOOST_REGEX_CHAR_T

-# error "BOOST_REGEX_CHAR_T not defined"

-#endif

-

-#ifndef BOOST_REGEX_TRAITS_T

-# define BOOST_REGEX_TRAITS_T , boost::regex_traits<BOOST_REGEX_CHAR_T >

-#endif

-

-//

-// what follows is compiler specific:

-//

-

-#if defined(__BORLANDC__) && (__BORLANDC__ < 0x600)

-

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_PREFIX

-#endif

-

-# ifndef BOOST_REGEX_INSTANTIATE

-# pragma option push -Jgx

-# endif

-

-template class BOOST_REGEX_DECL basic_regex< BOOST_REGEX_CHAR_T BOOST_REGEX_TRAITS_T >;

-template class BOOST_REGEX_DECL match_results< const BOOST_REGEX_CHAR_T* >;

-#ifndef BOOST_NO_STD_ALLOCATOR

-template class BOOST_REGEX_DECL ::boost::re_detail::perl_matcher<BOOST_REGEX_CHAR_T const *, match_results< const BOOST_REGEX_CHAR_T* >::allocator_type BOOST_REGEX_TRAITS_T >;

-#endif

-

-# ifndef BOOST_REGEX_INSTANTIATE

-# pragma option pop

-# endif

-

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_SUFFIX

-#endif

-

-#elif defined(BOOST_MSVC) || defined(__ICL)

-

-# ifndef BOOST_REGEX_INSTANTIATE

-# ifdef __GNUC__

-# define template __extension__ extern template

-# else

-# if BOOST_MSVC > 1310

-# define BOOST_REGEX_TEMPLATE_DECL

-# endif

-# define template extern template

-# endif

-# endif

-

-#ifndef BOOST_REGEX_TEMPLATE_DECL

-# define BOOST_REGEX_TEMPLATE_DECL BOOST_REGEX_DECL

-#endif

-

-# ifdef BOOST_MSVC

-# pragma warning(push)

-# pragma warning(disable : 4251 4231 4660)

-# endif

-

-template class BOOST_REGEX_TEMPLATE_DECL basic_regex< BOOST_REGEX_CHAR_T BOOST_REGEX_TRAITS_T >;

-

-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)

-template class BOOST_REGEX_TEMPLATE_DECL match_results< const BOOST_REGEX_CHAR_T* >;

-#endif

-#ifndef BOOST_NO_STD_ALLOCATOR

-template class BOOST_REGEX_TEMPLATE_DECL ::boost::re_detail::perl_matcher<BOOST_REGEX_CHAR_T const *, match_results< const BOOST_REGEX_CHAR_T* >::allocator_type BOOST_REGEX_TRAITS_T >;

-#endif

-#if !(defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB <= 1))\

- && !(defined(BOOST_INTEL_CXX_VERSION) && (BOOST_INTEL_CXX_VERSION <= 800))\

- && !(defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))\

- && !defined(BOOST_REGEX_ICU_INSTANCES)

-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)

-template class BOOST_REGEX_TEMPLATE_DECL match_results< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator >;

-#endif

-#ifndef BOOST_NO_STD_ALLOCATOR

-template class BOOST_REGEX_TEMPLATE_DECL ::boost::re_detail::perl_matcher< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator, match_results< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator >::allocator_type, boost::regex_traits<BOOST_REGEX_CHAR_T > >;

-#endif

-#endif

-

-

-# ifdef BOOST_MSVC

-# pragma warning(pop)

-# endif

-

-# ifdef template

-# undef template

-# endif

-

-#undef BOOST_REGEX_TEMPLATE_DECL

-

-#elif (defined(__GNUC__) && (__GNUC__ >= 3))

-

-# ifndef BOOST_REGEX_INSTANTIATE

-# define template __extension__ extern template

-# endif

-

-#if !defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_REGEX_ICU_INSTANCES)

-namespace re_detail{

-template BOOST_REGEX_DECL

-std::locale cpp_regex_traits_base<BOOST_REGEX_CHAR_T>::imbue(const std::locale& l);

-

-template BOOST_REGEX_DECL

-cpp_regex_traits_implementation<BOOST_REGEX_CHAR_T>::string_type

- cpp_regex_traits_implementation<BOOST_REGEX_CHAR_T>::transform_primary(const BOOST_REGEX_CHAR_T* p1, const BOOST_REGEX_CHAR_T* p2) const;

-template BOOST_REGEX_DECL

-cpp_regex_traits_implementation<BOOST_REGEX_CHAR_T>::string_type

- cpp_regex_traits_implementation<BOOST_REGEX_CHAR_T>::transform(const BOOST_REGEX_CHAR_T* p1, const BOOST_REGEX_CHAR_T* p2) const;

-template BOOST_REGEX_DECL

-cpp_regex_traits_implementation<BOOST_REGEX_CHAR_T>::string_type

- cpp_regex_traits_implementation<BOOST_REGEX_CHAR_T>::lookup_collatename(const BOOST_REGEX_CHAR_T* p1, const BOOST_REGEX_CHAR_T* p2) const;

-template BOOST_REGEX_DECL

-void cpp_regex_traits_implementation<BOOST_REGEX_CHAR_T>::init();

-template BOOST_REGEX_DECL

-cpp_regex_traits_implementation<BOOST_REGEX_CHAR_T>::char_class_type

- cpp_regex_traits_implementation<BOOST_REGEX_CHAR_T>::lookup_classname_imp(const BOOST_REGEX_CHAR_T* p1, const BOOST_REGEX_CHAR_T* p2) const;

-#ifdef BOOST_REGEX_BUGGY_CTYPE_FACET

-template BOOST_REGEX_DECL

-bool cpp_regex_traits_implementation<BOOST_REGEX_CHAR_T>::isctype(const BOOST_REGEX_CHAR_T c, char_class_type mask) const;

-#endif

-} // namespace

-template BOOST_REGEX_DECL

-int cpp_regex_traits<BOOST_REGEX_CHAR_T>::toi(const BOOST_REGEX_CHAR_T*& first, const BOOST_REGEX_CHAR_T* last, int radix)const;

-template BOOST_REGEX_DECL

-std::string cpp_regex_traits<BOOST_REGEX_CHAR_T>::catalog_name(const std::string& name);

-template BOOST_REGEX_DECL

-std::string& cpp_regex_traits<BOOST_REGEX_CHAR_T>::get_catalog_name_inst();

-template BOOST_REGEX_DECL

-std::string cpp_regex_traits<BOOST_REGEX_CHAR_T>::get_catalog_name();

-#ifdef BOOST_HAS_THREADS

-template BOOST_REGEX_DECL

-static_mutex& cpp_regex_traits<BOOST_REGEX_CHAR_T>::get_mutex_inst();

-#endif

-#endif

-

-template BOOST_REGEX_DECL basic_regex<BOOST_REGEX_CHAR_T BOOST_REGEX_TRAITS_T >&

- basic_regex<BOOST_REGEX_CHAR_T BOOST_REGEX_TRAITS_T >::do_assign(

- const BOOST_REGEX_CHAR_T* p1,

- const BOOST_REGEX_CHAR_T* p2,

- flag_type f);

-template BOOST_REGEX_DECL basic_regex<BOOST_REGEX_CHAR_T BOOST_REGEX_TRAITS_T >::locale_type BOOST_REGEX_CALL

- basic_regex<BOOST_REGEX_CHAR_T BOOST_REGEX_TRAITS_T >::imbue(locale_type l);

-

-template BOOST_REGEX_DECL void BOOST_REGEX_CALL

- match_results<const BOOST_REGEX_CHAR_T*>::maybe_assign(

- const match_results<const BOOST_REGEX_CHAR_T*>& m);

-

-namespace re_detail{

-template BOOST_REGEX_DECL void perl_matcher<BOOST_REGEX_CHAR_T const *, match_results< const BOOST_REGEX_CHAR_T* >::allocator_type BOOST_REGEX_TRAITS_T >::construct_init(

- const basic_regex<BOOST_REGEX_CHAR_T BOOST_REGEX_TRAITS_T >& e, match_flag_type f);

-template BOOST_REGEX_DECL bool perl_matcher<BOOST_REGEX_CHAR_T const *, match_results< const BOOST_REGEX_CHAR_T* >::allocator_type BOOST_REGEX_TRAITS_T >::match();

-template BOOST_REGEX_DECL bool perl_matcher<BOOST_REGEX_CHAR_T const *, match_results< const BOOST_REGEX_CHAR_T* >::allocator_type BOOST_REGEX_TRAITS_T >::find();

-} // namespace

-

-#if (defined(__GLIBCPP__) || defined(__GLIBCXX__)) \

- && !defined(BOOST_REGEX_ICU_INSTANCES)\

- && !defined(__SGI_STL_PORT)\

- && !defined(_STLPORT_VERSION)

-// std:basic_string<>::const_iterator instances as well:

-template BOOST_REGEX_DECL void BOOST_REGEX_CALL

- match_results<std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator>::maybe_assign(

- const match_results<std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator>& m);

-

-namespace re_detail{

-template BOOST_REGEX_DECL void perl_matcher<std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator, match_results< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator >::allocator_type, boost::regex_traits<BOOST_REGEX_CHAR_T > >::construct_init(

- const basic_regex<BOOST_REGEX_CHAR_T>& e, match_flag_type f);

-template BOOST_REGEX_DECL bool perl_matcher<std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator, match_results< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator >::allocator_type, boost::regex_traits<BOOST_REGEX_CHAR_T > >::match();

-template BOOST_REGEX_DECL bool perl_matcher<std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator, match_results< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator >::allocator_type, boost::regex_traits<BOOST_REGEX_CHAR_T > >::find();

-} // namespace

-#endif

-

-# ifdef template

-# undef template

-# endif

-

-

-#endif

-

-} // namespace boost

-

-#endif // BOOST_REGEX_NO_EXTERNAL_TEMPLATES

-

-

-

-

-

-/*

- *

- * Copyright (c) 2002

- * John Maddock

- *

- * 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_match.hpp

- * VERSION see <boost/version.hpp>

- * DESCRIPTION: Iterator traits for selecting an iterator type as

- * an integral constant expression.

- */

-

-

-#ifndef BOOST_REGEX_ITERATOR_CATEGORY_HPP

-#define BOOST_REGEX_ITERATOR_CATEGORY_HPP

-

-#include <iterator>

-#include <boost/type_traits/is_convertible.hpp>

-#include <boost/type_traits/is_pointer.hpp>

-

-namespace boost{

-namespace detail{

-

-template <class I>

-struct is_random_imp

-{

-private:

- typedef typename std::iterator_traits<I>::iterator_category cat;

-public:

- BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible<cat*, std::random_access_iterator_tag*>::value));

-};

-

-template <class I>

-struct is_random_pointer_imp

-{

- BOOST_STATIC_CONSTANT(bool, value = true);

-};

-

-template <bool is_pointer_type>

-struct is_random_imp_selector

-{

- template <class I>

- struct rebind

- {

- typedef is_random_imp<I> type;

- };

-};

-

-template <>

-struct is_random_imp_selector<true>

-{

- template <class I>

- struct rebind

- {

- typedef is_random_pointer_imp<I> type;

- };

-};

-

-}

-

-template <class I>

-struct is_random_access_iterator

-{

-private:

- typedef detail::is_random_imp_selector< ::boost::is_pointer<I>::value> selector;

- typedef typename selector::template rebind<I> bound_type;

- typedef typename bound_type::type answer;

-public:

- BOOST_STATIC_CONSTANT(bool, value = answer::value);

-};

-

-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION

-template <class I>

-const bool is_random_access_iterator<I>::value;

-#endif

-

-}

-

-#endif

-

-/*

- *

- * Copyright (c) 1998-2002

- * John Maddock

- *

- * 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 iterator_traits.cpp

- * VERSION see <boost/version.hpp>

- * DESCRIPTION: Declares iterator traits workarounds.

- */

-

-#ifndef BOOST_REGEX_V4_ITERATOR_TRAITS_HPP

-#define BOOST_REGEX_V4_ITERATOR_TRAITS_HPP

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_PREFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-namespace boost{

-namespace re_detail{

-

-#if defined(BOOST_NO_STD_ITERATOR_TRAITS) || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

-

-template <class T>

-struct regex_iterator_traits

-{

- typedef typename T::iterator_category iterator_category;

- typedef typename T::value_type value_type;

-#if !defined(BOOST_NO_STD_ITERATOR)

- typedef typename T::difference_type difference_type;

- typedef typename T::pointer pointer;

- typedef typename T::reference reference;

-#else

- typedef std::ptrdiff_t difference_type;

- typedef value_type* pointer;

- typedef value_type& reference;

-#endif

-};

-

-template <class T>

-struct pointer_iterator_traits

-{

- typedef std::ptrdiff_t difference_type;

- typedef T value_type;

- typedef T* pointer;

- typedef T& reference;

- typedef std::random_access_iterator_tag iterator_category;

-};

-template <class T>

-struct const_pointer_iterator_traits

-{

- typedef std::ptrdiff_t difference_type;

- typedef T value_type;

- typedef const T* pointer;

- typedef const T& reference;

- typedef std::random_access_iterator_tag iterator_category;

-};

-

-template<>

-struct regex_iterator_traits<char*> : pointer_iterator_traits<char>{};

-template<>

-struct regex_iterator_traits<const char*> : const_pointer_iterator_traits<char>{};

-template<>

-struct regex_iterator_traits<wchar_t*> : pointer_iterator_traits<wchar_t>{};

-template<>

-struct regex_iterator_traits<const wchar_t*> : const_pointer_iterator_traits<wchar_t>{};

-//

-// the follwoing are needed for ICU support:

-//

-template<>

-struct regex_iterator_traits<unsigned char*> : pointer_iterator_traits<char>{};

-template<>

-struct regex_iterator_traits<const unsigned char*> : const_pointer_iterator_traits<char>{};

-template<>

-struct regex_iterator_traits<int*> : pointer_iterator_traits<int>{};

-template<>

-struct regex_iterator_traits<const int*> : const_pointer_iterator_traits<int>{};

-

-#ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T

-template<>

-struct regex_iterator_traits<unsigned short*> : pointer_iterator_traits<unsigned short>{};

-template<>

-struct regex_iterator_traits<const unsigned short*> : const_pointer_iterator_traits<unsigned short>{};

-#endif

-

-#if defined(__SGI_STL_PORT) && defined(__STL_DEBUG)

-template<>

-struct regex_iterator_traits<std::string::iterator> : pointer_iterator_traits<char>{};

-template<>

-struct regex_iterator_traits<std::string::const_iterator> : const_pointer_iterator_traits<char>{};

-#ifndef BOOST_NO_STD_WSTRING

-template<>

-struct regex_iterator_traits<std::wstring::iterator> : pointer_iterator_traits<wchar_t>{};

-template<>

-struct regex_iterator_traits<std::wstring::const_iterator> : const_pointer_iterator_traits<wchar_t>{};

-#endif // BOOST_NO_WSTRING

-#endif // stport

-

-#else

-

-template <class T>

-struct regex_iterator_traits : public std::iterator_traits<T> {};

-

-#endif

-

-} // namespace re_detail

-} // namespace boost

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_SUFFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-#endif

-

-/*

- *

- * Copyright (c) 1998-2002

- * John Maddock

- *

- * 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 match_flags.hpp

- * VERSION see <boost/version.hpp>

- * DESCRIPTION: Declares match_flags type.

- */

-

-#ifndef BOOST_REGEX_V4_MATCH_FLAGS

-#define BOOST_REGEX_V4_MATCH_FLAGS

-

-#ifdef __cplusplus

-# include <boost/cstdint.hpp>

-#endif

-

-#ifdef __cplusplus

-namespace boost{

- namespace regex_constants{

-#endif

-

-typedef enum _match_flags

-{

- match_default = 0,

- match_not_bol = 1, // first is not start of line

- match_not_eol = match_not_bol << 1, // last is not end of line

- match_not_bob = match_not_eol << 1, // first is not start of buffer

- match_not_eob = match_not_bob << 1, // last is not end of buffer

- match_not_bow = match_not_eob << 1, // first is not start of word

- match_not_eow = match_not_bow << 1, // last is not end of word

- match_not_dot_newline = match_not_eow << 1, // \n is not matched by '.'

- match_not_dot_null = match_not_dot_newline << 1, // '\0' is not matched by '.'

- match_prev_avail = match_not_dot_null << 1, // *--first is a valid expression

- match_init = match_prev_avail << 1, // internal use

- match_any = match_init << 1, // don't care what we match

- match_not_null = match_any << 1, // string can't be null

- match_continuous = match_not_null << 1, // each grep match must continue from

- // uninterupted from the previous one

- match_partial = match_continuous << 1, // find partial matches

-

- match_stop = match_partial << 1, // stop after first match (grep) V3 only

- match_not_initial_null = match_stop, // don't match initial null, V4 only

- match_all = match_stop << 1, // must find the whole of input even if match_any is set

- match_perl = match_all << 1, // Use perl matching rules

- match_posix = match_perl << 1, // Use POSIX matching rules

- match_nosubs = match_posix << 1, // don't trap marked subs

- match_extra = match_nosubs << 1, // include full capture information for repeated captures

- match_single_line = match_extra << 1, // treat text as single line and ignor any \n's when matching ^ and $.

- match_unused1 = match_single_line << 1, // unused

- match_unused2 = match_unused1 << 1, // unused

- match_unused3 = match_unused2 << 1, // unused

- match_max = match_unused3,

-

- format_perl = 0, // perl style replacement

- format_default = 0, // ditto.

- format_sed = match_max << 1, // sed style replacement.

- format_all = format_sed << 1, // enable all extentions to sytax.

- format_no_copy = format_all << 1, // don't copy non-matching segments.

- format_first_only = format_no_copy << 1, // Only replace first occurance.

- format_is_if = format_first_only << 1, // internal use only.

- format_literal = format_is_if << 1 // treat string as a literal

-

-} match_flags;

-

-#if (defined(_MSC_VER) && (_MSC_VER < 1300)) || defined(__BORLANDC__)

-typedef unsigned long match_flag_type;

-#else

-typedef match_flags match_flag_type;

-

-

-#ifdef __cplusplus

-inline match_flags operator&(match_flags m1, match_flags m2)

-{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) & static_cast<boost::int32_t>(m2)); }

-inline match_flags operator|(match_flags m1, match_flags m2)

-{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) | static_cast<boost::int32_t>(m2)); }

-inline match_flags operator^(match_flags m1, match_flags m2)

-{ return static_cast<match_flags>(static_cast<boost::int32_t>(m1) ^ static_cast<boost::int32_t>(m2)); }

-inline match_flags operator~(match_flags m1)

-{ return static_cast<match_flags>(~static_cast<boost::int32_t>(m1)); }

-inline match_flags& operator&=(match_flags& m1, match_flags m2)

-{ m1 = m1&m2; return m1; }

-inline match_flags& operator|=(match_flags& m1, match_flags m2)

-{ m1 = m1|m2; return m1; }

-inline match_flags& operator^=(match_flags& m1, match_flags m2)

-{ m1 = m1^m2; return m1; }

-#endif

-#endif

-

-#ifdef __cplusplus

-} // namespace regex_constants

-//

-// import names into boost for backwards compatiblity:

-//

-using regex_constants::match_flag_type;

-using regex_constants::match_default;

-using regex_constants::match_not_bol;

-using regex_constants::match_not_eol;

-using regex_constants::match_not_bob;

-using regex_constants::match_not_eob;

-using regex_constants::match_not_bow;

-using regex_constants::match_not_eow;

-using regex_constants::match_not_dot_newline;

-using regex_constants::match_not_dot_null;

-using regex_constants::match_prev_avail;

-//using regex_constants::match_init;

-using regex_constants::match_any;

-using regex_constants::match_not_null;

-using regex_constants::match_continuous;

-using regex_constants::match_partial;

-//using regex_constants::match_stop;

-using regex_constants::match_all;

-using regex_constants::match_perl;

-using regex_constants::match_posix;

-using regex_constants::match_nosubs;

-using regex_constants::match_extra;

-using regex_constants::match_single_line;

-//using regex_constants::match_max;

-using regex_constants::format_all;

-using regex_constants::format_sed;

-using regex_constants::format_perl;

-using regex_constants::format_default;

-using regex_constants::format_no_copy;

-using regex_constants::format_first_only;

-//using regex_constants::format_is_if;

-

-} // namespace boost

-#endif // __cplusplus

-#endif // include guard

-

-/*

- *

- * Copyright (c) 1998-2002

- * John Maddock

- *

- * 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 match_results.cpp

- * VERSION see <boost/version.hpp>

- * DESCRIPTION: Declares template class match_results.

- */

-

-#ifndef BOOST_REGEX_V4_MATCH_RESULTS_HPP

-#define BOOST_REGEX_V4_MATCH_RESULTS_HPP

-

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable: 4103)

-#endif

-#ifdef BOOST_HAS_ABI_HEADERS

-# include BOOST_ABI_PREFIX

-#endif

-#ifdef BOOST_MSVC

-#pragma warning(pop)

-#endif

-

-namespace boost{

-#ifdef BOOST_MSVC

-#pragma warning(push)

-#pragma warning(disable : 4251 4231 4660)

-#endif

-

-template <class BidiIterator, class Allocator>

-class match_results

-{

-private:

-#ifndef BOOST_NO_STD_ALLOCATOR

- typedef std::vector<sub_match<BidiIterator>, Allocator> vector_type;

-#else

- typedef std::vector<sub_match<BidiIterator> > vector_type;

-#endif

-public:

- typedef sub_match<BidiIterator> value_type;

-#if !defined(BOOST_NO_STD_ALLOCATOR) && !(defined(BOOST_MSVC) && defined(_STLPORT_VERSION))

- typedef typename Allocator::const_reference const_reference;

-#else

- typedef const value_type& const_reference;

-#endif

- typedef const_reference reference;

- typedef typename vector_type::const_iterator const_iterator;

- typedef const_iterator iterator;

- typedef typename re_detail::regex_iterator_traits<

- BidiIterator>::difference_type difference_type;

- typedef typename Allocator::size_type size_type;

- typedef Allocator allocator_type;

- typedef typename re_detail::regex_iterator_traits<

- BidiIterator>::value_type char_type;

- typedef std::basic_string<char_type> string_type;

-

- // construct/copy/destroy:

- explicit match_results(const Allocator& a = Allocator())

-#ifndef BOOST_NO_STD_ALLOCATOR

- : m_subs(a), m_base() {}

-#else

- : m_subs(), m_base() { (void)a; }

-#endif

- match_results(const match_results& m)

- : m_subs(m.m_subs), m_base(m.m_base) {}

- match_results& operator=(const match_results& m)

- {

- m_subs = m.m_subs;

- m_base = m.m_base;

- return *this;

- }

- ~match_results(){}

-

- // size:

- size_type size() const

- { return empty() ? 0 : m_subs.size() - 2; }

- size_type max_size() const

- { return m_subs.max_size(); }

- bool empty() const

- { return m_subs.size() < 2; }

- // element access:

- difference_type length(int sub = 0) const

- {

- sub += 2;

- if((sub < (int)m_subs.size()) && (sub > 0))

- return m_subs[sub].length();

- return 0;

- }

- difference_type position(size_type sub = 0) const

- {

- sub += 2;

- if(sub < m_subs.size())

- {

- const sub_match<BidiIterator>& s = m_subs[sub];

- if(s.matched || (sub == 2))

- {

- return ::boost::re_detail::distance((BidiIterator)(m_base), (BidiIterator)(s.first));

- }

- }

- return ~static_cast<difference_type>(0);

- }

- string_type str(int sub = 0) const

- {

- sub += 2;

- string_type result;

- if(sub < (int)m_subs.size() && (sub > 0))

- {

- const sub_match<BidiIterator>& s = m_subs[sub];

- if(s.matched)

- {

- result = s.str();

- }

- }

- return result;

- }

- const_reference operator[](int sub) const

- {

- sub += 2;

- if(sub < (int)m_subs.size() && (sub >= 0))

- {

- return m_subs[sub];

- }

- return m_null;

- }

-

- const_reference prefix() const

- {

- return (*this)[-1];

- }

-

- const_reference suffix() const

- {

- return (*this)[-2];

- }

- const_iterator begin() const

- {

- return (m_subs.size() > 2) ? (m_subs.begin() + 2) : m_subs.end();

- }

- const_iterator end() const

- {

- return m_subs.end();

- }

- // format:

- template <class OutputIterator>

- OutputIterator format(OutputIterator out,

- const string_type& fmt,

- match_flag_type flags = format_default) const

- {

- re_detail::trivial_format_traits<char_type> traits;

- return re_detail::regex_format_imp(out, *this, fmt.data(), fmt.data() + fmt.size(), flags, traits);

- }

- string_type format(const string_type& fmt,

- match_flag_type flags = format_default) const

- {

- string_type result;

- re_detail::string_out_iterator<string_type> i(result);

- re_detail::trivial_format_traits<char_type> traits;

- re_detail::regex_format_imp(i, *this, fmt.data(), fmt.data() + fmt.size(), flags, traits);

- return result;

- }

- // format with locale:

- template <class OutputIterator, class RegexT>

- OutputIterator format(OutputIterator out,

- const string_type& fmt,

- match_flag_type flags,

- const RegexT& re) const

- {

- return ::boost::re_detail::regex_format_imp(out, *this, fmt.data(), fmt.data() + fmt.size(), flags, re.get_traits());

- }

- template <class RegexT>

- string_type format(const string_type& fmt,

- match_flag_type flags,

- const RegexT& re) const

- {

- string_type result;

- re_detail::string_out_iterator<string_type> i(result);

- ::boost::re_detail::regex_format_imp(i, *this, fmt.data(), fmt.data() + fmt.size(), flags, re.get_traits());

- return result;

- }

-

- allocator_type get_allocator() const

- {

-#ifndef BOOST_NO_STD_ALLOCATOR

- return m_subs.get_allocator();

-#else

- return allocator_type();

-#endif

- }

- void swap(match_results& that)

- {

- std::swap(m_subs, that.m_subs);

- std::swap(m_base, that.m_base);

- }

- bool operator==(const match_results& that)const

- {

- return (m_subs == that.m_subs) && (m_base == that.m_base);

- }

- bool operator!=(const match_results& that)const

- { return !(*this == that); }

-

-#ifdef BOOST_REGEX_MATCH_EXTRA

- typedef typename sub_match<BidiIterator>::capture_sequence_type capture_sequence_type;

-

- const capture_sequence_type& captures(int i)const

- {

- return (*this)[i].captures();

- }

-#endif

-

- //

- // private access functions:

- void BOOST_REGEX_CALL set_second(BidiIterator i)

- {

- BOOST_ASSERT(m_subs.size() > 2);

- m_subs[2].second = i;

- m_subs[2].matched = true;

- m_subs[0].first = i;

- m_subs[0].matched = (m_subs[0].first != m_subs[0].second);

- m_null.first = i;

- m_null.second = i;

- m_null.matched = false;

- }

-

- void BOOST_REGEX_CALL set_second(BidiIterator i, size_type pos, bool m = true)

- {

- pos += 2;

- BOOST_ASSERT(m_subs.size() > pos);

- m_subs[pos].second = i;

- m_subs[pos].matched = m;

- if(pos == 2)

- {

- m_subs[0].first = i;

- m_subs[0].matched = (m_subs[0].first != m_subs[0].second);

- m_null.first = i;

- m_null.second = i;

- m_null.matched = false;

- }

- }

- void BOOST_REGEX_CALL set_size(size_type n, BidiIterator i, BidiIterator j)

- {

- value_type v(j);

- size_type len = m_subs.size();

- if(len > n + 2)

- {

- m_subs.erase(m_subs.begin()+n+2, m_subs.end());

- std::fill(m_subs.begin(), m_subs.end(), v);

- }

- else

- {

- std::fill(m_subs.begin(), m_subs.end(), v);

- if(n+2 != len)

- m_subs.insert(m_subs.end(), n+2-len, v);

- }

- m_subs[1].first = i;

- }

- void BOOST_REGEX_CALL set_base(BidiIterator pos)

- {

- m_base = pos;

- }

- BidiIterator base()const

- {

- return m_base;

- }

- void BOOST_REGEX_CALL set_first(BidiIterator i)

- {

- // set up prefix:

- m_subs[1].second = i;

- m_subs[1].matched = (m_subs[1].first != i);

- // set up $0:

- m_subs[2].first = i;

- // zero out everything else:

- for(size_type n = 3; n < m_subs.size(); ++n)

- {

- m_subs[n].first = m_subs[n].second = m_subs[0].second;

- m_subs[n].matched = false;

- }

- }

- void BOOST_REGEX_CALL set_first(BidiIterator i, size_type pos)

- {

- BOOST_ASSERT(pos+2 < m_subs.size());

- if(pos)

- m_subs[pos+2].first = i;