/* | |
* | |
* 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 | |
#include <boost/type_traits/is_same.hpp> | |
#include <boost/functional/hash.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; | |
template <class I> | |
void bubble_down_one(I first, I last) | |
{ | |
if(first != last) | |
{ | |
I next = last - 1; | |
while((next != first) && (*next < *(next-1))) | |
{ | |
(next-1)->swap(*next); | |
--next; | |
} | |
} | |
} | |
template <class Iterator> | |
inline int hash_value_from_capture_name(Iterator i, Iterator j) | |
{ | |
std::size_t r = boost::hash_range(i, j); | |
r %= ((std::numeric_limits<int>::max)() - 10001); | |
r += 10000; | |
return static_cast<int>(r); | |
} | |
class named_subexpressions | |
{ | |
public: | |
struct name | |
{ | |
template <class charT> | |
name(const charT* i, const charT* j, int idx) | |
: index(idx) | |
{ | |
hash = hash_value_from_capture_name(i, j); | |
} | |
name(int h, int idx) | |
: index(idx), hash(h) | |
{ | |
} | |
int index; | |
int hash; | |
bool operator < (const name& other)const | |
{ | |
return hash < other.hash; | |
} | |
bool operator == (const name& other)const | |
{ | |
return hash == other.hash; | |
} | |
void swap(name& other) | |
{ | |
std::swap(index, other.index); | |
std::swap(hash, other.hash); | |
} | |
}; | |
typedef std::vector<name>::const_iterator const_iterator; | |
typedef std::pair<const_iterator, const_iterator> range_type; | |
named_subexpressions(){} | |
template <class charT> | |
void set_name(const charT* i, const charT* j, int index) | |
{ | |
m_sub_names.push_back(name(i, j, index)); | |
bubble_down_one(m_sub_names.begin(), m_sub_names.end()); | |
} | |
template <class charT> | |
int get_id(const charT* i, const charT* j)const | |
{ | |
name t(i, j, 0); | |
typename std::vector<name>::const_iterator pos = std::lower_bound(m_sub_names.begin(), m_sub_names.end(), t); | |
if((pos != m_sub_names.end()) && (*pos == t)) | |
{ | |
return pos->index; | |
} | |
return -1; | |
} | |
template <class charT> | |
range_type equal_range(const charT* i, const charT* j)const | |
{ | |
name t(i, j, 0); | |
return std::equal_range(m_sub_names.begin(), m_sub_names.end(), t); | |
} | |
int get_id(int h)const | |
{ | |
name t(h, 0); | |
std::vector<name>::const_iterator pos = std::lower_bound(m_sub_names.begin(), m_sub_names.end(), t); | |
if((pos != m_sub_names.end()) && (*pos == t)) | |
{ | |
return pos->index; | |
} | |
return -1; | |
} | |
range_type equal_range(int h)const | |
{ | |
name t(h, 0); | |
return std::equal_range(m_sub_names.begin(), m_sub_names.end(), t); | |
} | |
private: | |
std::vector<name> m_sub_names; | |
}; | |
// | |
// class regex_data: | |
// represents the data we wish to expose to the matching algorithms. | |
// | |
template <class charT, class traits> | |
struct regex_data : public named_subexpressions | |
{ | |
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*. | |
bool m_has_recursions; // whether we have recursive expressions; | |
}; | |
// | |
// 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(); | |
} | |
boost::shared_ptr<re_detail::named_subexpressions > get_named_subs()const | |
{ | |
return m_pimpl; | |
} | |
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 | |