513 lines
22 KiB
C++
513 lines
22 KiB
C++
/*
|
|
*
|
|
* 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 sub_match.cpp
|
|
* VERSION see <boost/version.hpp>
|
|
* DESCRIPTION: Declares template class sub_match.
|
|
*/
|
|
|
|
#ifndef BOOST_REGEX_V4_SUB_MATCH_HPP
|
|
#define BOOST_REGEX_V4_SUB_MATCH_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{
|
|
|
|
template <class BidiIterator>
|
|
struct sub_match : public std::pair<BidiIterator, BidiIterator>
|
|
{
|
|
typedef typename re_detail::regex_iterator_traits<BidiIterator>::value_type value_type;
|
|
#if defined(BOOST_NO_STD_ITERATOR_TRAITS) || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
|
|
typedef std::ptrdiff_t difference_type;
|
|
#else
|
|
typedef typename re_detail::regex_iterator_traits<BidiIterator>::difference_type difference_type;
|
|
#endif
|
|
typedef BidiIterator iterator_type;
|
|
typedef BidiIterator iterator;
|
|
typedef BidiIterator const_iterator;
|
|
|
|
bool matched;
|
|
|
|
sub_match() : std::pair<BidiIterator, BidiIterator>(), matched(false) {}
|
|
sub_match(BidiIterator i) : std::pair<BidiIterator, BidiIterator>(i, i), matched(false) {}
|
|
#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\
|
|
&& !BOOST_WORKAROUND(BOOST_MSVC, < 1310)\
|
|
&& !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)\
|
|
&& !BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
|
|
template <class T, class A>
|
|
operator std::basic_string<value_type, T, A> ()const
|
|
{
|
|
return matched ? std::basic_string<value_type, T, A>(this->first, this->second) : std::basic_string<value_type, T, A>();
|
|
}
|
|
#else
|
|
operator std::basic_string<value_type> ()const
|
|
{
|
|
return str();
|
|
}
|
|
#endif
|
|
difference_type BOOST_REGEX_CALL length()const
|
|
{
|
|
difference_type n = matched ? ::boost::re_detail::distance((BidiIterator)this->first, (BidiIterator)this->second) : 0;
|
|
return n;
|
|
}
|
|
std::basic_string<value_type> str()const
|
|
{
|
|
std::basic_string<value_type> result;
|
|
if(matched)
|
|
{
|
|
std::size_t len = ::boost::re_detail::distance((BidiIterator)this->first, (BidiIterator)this->second);
|
|
result.reserve(len);
|
|
BidiIterator i = this->first;
|
|
while(i != this->second)
|
|
{
|
|
result.append(1, *i);
|
|
++i;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
int compare(const sub_match& s)const
|
|
{
|
|
if(matched != s.matched)
|
|
return static_cast<int>(matched) - static_cast<int>(s.matched);
|
|
return str().compare(s.str());
|
|
}
|
|
int compare(const std::basic_string<value_type>& s)const
|
|
{
|
|
return str().compare(s);
|
|
}
|
|
int compare(const value_type* p)const
|
|
{
|
|
return str().compare(p);
|
|
}
|
|
|
|
bool operator==(const sub_match& that)const
|
|
{ return compare(that) == 0; }
|
|
bool BOOST_REGEX_CALL operator !=(const sub_match& that)const
|
|
{ return compare(that) != 0; }
|
|
bool operator<(const sub_match& that)const
|
|
{ return compare(that) < 0; }
|
|
bool operator>(const sub_match& that)const
|
|
{ return compare(that) > 0; }
|
|
bool operator<=(const sub_match& that)const
|
|
{ return compare(that) <= 0; }
|
|
bool operator>=(const sub_match& that)const
|
|
{ return compare(that) >= 0; }
|
|
|
|
#ifdef BOOST_REGEX_MATCH_EXTRA
|
|
typedef std::vector<sub_match<BidiIterator> > capture_sequence_type;
|
|
|
|
const capture_sequence_type& captures()const
|
|
{
|
|
if(!m_captures)
|
|
m_captures.reset(new capture_sequence_type());
|
|
return *m_captures;
|
|
}
|
|
//
|
|
// Private implementation API: DO NOT USE!
|
|
//
|
|
capture_sequence_type& get_captures()const
|
|
{
|
|
if(!m_captures)
|
|
m_captures.reset(new capture_sequence_type());
|
|
return *m_captures;
|
|
}
|
|
|
|
private:
|
|
mutable boost::scoped_ptr<capture_sequence_type> m_captures;
|
|
public:
|
|
|
|
#endif
|
|
sub_match(const sub_match& that, bool
|
|
#ifdef BOOST_REGEX_MATCH_EXTRA
|
|
deep_copy
|
|
#endif
|
|
= true
|
|
)
|
|
: std::pair<BidiIterator, BidiIterator>(that),
|
|
matched(that.matched)
|
|
{
|
|
#ifdef BOOST_REGEX_MATCH_EXTRA
|
|
if(that.m_captures)
|
|
if(deep_copy)
|
|
m_captures.reset(new capture_sequence_type(*(that.m_captures)));
|
|
#endif
|
|
}
|
|
sub_match& operator=(const sub_match& that)
|
|
{
|
|
this->first = that.first;
|
|
this->second = that.second;
|
|
matched = that.matched;
|
|
#ifdef BOOST_REGEX_MATCH_EXTRA
|
|
if(that.m_captures)
|
|
get_captures() = *(that.m_captures);
|
|
#endif
|
|
return *this;
|
|
}
|
|
|
|
|
|
#ifdef BOOST_OLD_REGEX_H
|
|
//
|
|
// the following are deprecated, do not use!!
|
|
//
|
|
operator int()const;
|
|
operator unsigned int()const;
|
|
operator short()const
|
|
{
|
|
return (short)(int)(*this);
|
|
}
|
|
operator unsigned short()const
|
|
{
|
|
return (unsigned short)(unsigned int)(*this);
|
|
}
|
|
#endif
|
|
};
|
|
|
|
typedef sub_match<const char*> csub_match;
|
|
typedef sub_match<std::string::const_iterator> ssub_match;
|
|
#ifndef BOOST_NO_WREGEX
|
|
typedef sub_match<const wchar_t*> wcsub_match;
|
|
typedef sub_match<std::wstring::const_iterator> wssub_match;
|
|
#endif
|
|
|
|
// comparison to std::basic_string<> part 1:
|
|
template <class RandomAccessIterator, class traits, class Allocator>
|
|
inline bool operator == (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return s.compare(m.str()) == 0; }
|
|
template <class RandomAccessIterator, class traits, class Allocator>
|
|
inline bool operator != (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return s.compare(m.str()) != 0; }
|
|
template <class RandomAccessIterator, class traits, class Allocator>
|
|
inline bool operator < (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return s.compare(m.str()) < 0; }
|
|
template <class RandomAccessIterator, class traits, class Allocator>
|
|
inline bool operator <= (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return s.compare(m.str()) <= 0; }
|
|
template <class RandomAccessIterator, class traits, class Allocator>
|
|
inline bool operator >= (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return s.compare(m.str()) >= 0; }
|
|
template <class RandomAccessIterator, class traits, class Allocator>
|
|
inline bool operator > (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return s.compare(m.str()) > 0; }
|
|
// comparison to std::basic_string<> part 2:
|
|
template <class RandomAccessIterator, class traits, class Allocator>
|
|
inline bool operator == (const sub_match<RandomAccessIterator>& m,
|
|
const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
|
|
{ return m.str().compare(s) == 0; }
|
|
template <class RandomAccessIterator, class traits, class Allocator>
|
|
inline bool operator != (const sub_match<RandomAccessIterator>& m,
|
|
const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
|
|
{ return m.str().compare(s) != 0; }
|
|
template <class RandomAccessIterator, class traits, class Allocator>
|
|
inline bool operator < (const sub_match<RandomAccessIterator>& m,
|
|
const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
|
|
{ return m.str().compare(s) < 0; }
|
|
template <class RandomAccessIterator, class traits, class Allocator>
|
|
inline bool operator > (const sub_match<RandomAccessIterator>& m,
|
|
const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
|
|
{ return m.str().compare(s) > 0; }
|
|
template <class RandomAccessIterator, class traits, class Allocator>
|
|
inline bool operator <= (const sub_match<RandomAccessIterator>& m,
|
|
const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
|
|
{ return m.str().compare(s) <= 0; }
|
|
template <class RandomAccessIterator, class traits, class Allocator>
|
|
inline bool operator >= (const sub_match<RandomAccessIterator>& m,
|
|
const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
|
|
{ return m.str().compare(s) >= 0; }
|
|
// comparison to const charT* part 1:
|
|
template <class RandomAccessIterator>
|
|
inline bool operator == (const sub_match<RandomAccessIterator>& m,
|
|
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
|
|
{ return m.str().compare(s) == 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator != (const sub_match<RandomAccessIterator>& m,
|
|
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
|
|
{ return m.str().compare(s) != 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator > (const sub_match<RandomAccessIterator>& m,
|
|
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
|
|
{ return m.str().compare(s) > 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator < (const sub_match<RandomAccessIterator>& m,
|
|
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
|
|
{ return m.str().compare(s) < 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator >= (const sub_match<RandomAccessIterator>& m,
|
|
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
|
|
{ return m.str().compare(s) >= 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator <= (const sub_match<RandomAccessIterator>& m,
|
|
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)
|
|
{ return m.str().compare(s) <= 0; }
|
|
// comparison to const charT* part 2:
|
|
template <class RandomAccessIterator>
|
|
inline bool operator == (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return m.str().compare(s) == 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator != (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return m.str().compare(s) != 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator < (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return m.str().compare(s) > 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator > (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return m.str().compare(s) < 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator <= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return m.str().compare(s) >= 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator >= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return m.str().compare(s) <= 0; }
|
|
|
|
// comparison to const charT& part 1:
|
|
template <class RandomAccessIterator>
|
|
inline bool operator == (const sub_match<RandomAccessIterator>& m,
|
|
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
|
|
{ return m.str().compare(0, m.length(), &s, 1) == 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator != (const sub_match<RandomAccessIterator>& m,
|
|
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
|
|
{ return m.str().compare(0, m.length(), &s, 1) != 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator > (const sub_match<RandomAccessIterator>& m,
|
|
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
|
|
{ return m.str().compare(0, m.length(), &s, 1) > 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator < (const sub_match<RandomAccessIterator>& m,
|
|
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
|
|
{ return m.str().compare(0, m.length(), &s, 1) < 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator >= (const sub_match<RandomAccessIterator>& m,
|
|
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
|
|
{ return m.str().compare(0, m.length(), &s, 1) >= 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator <= (const sub_match<RandomAccessIterator>& m,
|
|
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
|
|
{ return m.str().compare(0, m.length(), &s, 1) <= 0; }
|
|
// comparison to const charT* part 2:
|
|
template <class RandomAccessIterator>
|
|
inline bool operator == (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return m.str().compare(0, m.length(), &s, 1) == 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator != (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return m.str().compare(0, m.length(), &s, 1) != 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator < (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return m.str().compare(0, m.length(), &s, 1) > 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator > (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return m.str().compare(0, m.length(), &s, 1) < 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator <= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return m.str().compare(0, m.length(), &s, 1) >= 0; }
|
|
template <class RandomAccessIterator>
|
|
inline bool operator >= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{ return m.str().compare(0, m.length(), &s, 1) <= 0; }
|
|
|
|
// addition operators:
|
|
template <class RandomAccessIterator, class traits, class Allocator>
|
|
inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>
|
|
operator + (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{
|
|
std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> result;
|
|
result.reserve(s.size() + m.length() + 1);
|
|
return result.append(s).append(m.first, m.second);
|
|
}
|
|
template <class RandomAccessIterator, class traits, class Allocator>
|
|
inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>
|
|
operator + (const sub_match<RandomAccessIterator>& m,
|
|
const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
|
|
{
|
|
std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> result;
|
|
result.reserve(s.size() + m.length() + 1);
|
|
return result.append(m.first, m.second).append(s);
|
|
}
|
|
#if !(defined(__GNUC__) && defined(BOOST_NO_STD_LOCALE))
|
|
template <class RandomAccessIterator>
|
|
inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>
|
|
operator + (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{
|
|
std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;
|
|
result.reserve(std::char_traits<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);
|
|
return result.append(s).append(m.first, m.second);
|
|
}
|
|
template <class RandomAccessIterator>
|
|
inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>
|
|
operator + (const sub_match<RandomAccessIterator>& m,
|
|
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const * s)
|
|
{
|
|
std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;
|
|
result.reserve(std::char_traits<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);
|
|
return result.append(m.first, m.second).append(s);
|
|
}
|
|
#else
|
|
// worwaround versions:
|
|
template <class RandomAccessIterator>
|
|
inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>
|
|
operator + (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{
|
|
return s + m.str();
|
|
}
|
|
template <class RandomAccessIterator>
|
|
inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>
|
|
operator + (const sub_match<RandomAccessIterator>& m,
|
|
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const * s)
|
|
{
|
|
return m.str() + s;
|
|
}
|
|
#endif
|
|
template <class RandomAccessIterator>
|
|
inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>
|
|
operator + (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,
|
|
const sub_match<RandomAccessIterator>& m)
|
|
{
|
|
std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;
|
|
result.reserve(m.length() + 2);
|
|
return result.append(1, s).append(m.first, m.second);
|
|
}
|
|
template <class RandomAccessIterator>
|
|
inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>
|
|
operator + (const sub_match<RandomAccessIterator>& m,
|
|
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
|
|
{
|
|
std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;
|
|
result.reserve(m.length() + 2);
|
|
return result.append(m.first, m.second).append(1, s);
|
|
}
|
|
template <class RandomAccessIterator>
|
|
inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>
|
|
operator + (const sub_match<RandomAccessIterator>& m1,
|
|
const sub_match<RandomAccessIterator>& m2)
|
|
{
|
|
std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;
|
|
result.reserve(m1.length() + m2.length() + 1);
|
|
return result.append(m1.first, m1.second).append(m2.first, m2.second);
|
|
}
|
|
#ifndef BOOST_NO_STD_LOCALE
|
|
template <class charT, class traits, class RandomAccessIterator>
|
|
std::basic_ostream<charT, traits>&
|
|
operator << (std::basic_ostream<charT, traits>& os,
|
|
const sub_match<RandomAccessIterator>& s)
|
|
{
|
|
return (os << s.str());
|
|
}
|
|
#else
|
|
template <class RandomAccessIterator>
|
|
std::ostream& operator << (std::ostream& os,
|
|
const sub_match<RandomAccessIterator>& s)
|
|
{
|
|
return (os << s.str());
|
|
}
|
|
#endif
|
|
|
|
#ifdef BOOST_OLD_REGEX_H
|
|
namespace re_detail{
|
|
template <class BidiIterator, class charT>
|
|
int do_toi(BidiIterator i, BidiIterator j, char c, int radix)
|
|
{
|
|
std::string s(i, j);
|
|
char* p;
|
|
int result = std::strtol(s.c_str(), &p, radix);
|
|
if(*p)raise_regex_exception("Bad sub-expression");
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// helper:
|
|
template <class I, class charT>
|
|
int do_toi(I& i, I j, charT c)
|
|
{
|
|
int result = 0;
|
|
while((i != j) && (isdigit(*i)))
|
|
{
|
|
result = result*10 + (*i - '0');
|
|
++i;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
|
|
template <class BidiIterator>
|
|
sub_match<BidiIterator>::operator int()const
|
|
{
|
|
BidiIterator i = first;
|
|
BidiIterator j = second;
|
|
if(i == j)raise_regex_exception("Bad sub-expression");
|
|
int neg = 1;
|
|
if((i != j) && (*i == '-'))
|
|
{
|
|
neg = -1;
|
|
++i;
|
|
}
|
|
neg *= re_detail::do_toi(i, j, *i);
|
|
if(i != j)raise_regex_exception("Bad sub-expression");
|
|
return neg;
|
|
}
|
|
template <class BidiIterator>
|
|
sub_match<BidiIterator>::operator unsigned int()const
|
|
{
|
|
BidiIterator i = first;
|
|
BidiIterator j = second;
|
|
if(i == j)
|
|
raise_regex_exception("Bad sub-expression");
|
|
return re_detail::do_toi(i, j, *first);
|
|
}
|
|
#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
|
|
|