1 /*

     2  *

     3  * Copyright (c) 1998-2002

     4  * John Maddock

     5  *

     6  * Use, modification and distribution are subject to the 

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

     8  * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

     9  *

    10  */

    11 

    12  /*

    13   *   LOCATION:    see http://www.boost.org for most recent version.

    14   *   FILE         sub_match.cpp

    15   *   VERSION      see <boost/version.hpp>

    16   *   DESCRIPTION: Declares template class sub_match.

    17   */

    18 

    19 #ifndef BOOST_REGEX_V4_SUB_MATCH_HPP

    20 #define BOOST_REGEX_V4_SUB_MATCH_HPP

    21 

    22 #ifdef BOOST_MSVC

    23 #pragma warning(push)

    24 #pragma warning(disable: 4103)

    25 #endif

    26 #ifdef BOOST_HAS_ABI_HEADERS

    27 #  include BOOST_ABI_PREFIX

    28 #endif

    29 #ifdef BOOST_MSVC

    30 #pragma warning(pop)

    31 #endif

    32 

    33 namespace boost{

    34 

    35 template <class BidiIterator>

    36 struct sub_match : public std::pair<BidiIterator, BidiIterator>

    37 {

    38    typedef typename re_detail::regex_iterator_traits<BidiIterator>::value_type       value_type;

    39 #if defined(BOOST_NO_STD_ITERATOR_TRAITS) || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

    40    typedef          std::ptrdiff_t                                                   difference_type;

    41 #else

    42    typedef typename re_detail::regex_iterator_traits<BidiIterator>::difference_type  difference_type;

    43 #endif

    44    typedef          BidiIterator                                                     iterator_type;

    45    typedef          BidiIterator                                                     iterator;

    46    typedef          BidiIterator                                                     const_iterator;

    47 

    48    bool matched;

    49 

    50    sub_match() : std::pair<BidiIterator, BidiIterator>(), matched(false) {}

    51    sub_match(BidiIterator i) : std::pair<BidiIterator, BidiIterator>(i, i), matched(false) {}

    52 #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\

    53                && !BOOST_WORKAROUND(BOOST_MSVC, < 1310)\

    54                && !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)\

    55                && !BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))

    56    template <class T, class A>

    57    operator std::basic_string<value_type, T, A> ()const

    58    {

    59       return std::basic_string<value_type, T, A>(this->first, this->second);

    60    }

    61 #else

    62    operator std::basic_string<value_type> ()const

    63    {

    64       return str();

    65    }

    66 #endif

    67    difference_type BOOST_REGEX_CALL length()const

    68    {

    69       difference_type n = ::boost::re_detail::distance((BidiIterator)this->first, (BidiIterator)this->second);

    70       return n;

    71    }

    72    std::basic_string<value_type> str()const

    73    {

    74       std::basic_string<value_type> result;

    75       std::size_t len = ::boost::re_detail::distance((BidiIterator)this->first, (BidiIterator)this->second);

    76       result.reserve(len);

    77       BidiIterator i = this->first;

    78       while(i != this->second)

    79       {

    80          result.append(1, *i);

    81          ++i;

    82       }

    83       return result;

    84    }

    85    int compare(const sub_match& s)const

    86    {

    87       if(matched != s.matched)

    88          return static_cast<int>(matched) - static_cast<int>(s.matched);

    89       return str().compare(s.str());

    90    }

    91    int compare(const std::basic_string<value_type>& s)const

    92    {

    93       return str().compare(s);

    94    }

    95    int compare(const value_type* p)const

    96    {

    97       return str().compare(p);

    98    }

    99 

   100    bool operator==(const sub_match& that)const

   101    { return compare(that) == 0; }

   102    bool BOOST_REGEX_CALL operator !=(const sub_match& that)const

   103    { return compare(that) != 0; }

   104    bool operator<(const sub_match& that)const

   105    { return compare(that) < 0; }

   106    bool operator>(const sub_match& that)const

   107    { return compare(that) > 0; }

   108    bool operator<=(const sub_match& that)const

   109    { return compare(that) <= 0; }

   110    bool operator>=(const sub_match& that)const

   111    { return compare(that) >= 0; }

   112 

   113 #ifdef BOOST_REGEX_MATCH_EXTRA

   114    typedef std::vector<sub_match<BidiIterator> > capture_sequence_type;

   115 

   116    const capture_sequence_type& captures()const

   117    {

   118       if(!m_captures) 

   119          m_captures.reset(new capture_sequence_type());

   120       return *m_captures;

   121    }

   122    //

   123    // Private implementation API: DO NOT USE!

   124    //

   125    capture_sequence_type& get_captures()const

   126    {

   127       if(!m_captures) 

   128          m_captures.reset(new capture_sequence_type());

   129       return *m_captures;

   130    }

   131 

   132 private:

   133    mutable boost::scoped_ptr<capture_sequence_type> m_captures;

   134 public:

   135 

   136 #endif

   137    sub_match(const sub_match& that, bool 

   138 #ifdef BOOST_REGEX_MATCH_EXTRA

   139       deep_copy

   140 #endif

   141       = true

   142       ) 

   143       : std::pair<BidiIterator, BidiIterator>(that), 

   144         matched(that.matched) 

   145    {

   146 #ifdef BOOST_REGEX_MATCH_EXTRA

   147       if(that.m_captures)

   148          if(deep_copy)

   149             m_captures.reset(new capture_sequence_type(*(that.m_captures)));

   150 #endif

   151    }

   152    sub_match& operator=(const sub_match& that)

   153    {

   154       this->first = that.first;

   155       this->second = that.second;

   156       matched = that.matched;

   157 #ifdef BOOST_REGEX_MATCH_EXTRA

   158       if(that.m_captures)

   159          get_captures() = *(that.m_captures);

   160 #endif

   161       return *this;

   162    }

   163 

   164 

   165 #ifdef BOOST_OLD_REGEX_H

   166    //

   167    // the following are deprecated, do not use!!

   168    //

   169    operator int()const;

   170    operator unsigned int()const;

   171    operator short()const

   172    {

   173       return (short)(int)(*this);

   174    }

   175    operator unsigned short()const

   176    {

   177       return (unsigned short)(unsigned int)(*this);

   178    }

   179 #endif

   180 };

   181 

   182 typedef sub_match<const char*> csub_match;

   183 typedef sub_match<std::string::const_iterator> ssub_match;

   184 #ifndef BOOST_NO_WREGEX

   185 typedef sub_match<const wchar_t*> wcsub_match;

   186 typedef sub_match<std::wstring::const_iterator> wssub_match;

   187 #endif

   188 

   189 // comparison to std::basic_string<> part 1:

   190 template <class RandomAccessIterator, class traits, class Allocator>

   191 inline bool operator == (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,

   192                   const sub_match<RandomAccessIterator>& m)

   193 { return s.compare(m.str()) == 0; }

   194 template <class RandomAccessIterator, class traits, class Allocator>

   195 inline bool operator != (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,

   196                   const sub_match<RandomAccessIterator>& m)

   197 { return s.compare(m.str()) != 0; }

   198 template <class RandomAccessIterator, class traits, class Allocator>

   199 inline bool operator < (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,

   200                  const sub_match<RandomAccessIterator>& m)

   201 { return s.compare(m.str()) < 0; }

   202 template <class RandomAccessIterator, class traits, class Allocator>

   203 inline bool operator <= (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,

   204                   const sub_match<RandomAccessIterator>& m)

   205 { return s.compare(m.str()) <= 0; }

   206 template <class RandomAccessIterator, class traits, class Allocator>

   207 inline bool operator >= (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,

   208                   const sub_match<RandomAccessIterator>& m)

   209 { return s.compare(m.str()) >= 0; }

   210 template <class RandomAccessIterator, class traits, class Allocator>

   211 inline bool operator > (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,

   212                  const sub_match<RandomAccessIterator>& m)

   213 { return s.compare(m.str()) > 0; }

   214 // comparison to std::basic_string<> part 2:

   215 template <class RandomAccessIterator, class traits, class Allocator>

   216 inline bool operator == (const sub_match<RandomAccessIterator>& m,

   217                   const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)

   218 { return m.str().compare(s) == 0; }

   219 template <class RandomAccessIterator, class traits, class Allocator>

   220 inline bool operator != (const sub_match<RandomAccessIterator>& m,

   221                   const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)

   222 { return m.str().compare(s) != 0; }

   223 template <class RandomAccessIterator, class traits, class Allocator>

   224 inline bool operator < (const sub_match<RandomAccessIterator>& m,

   225                   const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)

   226 { return m.str().compare(s) < 0; }

   227 template <class RandomAccessIterator, class traits, class Allocator>

   228 inline bool operator > (const sub_match<RandomAccessIterator>& m,

   229                   const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)

   230 { return m.str().compare(s) > 0; }

   231 template <class RandomAccessIterator, class traits, class Allocator>

   232 inline bool operator <= (const sub_match<RandomAccessIterator>& m,

   233                   const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)

   234 { return m.str().compare(s) <= 0; }

   235 template <class RandomAccessIterator, class traits, class Allocator>

   236 inline bool operator >= (const sub_match<RandomAccessIterator>& m,

   237                   const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)

   238 { return m.str().compare(s) >= 0; }

   239 // comparison to const charT* part 1:

   240 template <class RandomAccessIterator>

   241 inline bool operator == (const sub_match<RandomAccessIterator>& m,

   242                   typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)

   243 { return m.str().compare(s) == 0; }

   244 template <class RandomAccessIterator>

   245 inline bool operator != (const sub_match<RandomAccessIterator>& m,

   246                   typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)

   247 { return m.str().compare(s) != 0; }

   248 template <class RandomAccessIterator>

   249 inline bool operator > (const sub_match<RandomAccessIterator>& m,

   250                   typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)

   251 { return m.str().compare(s) > 0; }

   252 template <class RandomAccessIterator>

   253 inline bool operator < (const sub_match<RandomAccessIterator>& m,

   254                   typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)

   255 { return m.str().compare(s) < 0; }

   256 template <class RandomAccessIterator>

   257 inline bool operator >= (const sub_match<RandomAccessIterator>& m,

   258                   typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)

   259 { return m.str().compare(s) >= 0; }

   260 template <class RandomAccessIterator>

   261 inline bool operator <= (const sub_match<RandomAccessIterator>& m,

   262                   typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s)

   263 { return m.str().compare(s) <= 0; }

   264 // comparison to const charT* part 2:

   265 template <class RandomAccessIterator>

   266 inline bool operator == (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,

   267                   const sub_match<RandomAccessIterator>& m)

   268 { return m.str().compare(s) == 0; }

   269 template <class RandomAccessIterator>

   270 inline bool operator != (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,

   271                   const sub_match<RandomAccessIterator>& m)

   272 { return m.str().compare(s) != 0; }

   273 template <class RandomAccessIterator>

   274 inline bool operator < (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,

   275                   const sub_match<RandomAccessIterator>& m)

   276 { return m.str().compare(s) > 0; }

   277 template <class RandomAccessIterator>

   278 inline bool operator > (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,

   279                   const sub_match<RandomAccessIterator>& m)

   280 { return m.str().compare(s) < 0; }

   281 template <class RandomAccessIterator>

   282 inline bool operator <= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,

   283                   const sub_match<RandomAccessIterator>& m)

   284 { return m.str().compare(s) >= 0; }

   285 template <class RandomAccessIterator>

   286 inline bool operator >= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,

   287                   const sub_match<RandomAccessIterator>& m)

   288 { return m.str().compare(s) <= 0; }

   289 

   290 // comparison to const charT& part 1:

   291 template <class RandomAccessIterator>

   292 inline bool operator == (const sub_match<RandomAccessIterator>& m,

   293                   typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)

   294 { return m.str().compare(0, m.length(), &s, 1) == 0; }

   295 template <class RandomAccessIterator>

   296 inline bool operator != (const sub_match<RandomAccessIterator>& m,

   297                   typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)

   298 { return m.str().compare(0, m.length(), &s, 1) != 0; }

   299 template <class RandomAccessIterator>

   300 inline bool operator > (const sub_match<RandomAccessIterator>& m,

   301                   typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)

   302 { return m.str().compare(0, m.length(), &s, 1) > 0; }

   303 template <class RandomAccessIterator>

   304 inline bool operator < (const sub_match<RandomAccessIterator>& m,

   305                   typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)

   306 { return m.str().compare(0, m.length(), &s, 1) < 0; }

   307 template <class RandomAccessIterator>

   308 inline bool operator >= (const sub_match<RandomAccessIterator>& m,

   309                   typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)

   310 { return m.str().compare(0, m.length(), &s, 1) >= 0; }

   311 template <class RandomAccessIterator>

   312 inline bool operator <= (const sub_match<RandomAccessIterator>& m,

   313                   typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)

   314 { return m.str().compare(0, m.length(), &s, 1) <= 0; }

   315 // comparison to const charT* part 2:

   316 template <class RandomAccessIterator>

   317 inline bool operator == (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,

   318                   const sub_match<RandomAccessIterator>& m)

   319 { return m.str().compare(0, m.length(), &s, 1) == 0; }

   320 template <class RandomAccessIterator>

   321 inline bool operator != (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,

   322                   const sub_match<RandomAccessIterator>& m)

   323 { return m.str().compare(0, m.length(), &s, 1) != 0; }

   324 template <class RandomAccessIterator>

   325 inline bool operator < (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,

   326                   const sub_match<RandomAccessIterator>& m)

   327 { return m.str().compare(0, m.length(), &s, 1) > 0; }

   328 template <class RandomAccessIterator>

   329 inline bool operator > (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,

   330                   const sub_match<RandomAccessIterator>& m)

   331 { return m.str().compare(0, m.length(), &s, 1) < 0; }

   332 template <class RandomAccessIterator>

   333 inline bool operator <= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,

   334                   const sub_match<RandomAccessIterator>& m)

   335 { return m.str().compare(0, m.length(), &s, 1) >= 0; }

   336 template <class RandomAccessIterator>

   337 inline bool operator >= (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,

   338                   const sub_match<RandomAccessIterator>& m)

   339 { return m.str().compare(0, m.length(), &s, 1) <= 0; }

   340 

   341 // addition operators:

   342 template <class RandomAccessIterator, class traits, class Allocator>

   343 inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> 

   344 operator + (const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s,

   345                   const sub_match<RandomAccessIterator>& m)

   346 {

   347    std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> result;

   348    result.reserve(s.size() + m.length() + 1);

   349    return result.append(s).append(m.first, m.second);

   350 }

   351 template <class RandomAccessIterator, class traits, class Allocator>

   352 inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> 

   353 operator + (const sub_match<RandomAccessIterator>& m,

   354             const std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)

   355 {

   356    std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> result;

   357    result.reserve(s.size() + m.length() + 1);

   358    return result.append(m.first, m.second).append(s);

   359 }

   360 #if !(defined(__GNUC__) && defined(BOOST_NO_STD_LOCALE))

   361 template <class RandomAccessIterator>

   362 inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 

   363 operator + (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,

   364                   const sub_match<RandomAccessIterator>& m)

   365 {

   366    std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;

   367    result.reserve(std::char_traits<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);

   368    return result.append(s).append(m.first, m.second);

   369 }

   370 template <class RandomAccessIterator>

   371 inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 

   372 operator + (const sub_match<RandomAccessIterator>& m,

   373             typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const * s)

   374 {

   375    std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;

   376    result.reserve(std::char_traits<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type>::length(s) + m.length() + 1);

   377    return result.append(m.first, m.second).append(s);

   378 }

   379 #else

   380 // worwaround versions:

   381 template <class RandomAccessIterator>

   382 inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 

   383 operator + (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const* s,

   384                   const sub_match<RandomAccessIterator>& m)

   385 {

   386    return s + m.str();

   387 }

   388 template <class RandomAccessIterator>

   389 inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 

   390 operator + (const sub_match<RandomAccessIterator>& m,

   391             typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const * s)

   392 {

   393    return m.str() + s;

   394 }

   395 #endif

   396 template <class RandomAccessIterator>

   397 inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 

   398 operator + (typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s,

   399                   const sub_match<RandomAccessIterator>& m)

   400 {

   401    std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;

   402    result.reserve(m.length() + 2);

   403    return result.append(1, s).append(m.first, m.second);

   404 }

   405 template <class RandomAccessIterator>

   406 inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 

   407 operator + (const sub_match<RandomAccessIterator>& m,

   408             typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)

   409 {

   410    std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;

   411    result.reserve(m.length() + 2);

   412    return result.append(m.first, m.second).append(1, s);

   413 }

   414 template <class RandomAccessIterator>

   415 inline std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> 

   416 operator + (const sub_match<RandomAccessIterator>& m1,

   417             const sub_match<RandomAccessIterator>& m2)

   418 {

   419    std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;

   420    result.reserve(m1.length() + m2.length() + 1);

   421    return result.append(m1.first, m1.second).append(m2.first, m2.second);

   422 }

   423 #ifndef BOOST_NO_STD_LOCALE

   424 template <class charT, class traits, class RandomAccessIterator>

   425 std::basic_ostream<charT, traits>&

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

   427                 const sub_match<RandomAccessIterator>& s)

   428 {

   429    return (os << s.str());

   430 }

   431 #else

   432 template <class RandomAccessIterator>

   433 std::ostream& operator << (std::ostream& os,

   434                            const sub_match<RandomAccessIterator>& s)

   435 {

   436    return (os << s.str());

   437 }

   438 #endif

   439 

   440 #ifdef BOOST_OLD_REGEX_H

   441 namespace re_detail{

   442 template <class BidiIterator, class charT>

   443 int do_toi(BidiIterator i, BidiIterator j, char c, int radix)

   444 {

   445    std::string s(i, j);

   446    char* p;

   447    int result = std::strtol(s.c_str(), &p, radix);

   448    if(*p)raise_regex_exception("Bad sub-expression");

   449    return result;

   450 }

   451 

   452 //

   453 // helper:

   454 template <class I, class charT>

   455 int do_toi(I& i, I j, charT c)

   456 {

   457    int result = 0;

   458    while((i != j) && (isdigit(*i)))

   459    {

   460       result = result*10 + (*i - '0');

   461       ++i;

   462    }

   463    return result;

   464 }

   465 }

   466 

   467 

   468 template <class BidiIterator>

   469 sub_match<BidiIterator>::operator int()const

   470 {

   471    BidiIterator i = first;

   472    BidiIterator j = second;

   473    if(i == j)raise_regex_exception("Bad sub-expression");

   474    int neg = 1;

   475    if((i != j) && (*i == '-'))

   476    {

   477       neg = -1;

   478       ++i;

   479    }

   480    neg *= re_detail::do_toi(i, j, *i);

   481    if(i != j)raise_regex_exception("Bad sub-expression");

   482    return neg;

   483 }

   484 template <class BidiIterator>

   485 sub_match<BidiIterator>::operator unsigned int()const

   486 {

   487    BidiIterator i = first;

   488    BidiIterator j = second;

   489    if(i == j)

   490       raise_regex_exception("Bad sub-expression");

   491    return re_detail::do_toi(i, j, *first);

   492 }

   493 #endif

   494 

   495 } // namespace boost

   496 

   497 #ifdef BOOST_MSVC

   498 #pragma warning(push)

   499 #pragma warning(disable: 4103)

   500 #endif

   501 #ifdef BOOST_HAS_ABI_HEADERS

   502 #  include BOOST_ABI_SUFFIX

   503 #endif

   504 #ifdef BOOST_MSVC

   505 #pragma warning(pop)

   506 #endif

   507 

   508 #endif

   509