boostorg/regex
1
0
Fork 1
mirror of https://github.com/boostorg/regex.git synced 2025-07-15 05:16:37 +02:00
Code Issues Packages Projects Releases Wiki Activity

Change detail namespace.

Browse Source 
Big search and replace to change name of internal namepace so it's mangled with the Boost version number - the aim is to reduce the chances of mixing different header and library versions.
This commit is contained in:
jzmaddock
2015-04-04 19:10:37 +01:00
parent 297e87360c
commit 6ffcc5ede0
55 changed files with 609 additions and 598 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
include/boost/regex/config.hpp
View File

@ -25,6 +25,7 @@
#if defined(__BORLANDC__)
# include <boost/regex/config/borland.hpp>
#endif
#include <boost/version.hpp>
/*****************************************************************************
*
@ -69,6 +70,13 @@
#define UNICODE
#endif
/*
* Define a macro for the namespace that details are placed in, this includes the Boost
* version number to avoid mismatched header and library versions:
*/
#define BOOST_REGEX_DETAIL_NS BOOST_JOIN(re_detail_, BOOST_VERSION)
/*
* Fix for gcc prior to 3.4: std::ctype<wchar_t> doesn't allow
* masks to be combined, for example:
@ -334,7 +342,7 @@ if(0 == (x))\
#if defined(__cplusplus) && defined(BOOST_REGEX_HAS_MS_STACK_GUARD)
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
BOOST_REGEX_DECL void BOOST_REGEX_CALL reset_stack_guard_page();
@ -387,7 +395,7 @@ BOOST_REGEX_DECL void BOOST_REGEX_CALL reset_stack_guard_page();
****************************************************************************/
#if defined(__cplusplus) && defined(BOOST_REGEX_NON_RECURSIVE)
namespace boost{ namespace re_detail{
namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
BOOST_REGEX_DECL void* BOOST_REGEX_CALL get_mem_block();
BOOST_REGEX_DECL void BOOST_REGEX_CALL put_mem_block(void*);

166
include/boost/regex/icu.hpp
View File

@ -34,7 +34,7 @@
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
//
// Implementation details:
@ -108,18 +108,18 @@ public:
struct boost_extensions_tag{};
icu_regex_traits()
: m_pimpl(re_detail::get_icu_regex_traits_implementation(U_NAMESPACE_QUALIFIER Locale()))
: m_pimpl(BOOST_REGEX_DETAIL_NS::get_icu_regex_traits_implementation(U_NAMESPACE_QUALIFIER Locale()))
{
}
static size_type length(const char_type* p);
::boost::regex_constants::syntax_type syntax_type(char_type c)const
{
return ((c < 0x7f) && (c > 0)) ? re_detail::get_default_syntax_type(static_cast<char>(c)) : regex_constants::syntax_char;
return ((c < 0x7f) && (c > 0)) ? BOOST_REGEX_DETAIL_NS::get_default_syntax_type(static_cast<char>(c)) : regex_constants::syntax_char;
}
::boost::regex_constants::escape_syntax_type escape_syntax_type(char_type c) const
{
return ((c < 0x7f) && (c > 0)) ? re_detail::get_default_escape_syntax_type(static_cast<char>(c)) : regex_constants::syntax_char;
return ((c < 0x7f) && (c > 0)) ? BOOST_REGEX_DETAIL_NS::get_default_escape_syntax_type(static_cast<char>(c)) : regex_constants::syntax_char;
}
char_type translate(char_type c) const
{
@ -154,7 +154,7 @@ public:
bool isctype(char_type c, char_class_type f) const;
int toi(const char_type*& p1, const char_type* p2, int radix)const
{
return re_detail::global_toi(p1, p2, radix, *this);
return BOOST_REGEX_DETAIL_NS::global_toi(p1, p2, radix, *this);
}
int value(char_type c, int radix)const
{
@ -163,7 +163,7 @@ public:
locale_type imbue(locale_type l)
{
locale_type result(m_pimpl->getloc());
m_pimpl = re_detail::get_icu_regex_traits_implementation(l);
m_pimpl = BOOST_REGEX_DETAIL_NS::get_icu_regex_traits_implementation(l);
return result;
}
locale_type getloc()const
@ -172,7 +172,7 @@ public:
}
std::string error_string(::boost::regex_constants::error_type n) const
{
return re_detail::get_default_error_string(n);
return BOOST_REGEX_DETAIL_NS::get_default_error_string(n);
}
private:
icu_regex_traits(const icu_regex_traits&);
@ -208,7 +208,7 @@ private:
static char_class_type lookup_icu_mask(const ::UChar32* p1, const ::UChar32* p2);
boost::shared_ptr< ::boost::re_detail::icu_regex_traits_implementation> m_pimpl;
boost::shared_ptr< ::boost::BOOST_REGEX_DETAIL_NS::icu_regex_traits_implementation> m_pimpl;
};
} // namespace boost
@ -241,7 +241,7 @@ typedef match_results<const ::UChar*> u16match;
//
// Construction of 32-bit regex types from UTF-8 and UTF-16 primitives:
//
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
#if !defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(__IBMCPP__)
template <class InputIterator>
@ -341,18 +341,18 @@ inline u32regex make_u32regex(InputIterator i,
InputIterator j,
boost::regex_constants::syntax_option_type opt)
{
return re_detail::do_make_u32regex(i, j, opt, static_cast<boost::mpl::int_<sizeof(*i)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_make_u32regex(i, j, opt, static_cast<boost::mpl::int_<sizeof(*i)> const*>(0));
}
//
// construction from UTF-8 nul-terminated strings:
//
inline u32regex make_u32regex(const char* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
{
return re_detail::do_make_u32regex(p, p + std::strlen(p), opt, static_cast<boost::mpl::int_<1> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + std::strlen(p), opt, static_cast<boost::mpl::int_<1> const*>(0));
}
inline u32regex make_u32regex(const unsigned char* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
{
return re_detail::do_make_u32regex(p, p + std::strlen(reinterpret_cast<const char*>(p)), opt, static_cast<boost::mpl::int_<1> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + std::strlen(reinterpret_cast<const char*>(p)), opt, static_cast<boost::mpl::int_<1> const*>(0));
}
//
// construction from UTF-16 nul-terminated strings:
@ -360,13 +360,13 @@ inline u32regex make_u32regex(const unsigned char* p, boost::regex_constants::sy
#ifndef BOOST_NO_WREGEX
inline u32regex make_u32regex(const wchar_t* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
{
return re_detail::do_make_u32regex(p, p + std::wcslen(p), opt, static_cast<boost::mpl::int_<sizeof(wchar_t)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + std::wcslen(p), opt, static_cast<boost::mpl::int_<sizeof(wchar_t)> const*>(0));
}
#endif
#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2)
inline u32regex make_u32regex(const UChar* p, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
{
return re_detail::do_make_u32regex(p, p + u_strlen(p), opt, static_cast<boost::mpl::int_<2> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_make_u32regex(p, p + u_strlen(p), opt, static_cast<boost::mpl::int_<2> const*>(0));
}
#endif
//
@ -375,20 +375,20 @@ inline u32regex make_u32regex(const UChar* p, boost::regex_constants::syntax_opt
template<class C, class T, class A>
inline u32regex make_u32regex(const std::basic_string<C, T, A>& s, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
{
return re_detail::do_make_u32regex(s.begin(), s.end(), opt, static_cast<boost::mpl::int_<sizeof(C)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_make_u32regex(s.begin(), s.end(), opt, static_cast<boost::mpl::int_<sizeof(C)> const*>(0));
}
//
// Construction from ICU string type:
//
inline u32regex make_u32regex(const U_NAMESPACE_QUALIFIER UnicodeString& s, boost::regex_constants::syntax_option_type opt = boost::regex_constants::perl)
{
return re_detail::do_make_u32regex(s.getBuffer(), s.getBuffer() + s.length(), opt, static_cast<boost::mpl::int_<2> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_make_u32regex(s.getBuffer(), s.getBuffer() + s.length(), opt, static_cast<boost::mpl::int_<2> const*>(0));
}
//
// regex_match overloads that widen the character type as appropriate:
//
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
template<class MR1, class MR2>
void copy_results(MR1& out, MR2 const& in)
{
@ -446,7 +446,7 @@ bool do_regex_match(BidiIterator first, BidiIterator last,
if(result) copy_results(m, what);
return result;
}
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
template <class BidiIterator, class Allocator>
inline bool u32regex_match(BidiIterator first, BidiIterator last,
@ -454,14 +454,14 @@ inline bool u32regex_match(BidiIterator first, BidiIterator last,
const u32regex& e,
match_flag_type flags = match_default)
{
return re_detail::do_regex_match(first, last, m, e, flags, static_cast<mpl::int_<sizeof(*first)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_match(first, last, m, e, flags, static_cast<mpl::int_<sizeof(*first)> const*>(0));
}
inline bool u32regex_match(const UChar* p,
match_results<const UChar*>& m,
const u32regex& e,
match_flag_type flags = match_default)
{
return re_detail::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<mpl::int_<2> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<mpl::int_<2> const*>(0));
}
#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
inline bool u32regex_match(const wchar_t* p,
@ -469,7 +469,7 @@ inline bool u32regex_match(const wchar_t* p,
const u32regex& e,
match_flag_type flags = match_default)
{
return re_detail::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
}
#endif
inline bool u32regex_match(const char* p,
@ -477,21 +477,21 @@ inline bool u32regex_match(const char* p,
const u32regex& e,
match_flag_type flags = match_default)
{
return re_detail::do_regex_match(p, p+std::strlen(p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen(p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
}
inline bool u32regex_match(const unsigned char* p,
match_results<const unsigned char*>& m,
const u32regex& e,
match_flag_type flags = match_default)
{
return re_detail::do_regex_match(p, p+std::strlen((const char*)p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen((const char*)p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
}
inline bool u32regex_match(const std::string& s,
match_results<std::string::const_iterator>& m,
const u32regex& e,
match_flag_type flags = match_default)
{
return re_detail::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<1> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<1> const*>(0));
}
#ifndef BOOST_NO_STD_WSTRING
inline bool u32regex_match(const std::wstring& s,
@ -499,7 +499,7 @@ inline bool u32regex_match(const std::wstring& s,
const u32regex& e,
match_flag_type flags = match_default)
{
return re_detail::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
}
#endif
inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
@ -507,7 +507,7 @@ inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
const u32regex& e,
match_flag_type flags = match_default)
{
return re_detail::do_regex_match(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_match(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
}
//
// regex_match overloads that do not return what matched:
@ -518,14 +518,14 @@ inline bool u32regex_match(BidiIterator first, BidiIterator last,
match_flag_type flags = match_default)
{
match_results<BidiIterator> m;
return re_detail::do_regex_match(first, last, m, e, flags, static_cast<mpl::int_<sizeof(*first)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_match(first, last, m, e, flags, static_cast<mpl::int_<sizeof(*first)> const*>(0));
}
inline bool u32regex_match(const UChar* p,
const u32regex& e,
match_flag_type flags = match_default)
{
match_results<const UChar*> m;
return re_detail::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<mpl::int_<2> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+u_strlen(p), m, e, flags, static_cast<mpl::int_<2> const*>(0));
}
#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
inline bool u32regex_match(const wchar_t* p,
@ -533,7 +533,7 @@ inline bool u32regex_match(const wchar_t* p,
match_flag_type flags = match_default)
{
match_results<const wchar_t*> m;
return re_detail::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::wcslen(p), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
}
#endif
inline bool u32regex_match(const char* p,
@ -541,21 +541,21 @@ inline bool u32regex_match(const char* p,
match_flag_type flags = match_default)
{
match_results<const char*> m;
return re_detail::do_regex_match(p, p+std::strlen(p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen(p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
}
inline bool u32regex_match(const unsigned char* p,
const u32regex& e,
match_flag_type flags = match_default)
{
match_results<const unsigned char*> m;
return re_detail::do_regex_match(p, p+std::strlen((const char*)p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_match(p, p+std::strlen((const char*)p), m, e, flags, static_cast<mpl::int_<1> const*>(0));
}
inline bool u32regex_match(const std::string& s,
const u32regex& e,
match_flag_type flags = match_default)
{
match_results<std::string::const_iterator> m;
return re_detail::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<1> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<1> const*>(0));
}
#ifndef BOOST_NO_STD_WSTRING
inline bool u32regex_match(const std::wstring& s,
@ -563,7 +563,7 @@ inline bool u32regex_match(const std::wstring& s,
match_flag_type flags = match_default)
{
match_results<std::wstring::const_iterator> m;
return re_detail::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_match(s.begin(), s.end(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
}
#endif
inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
@ -571,13 +571,13 @@ inline bool u32regex_match(const U_NAMESPACE_QUALIFIER UnicodeString& s,
match_flag_type flags = match_default)
{
match_results<const UChar*> m;
return re_detail::do_regex_match(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_match(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
}
//
// regex_search overloads that widen the character type as appropriate:
//
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
template <class BidiIterator, class Allocator>
inline bool do_regex_search(BidiIterator first, BidiIterator last,
match_results<BidiIterator, Allocator>& m,
@ -630,7 +630,7 @@ inline bool u32regex_search(BidiIterator first, BidiIterator last,
const u32regex& e,
match_flag_type flags = match_default)
{
return re_detail::do_regex_search(first, last, m, e, flags, first, static_cast<mpl::int_<sizeof(*first)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, first, static_cast<mpl::int_<sizeof(*first)> const*>(0));
}
template <class BidiIterator, class Allocator>
inline bool u32regex_search(BidiIterator first, BidiIterator last,
@ -639,14 +639,14 @@ inline bool u32regex_search(BidiIterator first, BidiIterator last,
match_flag_type flags,
BidiIterator base)
{
return re_detail::do_regex_search(first, last, m, e, flags, base, static_cast<mpl::int_<sizeof(*first)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, base, static_cast<mpl::int_<sizeof(*first)> const*>(0));
}
inline bool u32regex_search(const UChar* p,
match_results<const UChar*>& m,
const u32regex& e,
match_flag_type flags = match_default)
{
return re_detail::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<mpl::int_<2> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<mpl::int_<2> const*>(0));
}
#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
inline bool u32regex_search(const wchar_t* p,
@ -654,7 +654,7 @@ inline bool u32regex_search(const wchar_t* p,
const u32regex& e,
match_flag_type flags = match_default)
{
return re_detail::do_regex_search(p, p+std::wcslen(p), m, e, flags, p, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::wcslen(p), m, e, flags, p, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
}
#endif
inline bool u32regex_search(const char* p,
@ -662,21 +662,21 @@ inline bool u32regex_search(const char* p,
const u32regex& e,
match_flag_type flags = match_default)
{
return re_detail::do_regex_search(p, p+std::strlen(p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen(p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
}
inline bool u32regex_search(const unsigned char* p,
match_results<const unsigned char*>& m,
const u32regex& e,
match_flag_type flags = match_default)
{
return re_detail::do_regex_search(p, p+std::strlen((const char*)p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen((const char*)p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
}
inline bool u32regex_search(const std::string& s,
match_results<std::string::const_iterator>& m,
const u32regex& e,
match_flag_type flags = match_default)
{
return re_detail::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<1> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<1> const*>(0));
}
#ifndef BOOST_NO_STD_WSTRING
inline bool u32regex_search(const std::wstring& s,
@ -684,7 +684,7 @@ inline bool u32regex_search(const std::wstring& s,
const u32regex& e,
match_flag_type flags = match_default)
{
return re_detail::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
}
#endif
inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
@ -692,7 +692,7 @@ inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
const u32regex& e,
match_flag_type flags = match_default)
{
return re_detail::do_regex_search(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, s.getBuffer(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_search(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, s.getBuffer(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
}
template <class BidiIterator>
inline bool u32regex_search(BidiIterator first, BidiIterator last,
@ -700,14 +700,14 @@ inline bool u32regex_search(BidiIterator first, BidiIterator last,
match_flag_type flags = match_default)
{
match_results<BidiIterator> m;
return re_detail::do_regex_search(first, last, m, e, flags, first, static_cast<mpl::int_<sizeof(*first)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_search(first, last, m, e, flags, first, static_cast<mpl::int_<sizeof(*first)> const*>(0));
}
inline bool u32regex_search(const UChar* p,
const u32regex& e,
match_flag_type flags = match_default)
{
match_results<const UChar*> m;
return re_detail::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<mpl::int_<2> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+u_strlen(p), m, e, flags, p, static_cast<mpl::int_<2> const*>(0));
}
#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)
inline bool u32regex_search(const wchar_t* p,
@ -715,7 +715,7 @@ inline bool u32regex_search(const wchar_t* p,
match_flag_type flags = match_default)
{
match_results<const wchar_t*> m;
return re_detail::do_regex_search(p, p+std::wcslen(p), m, e, flags, p, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::wcslen(p), m, e, flags, p, static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
}
#endif
inline bool u32regex_search(const char* p,
@ -723,21 +723,21 @@ inline bool u32regex_search(const char* p,
match_flag_type flags = match_default)
{
match_results<const char*> m;
return re_detail::do_regex_search(p, p+std::strlen(p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen(p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
}
inline bool u32regex_search(const unsigned char* p,
const u32regex& e,
match_flag_type flags = match_default)
{
match_results<const unsigned char*> m;
return re_detail::do_regex_search(p, p+std::strlen((const char*)p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_search(p, p+std::strlen((const char*)p), m, e, flags, p, static_cast<mpl::int_<1> const*>(0));
}
inline bool u32regex_search(const std::string& s,
const u32regex& e,
match_flag_type flags = match_default)
{
match_results<std::string::const_iterator> m;
return re_detail::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<1> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<1> const*>(0));
}
#ifndef BOOST_NO_STD_WSTRING
inline bool u32regex_search(const std::wstring& s,
@ -745,7 +745,7 @@ inline bool u32regex_search(const std::wstring& s,
match_flag_type flags = match_default)
{
match_results<std::wstring::const_iterator> m;
return re_detail::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_search(s.begin(), s.end(), m, e, flags, s.begin(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
}
#endif
inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
@ -753,13 +753,13 @@ inline bool u32regex_search(const U_NAMESPACE_QUALIFIER UnicodeString& s,
match_flag_type flags = match_default)
{
match_results<const UChar*> m;
return re_detail::do_regex_search(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, s.getBuffer(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
return BOOST_REGEX_DETAIL_NS::do_regex_search(s.getBuffer(), s.getBuffer() + s.length(), m, e, flags, s.getBuffer(), static_cast<mpl::int_<sizeof(wchar_t)> const*>(0));
}
//
// overloads for regex_replace with utf-8 and utf-16 data types:
//
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
template <class I>
inline std::pair< boost::u8_to_u32_iterator<I>, boost::u8_to_u32_iterator<I> >
make_utf32_seq(I i, I j, mpl::int_<1> const*)
@ -838,7 +838,7 @@ OutputIterator do_regex_replace(OutputIterator out,
if(i == j)
{
if(!(flags & regex_constants::format_no_copy))
out = re_detail::copy(in.first, in.second, out);
out = BOOST_REGEX_DETAIL_NS::copy(in.first, in.second, out);
}
else
{
@ -846,18 +846,18 @@ OutputIterator do_regex_replace(OutputIterator out,
while(i != j)
{
if(!(flags & regex_constants::format_no_copy))
out = re_detail::copy(i->prefix().first, i->prefix().second, out);
out = BOOST_REGEX_DETAIL_NS::copy(i->prefix().first, i->prefix().second, out);
if(f.size())
out = ::boost::re_detail::regex_format_imp(out, *i, &*f.begin(), &*f.begin() + f.size(), flags, e.get_traits());
out = ::boost::BOOST_REGEX_DETAIL_NS::regex_format_imp(out, *i, &*f.begin(), &*f.begin() + f.size(), flags, e.get_traits());
else
out = ::boost::re_detail::regex_format_imp(out, *i, static_cast<UChar32 const*>(0), static_cast<UChar32 const*>(0), flags, e.get_traits());
out = ::boost::BOOST_REGEX_DETAIL_NS::regex_format_imp(out, *i, static_cast<UChar32 const*>(0), static_cast<UChar32 const*>(0), flags, e.get_traits());
last_m = (*i)[0].second;
if(flags & regex_constants::format_first_only)
break;
++i;
}
if(!(flags & regex_constants::format_no_copy))
out = re_detail::copy(last_m, in.second, out);
out = BOOST_REGEX_DETAIL_NS::copy(last_m, in.second, out);
}
return out;
}
@ -876,7 +876,7 @@ inline BaseIterator extract_output_base(const utf16_output_iterator<BaseIterator
{
return b.base();
}
} // re_detail
} // BOOST_REGEX_DETAIL_NS
template <class OutputIterator, class BidirectionalIterator, class charT>
inline OutputIterator u32regex_replace(OutputIterator out,
@ -886,13 +886,13 @@ inline OutputIterator u32regex_replace(OutputIterator out,
const charT* fmt,
match_flag_type flags = match_default)
{
return re_detail::extract_output_base
return BOOST_REGEX_DETAIL_NS::extract_output_base
(
re_detail::do_regex_replace(
re_detail::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
re_detail::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
BOOST_REGEX_DETAIL_NS::do_regex_replace(
BOOST_REGEX_DETAIL_NS::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
BOOST_REGEX_DETAIL_NS::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
e,
re_detail::make_utf32_seq(fmt, static_cast<mpl::int_<sizeof(*fmt)> const*>(0)),
BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt, static_cast<mpl::int_<sizeof(*fmt)> const*>(0)),
flags)
);
}
@ -905,13 +905,13 @@ inline OutputIterator u32regex_replace(OutputIterator out,
const std::basic_string<charT>& fmt,
match_flag_type flags = match_default)
{
return re_detail::extract_output_base
return BOOST_REGEX_DETAIL_NS::extract_output_base
(
re_detail::do_regex_replace(
re_detail::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
re_detail::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
BOOST_REGEX_DETAIL_NS::do_regex_replace(
BOOST_REGEX_DETAIL_NS::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
BOOST_REGEX_DETAIL_NS::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
e,
re_detail::make_utf32_seq(fmt.begin(), fmt.end(), static_cast<mpl::int_<sizeof(charT)> const*>(0)),
BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt.begin(), fmt.end(), static_cast<mpl::int_<sizeof(charT)> const*>(0)),
flags)
);
}
@ -924,13 +924,13 @@ inline OutputIterator u32regex_replace(OutputIterator out,
const U_NAMESPACE_QUALIFIER UnicodeString& fmt,
match_flag_type flags = match_default)
{
return re_detail::extract_output_base
return BOOST_REGEX_DETAIL_NS::extract_output_base
(
re_detail::do_regex_replace(
re_detail::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
re_detail::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
BOOST_REGEX_DETAIL_NS::do_regex_replace(
BOOST_REGEX_DETAIL_NS::make_utf32_out(out, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
BOOST_REGEX_DETAIL_NS::make_utf32_seq(first, last, static_cast<mpl::int_<sizeof(*first)> const*>(0)),
e,
re_detail::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast<mpl::int_<2> const*>(0)),
BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast<mpl::int_<2> const*>(0)),
flags)
);
}
@ -942,7 +942,7 @@ std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
match_flag_type flags = match_default)
{
std::basic_string<charT> result;
re_detail::string_out_iterator<std::basic_string<charT> > i(result);
BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<charT> > i(result);
u32regex_replace(i, s.begin(), s.end(), e, fmt, flags);
return result;
}
@ -954,12 +954,12 @@ std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,
match_flag_type flags = match_default)
{
std::basic_string<charT> result;
re_detail::string_out_iterator<std::basic_string<charT> > i(result);
BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<charT> > i(result);
u32regex_replace(i, s.begin(), s.end(), e, fmt.c_str(), flags);
return result;
}
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
class unicode_string_out_iterator
{
@ -989,7 +989,7 @@ inline U_NAMESPACE_QUALIFIER UnicodeString u32regex_replace(const U_NAMESPACE_QU
match_flag_type flags = match_default)
{
U_NAMESPACE_QUALIFIER UnicodeString result;
re_detail::unicode_string_out_iterator i(result);
BOOST_REGEX_DETAIL_NS::unicode_string_out_iterator i(result);
u32regex_replace(i, s.getBuffer(), s.getBuffer()+s.length(), e, fmt, flags);
return result;
}
@ -1000,12 +1000,12 @@ inline U_NAMESPACE_QUALIFIER UnicodeString u32regex_replace(const U_NAMESPACE_QU
match_flag_type flags = match_default)
{
U_NAMESPACE_QUALIFIER UnicodeString result;
re_detail::unicode_string_out_iterator i(result);
re_detail::do_regex_replace(
re_detail::make_utf32_out(i, static_cast<mpl::int_<2> const*>(0)),
re_detail::make_utf32_seq(s.getBuffer(), s.getBuffer()+s.length(), static_cast<mpl::int_<2> const*>(0)),
BOOST_REGEX_DETAIL_NS::unicode_string_out_iterator i(result);
BOOST_REGEX_DETAIL_NS::do_regex_replace(
BOOST_REGEX_DETAIL_NS::make_utf32_out(i, static_cast<mpl::int_<2> const*>(0)),
BOOST_REGEX_DETAIL_NS::make_utf32_seq(s.getBuffer(), s.getBuffer()+s.length(), static_cast<mpl::int_<2> const*>(0)),
e,
re_detail::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast<mpl::int_<2> const*>(0)),
BOOST_REGEX_DETAIL_NS::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast<mpl::int_<2> const*>(0)),
flags);
return result;
}

4
include/boost/regex/mfc.hpp
View File

@ -144,7 +144,7 @@ OutputIterator regex_replace(OutputIterator out,
return ::boost::regex_replace(out, first, last, e, fmt.GetString(), flags);
}
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
template <class B, bool b>
class mfc_string_out_iterator
@ -176,7 +176,7 @@ ATL::CSimpleStringT<B, b> regex_replace(const ATL::CSimpleStringT<B, b>& s,
match_flag_type flags = match_default)
{
ATL::CSimpleStringT<B, b> result(s.GetManager());
re_detail::mfc_string_out_iterator<B, b> i(result);
BOOST_REGEX_DETAIL_NS::mfc_string_out_iterator<B, b> i(result);
regex_replace(i, s.GetString(), s.GetString() + s.GetLength(), e, fmt.GetString(), flags);
return result;
}

4
include/boost/regex/pattern_except.hpp
View File

@ -63,7 +63,7 @@ private:
typedef regex_error bad_pattern;
typedef regex_error bad_expression;
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
BOOST_REGEX_DECL void BOOST_REGEX_CALL raise_runtime_error(const std::runtime_error& ex);
@ -72,7 +72,7 @@ void raise_error(const traits& t, regex_constants::error_type code)
{
(void)t; // warning suppression
std::runtime_error e(t.error_string(code));
::boost::re_detail::raise_runtime_error(e);
::boost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(e);
}
}

26
include/boost/regex/v4/basic_regex.hpp
View File

@ -42,7 +42,7 @@ namespace boost{
#endif
#endif
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
//
// forward declaration, we will need this one later:
@ -176,11 +176,11 @@ struct regex_data : public named_subexpressions
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
BOOST_REGEX_DETAIL_NS::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
BOOST_REGEX_DETAIL_NS::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<
@ -266,7 +266,7 @@ public:
{
return this->m_mark_count - 1;
}
const re_detail::re_syntax_base* get_first_state()const
const BOOST_REGEX_DETAIL_NS::re_syntax_base* get_first_state()const
{
return this->m_first_state;
}
@ -293,7 +293,7 @@ public:
}
};
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
//
// class basic_regex:
// represents the compiled
@ -597,7 +597,7 @@ public:
//
// private access methods:
//
const re_detail::re_syntax_base* get_first_state()const
const BOOST_REGEX_DETAIL_NS::re_syntax_base* get_first_state()const
{
BOOST_ASSERT(0 != m_pimpl.get());
return m_pimpl->get_first_state();
@ -622,18 +622,18 @@ public:
BOOST_ASSERT(0 != m_pimpl.get());
return m_pimpl->can_be_null();
}
const re_detail::regex_data<charT, traits>& get_data()const
const BOOST_REGEX_DETAIL_NS::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
boost::shared_ptr<BOOST_REGEX_DETAIL_NS::named_subexpressions > get_named_subs()const
{
return m_pimpl;
}
private:
shared_ptr<re_detail::basic_regex_implementation<charT, traits> > m_pimpl;
shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> > m_pimpl;
};
//
@ -647,14 +647,14 @@ basic_regex<charT, traits>& basic_regex<charT, traits>::do_assign(const charT* p
const charT* p2,
flag_type f)
{
shared_ptr<re_detail::basic_regex_implementation<charT, traits> > temp;
shared_ptr<BOOST_REGEX_DETAIL_NS::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>());
temp = shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> >(new BOOST_REGEX_DETAIL_NS::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 = shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> >(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits>(m_pimpl->m_ptraits));
}
temp->assign(p1, p2, f);
temp.swap(m_pimpl);
@ -664,7 +664,7 @@ basic_regex<charT, traits>& basic_regex<charT, traits>::do_assign(const charT* p
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>());
shared_ptr<BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits> > temp(new BOOST_REGEX_DETAIL_NS::basic_regex_implementation<charT, traits>());
locale_type result = temp->imbue(l);
temp.swap(m_pimpl);
return result;

36
include/boost/regex/v4/basic_regex_creator.hpp
View File

@ -38,7 +38,7 @@
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
template <class charT>
struct digraph : public std::pair<charT, charT>
@ -371,9 +371,9 @@ re_syntax_base* basic_regex_creator<charT, traits>::append_set(
//
// 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->csingles = static_cast<unsigned int>(::boost::BOOST_REGEX_DETAIL_NS::distance(char_set.singles_begin(), char_set.singles_end()));
result->cranges = static_cast<unsigned int>(::boost::BOOST_REGEX_DETAIL_NS::distance(char_set.ranges_begin(), char_set.ranges_end())) / 2;
result->cequivalents = static_cast<unsigned int>(::boost::BOOST_REGEX_DETAIL_NS::distance(char_set.equivalents_begin(), char_set.equivalents_end()));
result->cclasses = char_set.classes();
result->cnclasses = char_set.negated_classes();
if(flags() & regbase::icase)
@ -463,10 +463,10 @@ re_syntax_base* basic_regex_creator<charT, traits>::append_set(
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);
BOOST_REGEX_DETAIL_NS::copy(s1.begin(), s1.end(), p);
p[s1.size()] = charT(0);
p += s1.size() + 1;
re_detail::copy(s2.begin(), s2.end(), p);
BOOST_REGEX_DETAIL_NS::copy(s2.begin(), s2.end(), p);
p[s2.size()] = charT(0);
}
//
@ -487,7 +487,7 @@ re_syntax_base* basic_regex_creator<charT, traits>::append_set(
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);
BOOST_REGEX_DETAIL_NS::copy(s.begin(), s.end(), p);
p[s.size()] = charT(0);
++first;
}
@ -664,7 +664,7 @@ void basic_regex_creator<charT, traits>::finalize(const charT* p1, const charT*
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);
BOOST_REGEX_DETAIL_NS::copy(p1, p2, ps);
ps[p2 - p1] = 0;
// fill in our other data...
// successful parsing implies a zero status:
@ -1456,15 +1456,15 @@ syntax_element_type basic_regex_creator<charT, traits>::get_repeat_type(re_synta
{
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<m_type>*>(state->next.p)->singleton)
return re_detail::syntax_element_long_set_rep;
case BOOST_REGEX_DETAIL_NS::syntax_element_wild:
return BOOST_REGEX_DETAIL_NS::syntax_element_dot_rep;
case BOOST_REGEX_DETAIL_NS::syntax_element_literal:
return BOOST_REGEX_DETAIL_NS::syntax_element_char_rep;
case BOOST_REGEX_DETAIL_NS::syntax_element_set:
return BOOST_REGEX_DETAIL_NS::syntax_element_short_set_rep;
case BOOST_REGEX_DETAIL_NS::syntax_element_long_set:
if(static_cast<BOOST_REGEX_DETAIL_NS::re_set_long<m_type>*>(state->next.p)->singleton)
return BOOST_REGEX_DETAIL_NS::syntax_element_long_set_rep;
break;
default:
break;
@ -1529,7 +1529,7 @@ void basic_regex_creator<charT, traits>::probe_leading_repeat(re_syntax_base* st
}
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
} // namespace boost

20
include/boost/regex/v4/basic_regex_parser.hpp
View File

@ -31,7 +31,7 @@
#endif
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
#ifdef BOOST_MSVC
#pragma warning(push)
@ -165,7 +165,7 @@ void basic_regex_parser<charT, traits>::parse(const charT* p1, const charT* p2,
// have had an unexpected ')' :
if(!result)
{
fail(regex_constants::error_paren, ::boost::re_detail::distance(m_base, m_position), "Found a closing ) with no corresponding openening parenthesis.");
fail(regex_constants::error_paren, ::boost::BOOST_REGEX_DETAIL_NS::distance(m_base, m_position), "Found a closing ) with no corresponding openening parenthesis.");
return;
}
// if an error has been set then give up now:
@ -489,7 +489,7 @@ bool basic_regex_parser<charT, traits>::parse_open_paren()
//
if(m_position == m_end)
{
this->fail(regex_constants::error_paren, ::boost::re_detail::distance(m_base, m_end));
this->fail(regex_constants::error_paren, ::boost::BOOST_REGEX_DETAIL_NS::distance(m_base, m_end));
return false;
}
BOOST_ASSERT(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark);
@ -924,9 +924,9 @@ bool basic_regex_parser<charT, traits>::parse_match_any()
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
? BOOST_REGEX_DETAIL_NS::force_not_newline
: this->flags() & regbase::mod_s ?
re_detail::force_newline : re_detail::dont_care);
BOOST_REGEX_DETAIL_NS::force_newline : BOOST_REGEX_DETAIL_NS::dont_care);
return true;
}
@ -963,7 +963,7 @@ bool basic_regex_parser<charT, traits>::parse_repeat(std::size_t low, std::size_
}
if(0 == this->m_last_state)
{
fail(regex_constants::error_badrepeat, ::boost::re_detail::distance(m_base, m_position), "Nothing to repeat.");
fail(regex_constants::error_badrepeat, ::boost::BOOST_REGEX_DETAIL_NS::distance(m_base, m_position), "Nothing to repeat.");
return false;
}
if(this->m_last_state->type == syntax_element_endmark)
@ -1235,7 +1235,7 @@ bool basic_regex_parser<charT, traits>::parse_alt()
//
// we need to append a trailing jump:
//
re_syntax_base* pj = this->append_state(re_detail::syntax_element_jump, sizeof(re_jump));
re_syntax_base* pj = this->append_state(BOOST_REGEX_DETAIL_NS::syntax_element_jump, sizeof(re_jump));
std::ptrdiff_t jump_offset = this->getoffset(pj);
//
// now insert the alternative:
@ -1784,7 +1784,7 @@ charT basic_regex_parser<charT, traits>::unescape_character()
{
// 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));
std::ptrdiff_t len = (std::min)(::boost::BOOST_REGEX_DETAIL_NS::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)
@ -2521,7 +2521,7 @@ option_group_jump:
// Rewind to start of (? sequence:
--m_position;
while(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_open_mark) --m_position;
this->fail(regex_constants::error_paren, ::boost::re_detail::distance(m_base, m_end));
this->fail(regex_constants::error_paren, ::boost::BOOST_REGEX_DETAIL_NS::distance(m_base, m_end));
return false;
}
BOOST_ASSERT(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark);
@ -2862,7 +2862,7 @@ bool basic_regex_parser<charT, traits>::unwind_alts(std::ptrdiff_t last_paren_st
#pragma warning(pop)
#endif
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
} // namespace boost
#ifdef BOOST_MSVC

138
include/boost/regex/v4/cpp_regex_traits.hpp
View File

@ -69,7 +69,7 @@ namespace boost{
template <class charT>
class cpp_regex_traits;
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
//
// class parser_buf:
@ -290,7 +290,7 @@ void cpp_regex_traits_char_layer<charT>::init()
{
std::string m("Unable to open message catalog: ");
std::runtime_error err(m + cat_name);
boost::re_detail::raise_runtime_error(err);
boost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(err);
}
}
//
@ -718,7 +718,7 @@ void cpp_regex_traits_implementation<charT>::init()
{
std::string m("Unable to open message catalog: ");
std::runtime_error err(m + cat_name);
boost::re_detail::raise_runtime_error(err);
boost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(err);
}
}
//
@ -774,22 +774,22 @@ void cpp_regex_traits_implementation<charT>::init()
#else
static const char_class_type masks[16] =
{
::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_horizontal_space,
::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_vertical_space,
::boost::re_detail::char_class_xdigit,
::boost::re_detail::char_class_blank,
::boost::re_detail::char_class_word,
::boost::re_detail::char_class_unicode,
::boost::BOOST_REGEX_DETAIL_NS::char_class_alnum,
::boost::BOOST_REGEX_DETAIL_NS::char_class_alpha,
::boost::BOOST_REGEX_DETAIL_NS::char_class_cntrl,
::boost::BOOST_REGEX_DETAIL_NS::char_class_digit,
::boost::BOOST_REGEX_DETAIL_NS::char_class_graph,
::boost::BOOST_REGEX_DETAIL_NS::char_class_horizontal_space,
::boost::BOOST_REGEX_DETAIL_NS::char_class_lower,
::boost::BOOST_REGEX_DETAIL_NS::char_class_print,
::boost::BOOST_REGEX_DETAIL_NS::char_class_punct,
::boost::BOOST_REGEX_DETAIL_NS::char_class_space,
::boost::BOOST_REGEX_DETAIL_NS::char_class_upper,
::boost::BOOST_REGEX_DETAIL_NS::char_class_vertical_space,
::boost::BOOST_REGEX_DETAIL_NS::char_class_xdigit,
::boost::BOOST_REGEX_DETAIL_NS::char_class_blank,
::boost::BOOST_REGEX_DETAIL_NS::char_class_word,
::boost::BOOST_REGEX_DETAIL_NS::char_class_unicode,
};
#endif
static const string_type null_string;
@ -804,7 +804,7 @@ void cpp_regex_traits_implementation<charT>::init()
//
// get the collation format used by m_pcollate:
//
m_collate_type = re_detail::find_sort_syntax(this, &m_collate_delim);
m_collate_type = BOOST_REGEX_DETAIL_NS::find_sort_syntax(this, &m_collate_delim);
}
template <class charT>
@ -841,27 +841,27 @@ typename cpp_regex_traits_implementation<charT>::char_class_type
static const char_class_type masks[22] =
{
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_horizontal_space,
::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_vertical_space,
::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,
::boost::BOOST_REGEX_DETAIL_NS::char_class_alnum,
::boost::BOOST_REGEX_DETAIL_NS::char_class_alpha,
::boost::BOOST_REGEX_DETAIL_NS::char_class_blank,
::boost::BOOST_REGEX_DETAIL_NS::char_class_cntrl,
::boost::BOOST_REGEX_DETAIL_NS::char_class_digit,
::boost::BOOST_REGEX_DETAIL_NS::char_class_digit,
::boost::BOOST_REGEX_DETAIL_NS::char_class_graph,
::boost::BOOST_REGEX_DETAIL_NS::char_class_horizontal_space,
::boost::BOOST_REGEX_DETAIL_NS::char_class_lower,
::boost::BOOST_REGEX_DETAIL_NS::char_class_lower,
::boost::BOOST_REGEX_DETAIL_NS::char_class_print,
::boost::BOOST_REGEX_DETAIL_NS::char_class_punct,
::boost::BOOST_REGEX_DETAIL_NS::char_class_space,
::boost::BOOST_REGEX_DETAIL_NS::char_class_space,
::boost::BOOST_REGEX_DETAIL_NS::char_class_upper,
::boost::BOOST_REGEX_DETAIL_NS::char_class_unicode,
::boost::BOOST_REGEX_DETAIL_NS::char_class_upper,
::boost::BOOST_REGEX_DETAIL_NS::char_class_vertical_space,
::boost::BOOST_REGEX_DETAIL_NS::char_class_alnum | ::boost::BOOST_REGEX_DETAIL_NS::char_class_word,
::boost::BOOST_REGEX_DETAIL_NS::char_class_alnum | ::boost::BOOST_REGEX_DETAIL_NS::char_class_word,
::boost::BOOST_REGEX_DETAIL_NS::char_class_xdigit,
};
#endif
if(m_custom_class_names.size())
@ -871,7 +871,7 @@ typename cpp_regex_traits_implementation<charT>::char_class_type
if(pos != m_custom_class_names.end())
return pos->second;
}
std::size_t state_id = 1 + re_detail::get_default_class_id(p1, p2);
std::size_t state_id = 1 + BOOST_REGEX_DETAIL_NS::get_default_class_id(p1, p2);
BOOST_ASSERT(state_id < sizeof(masks) / sizeof(masks[0]));
return masks[state_id];
}
@ -881,20 +881,20 @@ 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) && (this->m_pctype->is(std::ctype<charT>::space, c)))
|| ((mask & ::boost::re_detail::char_class_print) && (this->m_pctype->is(std::ctype<charT>::print, c)))
|| ((mask & ::boost::re_detail::char_class_cntrl) && (this->m_pctype->is(std::ctype<charT>::cntrl, c)))
|| ((mask & ::boost::re_detail::char_class_upper) && (this->m_pctype->is(std::ctype<charT>::upper, c)))
|| ((mask & ::boost::re_detail::char_class_lower) && (this->m_pctype->is(std::ctype<charT>::lower, c)))
|| ((mask & ::boost::re_detail::char_class_alpha) && (this->m_pctype->is(std::ctype<charT>::alpha, c)))
|| ((mask & ::boost::re_detail::char_class_digit) && (this->m_pctype->is(std::ctype<charT>::digit, c)))
|| ((mask & ::boost::re_detail::char_class_punct) && (this->m_pctype->is(std::ctype<charT>::punct, c)))
|| ((mask & ::boost::re_detail::char_class_xdigit) && (this->m_pctype->is(std::ctype<charT>::xdigit, c)))
|| ((mask & ::boost::re_detail::char_class_blank) && (this->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))
|| ((mask & ::boost::re_detail::char_class_vertical_space) && (is_separator(c) || (c == '\v')))
|| ((mask & ::boost::re_detail::char_class_horizontal_space) && this->m_pctype->is(std::ctype<charT>::space, c) && !(is_separator(c) || (c == '\v')));
((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_space) && (this->m_pctype->is(std::ctype<charT>::space, c)))
|| ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_print) && (this->m_pctype->is(std::ctype<charT>::print, c)))
|| ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_cntrl) && (this->m_pctype->is(std::ctype<charT>::cntrl, c)))
|| ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_upper) && (this->m_pctype->is(std::ctype<charT>::upper, c)))
|| ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_lower) && (this->m_pctype->is(std::ctype<charT>::lower, c)))
|| ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_alpha) && (this->m_pctype->is(std::ctype<charT>::alpha, c)))
|| ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_digit) && (this->m_pctype->is(std::ctype<charT>::digit, c)))
|| ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_punct) && (this->m_pctype->is(std::ctype<charT>::punct, c)))
|| ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_xdigit) && (this->m_pctype->is(std::ctype<charT>::xdigit, c)))
|| ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_blank) && (this->m_pctype->is(std::ctype<charT>::space, c)) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c))
|| ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_word) && (c == '_'))
|| ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_unicode) && ::boost::BOOST_REGEX_DETAIL_NS::is_extended(c))
|| ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_vertical_space) && (is_separator(c) || (c == '\v')))
|| ((mask & ::boost::BOOST_REGEX_DETAIL_NS::char_class_horizontal_space) && this->m_pctype->is(std::ctype<charT>::space, c) && !(is_separator(c) || (c == '\v')));
}
#endif
@ -906,7 +906,7 @@ inline boost::shared_ptr<const cpp_regex_traits_implementation<charT> > create_c
return ::boost::object_cache<cpp_regex_traits_base<charT>, cpp_regex_traits_implementation<charT> >::get(key, 5);
}
} // re_detail
} // BOOST_REGEX_DETAIL_NS
template <class charT>
class cpp_regex_traits
@ -923,7 +923,7 @@ public:
struct boost_extensions_tag{};
cpp_regex_traits()
: m_pimpl(re_detail::create_cpp_regex_traits<charT>(std::locale()))
: m_pimpl(BOOST_REGEX_DETAIL_NS::create_cpp_regex_traits<charT>(std::locale()))
{ }
static size_type length(const char_type* p)
{
@ -996,19 +996,19 @@ public:
&& (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))
else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_unicode) && BOOST_REGEX_DETAIL_NS::is_extended(c))
return true;
else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_word) && (c == '_'))
else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_word) && (c == '_'))
return true;
else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_blank)
else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_blank)
&& m_pimpl->m_pctype->is(std::ctype<charT>::space, c)
&& !re_detail::is_separator(c))
&& !BOOST_REGEX_DETAIL_NS::is_separator(c))
return true;
else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_vertical)
&& (::boost::re_detail::is_separator(c) || (c == '\v')))
else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_vertical)
&& (::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) || (c == '\v')))
return true;
else if((f & re_detail::cpp_regex_traits_implementation<charT>::mask_horizontal)
&& this->isctype(c, std::ctype<charT>::space) && !this->isctype(c, re_detail::cpp_regex_traits_implementation<charT>::mask_vertical))
else if((f & BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_horizontal)
&& this->isctype(c, std::ctype<charT>::space) && !this->isctype(c, BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT>::mask_vertical))
return true;
#ifdef __CYGWIN__
//
@ -1036,7 +1036,7 @@ public:
locale_type imbue(locale_type l)
{
std::locale result(getloc());
m_pimpl = re_detail::create_cpp_regex_traits<charT>(l);
m_pimpl = BOOST_REGEX_DETAIL_NS::create_cpp_regex_traits<charT>(l);
return result;
}
locale_type getloc()const
@ -1056,7 +1056,7 @@ public:
static std::string get_catalog_name();
private:
boost::shared_ptr<const re_detail::cpp_regex_traits_implementation<charT> > m_pimpl;
boost::shared_ptr<const BOOST_REGEX_DETAIL_NS::cpp_regex_traits_implementation<charT> > m_pimpl;
//
// catalog name handler:
//
@ -1071,7 +1071,7 @@ private:
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.
BOOST_REGEX_DETAIL_NS::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:

14
include/boost/regex/v4/cregex.hpp
View File

@ -221,7 +221,7 @@ namespace boost{
class RegEx;
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
class RegExData;
struct pred1;
@ -229,7 +229,7 @@ struct pred2;
struct pred3;
struct pred4;
} /* namespace re_detail */
} /* namespace BOOST_REGEX_DETAIL_NS */
#if (defined(BOOST_MSVC) || defined(__BORLANDC__)) && !defined(BOOST_DISABLE_WIN32)
typedef bool (__cdecl *GrepCallback)(const RegEx& expression);
@ -244,7 +244,7 @@ typedef bool (*FindFilesCallback)(const char* file);
class BOOST_REGEX_DECL RegEx
{
private:
re_detail::RegExData* pdata;
BOOST_REGEX_DETAIL_NS::RegExData* pdata;
public:
RegEx();
RegEx(const RegEx& o);
@ -296,10 +296,10 @@ public:
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;
friend struct BOOST_REGEX_DETAIL_NS::pred1;
friend struct BOOST_REGEX_DETAIL_NS::pred2;
friend struct BOOST_REGEX_DETAIL_NS::pred3;
friend struct BOOST_REGEX_DETAIL_NS::pred4;
};
#ifdef BOOST_MSVC

18
include/boost/regex/v4/fileiter.hpp
View File

@ -49,7 +49,7 @@
#include <cstddef>
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
#ifndef BOOST_NO_ANSI_APIS
typedef WIN32_FIND_DATAA _fi_find_data;
@ -58,7 +58,7 @@ typedef WIN32_FIND_DATAW _fi_find_data;
#endif
typedef HANDLE _fi_find_handle;
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
} // namespace boost
@ -84,7 +84,7 @@ using std::list;
#endif
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
@ -110,7 +110,7 @@ bool _fi_FindClose(_fi_find_handle hFindFile);
# include BOOST_ABI_SUFFIX
#endif
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
} // namespace boost
#ifdef FindFirstFile
@ -130,7 +130,7 @@ bool _fi_FindClose(_fi_find_handle hFindFile);
#endif
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
@ -427,10 +427,10 @@ inline bool operator < (const directory_iterator&, const directory_iterator&)
#endif
} // namespace re_detail
using boost::re_detail::directory_iterator;
using boost::re_detail::file_iterator;
using boost::re_detail::mapfile;
} // namespace BOOST_REGEX_DETAIL_NS
using boost::BOOST_REGEX_DETAIL_NS::directory_iterator;
using boost::BOOST_REGEX_DETAIL_NS::file_iterator;
using boost::BOOST_REGEX_DETAIL_NS::mapfile;
} // namespace boost
#endif // BOOST_REGEX_NO_FILEITER

12
include/boost/regex/v4/instances.hpp
View File

@ -54,7 +54,7 @@ namespace boost{
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 >;
template class BOOST_REGEX_DECL ::boost::BOOST_REGEX_DETAIL_NS::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
@ -94,7 +94,7 @@ template class BOOST_REGEX_TEMPLATE_DECL basic_regex< BOOST_REGEX_CHAR_T BOOST_R
template class BOOST_REGEX_TEMPLATE_DECL match_results< const BOOST_REGEX_CHAR_T* >;
#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 >;
template class BOOST_REGEX_TEMPLATE_DECL ::boost::BOOST_REGEX_DETAIL_NS::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))\
@ -102,7 +102,7 @@ template class BOOST_REGEX_TEMPLATE_DECL ::boost::re_detail::perl_matcher<BOOST_
&& !defined(BOOST_REGEX_ICU_INSTANCES)
template class BOOST_REGEX_TEMPLATE_DECL match_results< std::basic_string<BOOST_REGEX_CHAR_T>::const_iterator >;
#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 > >;
template class BOOST_REGEX_TEMPLATE_DECL ::boost::BOOST_REGEX_DETAIL_NS::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
@ -128,7 +128,7 @@ template class BOOST_REGEX_TEMPLATE_DECL ::boost::re_detail::perl_matcher< std::
# endif
#if !defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_REGEX_ICU_INSTANCES)
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
template BOOST_REGEX_DECL
std::locale cpp_regex_traits_base<BOOST_REGEX_CHAR_T>::imbue(const std::locale& l);
@ -177,7 +177,7 @@ 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{
namespace BOOST_REGEX_DETAIL_NS{
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();
@ -193,7 +193,7 @@ 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{
namespace BOOST_REGEX_DETAIL_NS{
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();

4
include/boost/regex/v4/iterator_traits.hpp
View File

@ -31,7 +31,7 @@
#endif
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
#if defined(BOOST_NO_STD_ITERATOR_TRAITS)
@ -117,7 +117,7 @@ struct regex_iterator_traits : public std::iterator_traits<T> {};
#endif
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
} // namespace boost
#ifdef BOOST_MSVC

34
include/boost/regex/v4/match_results.hpp
View File

@ -39,7 +39,7 @@ namespace boost{
# endif
#endif
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
class named_subexpressions;
@ -64,14 +64,14 @@ public:
typedef const_reference reference;
typedef typename vector_type::const_iterator const_iterator;
typedef const_iterator iterator;
typedef typename re_detail::regex_iterator_traits<
typedef typename BOOST_REGEX_DETAIL_NS::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<
typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<
BidiIterator>::value_type char_type;
typedef std::basic_string<char_type> string_type;
typedef re_detail::named_subexpressions named_sub_type;
typedef BOOST_REGEX_DETAIL_NS::named_subexpressions named_sub_type;
// construct/copy/destroy:
explicit match_results(const Allocator& a = Allocator())
@ -158,7 +158,7 @@ public:
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 ::boost::BOOST_REGEX_DETAIL_NS::distance((BidiIterator)(m_base), (BidiIterator)(s.first));
}
}
return ~static_cast<difference_type>(0);
@ -237,7 +237,7 @@ public:
//
if(m_is_singular)
raise_logic_error();
re_detail::named_subexpressions::range_type r = m_named_subs->equal_range(i, j);
BOOST_REGEX_DETAIL_NS::named_subexpressions::range_type r = m_named_subs->equal_range(i, j);
while((r.first != r.second) && ((*this)[r.first->index].matched == false))
++r.first;
return r.first != r.second ? (*this)[r.first->index] : m_null;
@ -262,7 +262,7 @@ public:
//
if(m_is_singular)
raise_logic_error();
re_detail::named_subexpressions::range_type s, r;
BOOST_REGEX_DETAIL_NS::named_subexpressions::range_type s, r;
s = r = m_named_subs->equal_range(i, j);
while((r.first != r.second) && ((*this)[r.first->index].matched == false))
++r.first;
@ -345,7 +345,7 @@ public:
{
if(m_is_singular)
raise_logic_error();
typedef typename re_detail::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, OutputIterator>::type F;
typedef typename BOOST_REGEX_DETAIL_NS::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, OutputIterator>::type F;
F func(fmt);
return func(*this, out, flags);
}
@ -355,9 +355,9 @@ public:
if(m_is_singular)
raise_logic_error();
std::basic_string<char_type> result;
re_detail::string_out_iterator<std::basic_string<char_type> > i(result);
BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<char_type> > i(result);
typedef typename re_detail::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, re_detail::string_out_iterator<std::basic_string<char_type> > >::type F;
typedef typename BOOST_REGEX_DETAIL_NS::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<char_type> > >::type F;
F func(fmt);
func(*this, i, flags);
@ -373,7 +373,7 @@ public:
if(m_is_singular)
raise_logic_error();
typedef ::boost::regex_traits_wrapper<typename RegexT::traits_type> traits_type;
typedef typename re_detail::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, OutputIterator, traits_type>::type F;
typedef typename BOOST_REGEX_DETAIL_NS::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, OutputIterator, traits_type>::type F;
F func(fmt);
return func(*this, out, flags, re.get_traits());
}
@ -386,9 +386,9 @@ public:
raise_logic_error();
typedef ::boost::regex_traits_wrapper<typename RegexT::traits_type> traits_type;
std::basic_string<char_type> result;
re_detail::string_out_iterator<std::basic_string<char_type> > i(result);
BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<char_type> > i(result);
typedef typename re_detail::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, re_detail::string_out_iterator<std::basic_string<char_type> >, traits_type >::type F;
typedef typename BOOST_REGEX_DETAIL_NS::compute_functor_type<Functor, match_results<BidiIterator, Allocator>, BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<char_type> >, traits_type >::type F;
F func(fmt);
func(*this, i, flags, re.get_traits());
@ -639,15 +639,15 @@ void BOOST_REGEX_CALL match_results<BidiIterator, Allocator>::maybe_assign(const
// p1 better than p2, and no need to calculate distances:
return;
}
base1 = ::boost::re_detail::distance(l_base, p1->first);
base2 = ::boost::re_detail::distance(l_base, p2->first);
base1 = ::boost::BOOST_REGEX_DETAIL_NS::distance(l_base, p1->first);
base2 = ::boost::BOOST_REGEX_DETAIL_NS::distance(l_base, p2->first);
BOOST_ASSERT(base1 >= 0);
BOOST_ASSERT(base2 >= 0);
if(base1 < base2) return;
if(base2 < base1) break;
len1 = ::boost::re_detail::distance((BidiIterator)p1->first, (BidiIterator)p1->second);
len2 = ::boost::re_detail::distance((BidiIterator)p2->first, (BidiIterator)p2->second);
len1 = ::boost::BOOST_REGEX_DETAIL_NS::distance((BidiIterator)p1->first, (BidiIterator)p1->second);
len2 = ::boost::BOOST_REGEX_DETAIL_NS::distance((BidiIterator)p2->first, (BidiIterator)p2->second);
BOOST_ASSERT(len1 >= 0);
BOOST_ASSERT(len2 >= 0);
if((len1 != len2) || ((p1->matched == false) && (p2->matched == true)))

2
include/boost/regex/v4/mem_block_cache.hpp
View File

@ -28,7 +28,7 @@
#endif
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
struct mem_block_node
{

4
include/boost/regex/v4/perl_matcher.hpp
View File

@ -31,7 +31,7 @@
#endif
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
//
// error checking API:
@ -561,7 +561,7 @@ private:
#pragma warning(pop)
#endif
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
#ifdef BOOST_MSVC
#pragma warning(push)

12
include/boost/regex/v4/perl_matcher_common.hpp
View File

@ -40,7 +40,7 @@
#endif
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
template <class BidiIterator, class Allocator, class traits>
void perl_matcher<BidiIterator, Allocator, traits>::construct_init(const basic_regex<char_type, traits>& e, match_flag_type f)
@ -84,7 +84,7 @@ void perl_matcher<BidiIterator, Allocator, traits>::construct_init(const basic_r
// find the value to use for matching word boundaries:
m_word_mask = re.get_data().m_word_mask;
// find bitmask to use for matching '.':
match_any_mask = static_cast<unsigned char>((f & match_not_dot_newline) ? re_detail::test_not_newline : re_detail::test_newline);
match_any_mask = static_cast<unsigned char>((f & match_not_dot_newline) ? BOOST_REGEX_DETAIL_NS::test_not_newline : BOOST_REGEX_DETAIL_NS::test_newline);
}
template <class BidiIterator, class Allocator, class traits>
@ -101,7 +101,7 @@ void perl_matcher<BidiIterator, Allocator, traits>::estimate_max_state_count(std
// Calculate NS^2 first:
//
static const std::ptrdiff_t k = 100000;
std::ptrdiff_t dist = boost::re_detail::distance(base, last);
std::ptrdiff_t dist = boost::BOOST_REGEX_DETAIL_NS::distance(base, last);
if(dist == 0)
dist = 1;
std::ptrdiff_t states = re.size();
@ -165,7 +165,7 @@ template <class BidiIterator, class Allocator, class traits>
inline bool perl_matcher<BidiIterator, Allocator, traits>::protected_call(
protected_proc_type proc)
{
::boost::re_detail::concrete_protected_call
::boost::BOOST_REGEX_DETAIL_NS::concrete_protected_call
<perl_matcher<BidiIterator, Allocator, traits> >
obj(this, proc);
return obj.execute();
@ -703,7 +703,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_backstep()
#endif
if( ::boost::is_random_access_iterator<BidiIterator>::value)
{
std::ptrdiff_t maxlen = ::boost::re_detail::distance(backstop, position);
std::ptrdiff_t maxlen = ::boost::BOOST_REGEX_DETAIL_NS::distance(backstop, position);
if(maxlen < static_cast<const re_brace*>(pstate)->index)
return false;
std::advance(position, -static_cast<const re_brace*>(pstate)->index);
@ -966,7 +966,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::find_restart_lit()
return false;
}
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
} // namespace boost

42
include/boost/regex/v4/perl_matcher_non_recursive.hpp
View File

@ -38,7 +38,7 @@
#endif
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
template <class T>
inline void inplace_destroy(T* p)
@ -652,7 +652,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_fast()
const re_repeat* rep = static_cast<const re_repeat*>(pstate);
bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);
unsigned count = static_cast<unsigned>((std::min)(static_cast<unsigned>(::boost::re_detail::distance(position, last)), static_cast<unsigned>(greedy ? rep->max : rep->min)));
unsigned count = static_cast<unsigned>((std::min)(static_cast<unsigned>(::boost::BOOST_REGEX_DETAIL_NS::distance(position, last)), static_cast<unsigned>(greedy ? rep->max : rep->min)));
if(rep->min > count)
{
position = last;
@ -705,7 +705,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_char_repeat()
BidiIterator end = position;
// Move end forward by "desired", preferably without using distance or advance if we can
// as these can be slow for some iterator types.
std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::re_detail::distance(position, last);
std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::BOOST_REGEX_DETAIL_NS::distance(position, last);
if(desired >= len)
end = last;
else
@ -715,7 +715,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_char_repeat()
{
++position;
}
count = (unsigned)::boost::re_detail::distance(origin, position);
count = (unsigned)::boost::BOOST_REGEX_DETAIL_NS::distance(origin, position);
}
else
{
@ -779,7 +779,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_set_repeat()
BidiIterator end = position;
// Move end forward by "desired", preferably without using distance or advance if we can
// as these can be slow for some iterator types.
std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::re_detail::distance(position, last);
std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::BOOST_REGEX_DETAIL_NS::distance(position, last);
if(desired >= len)
end = last;
else
@ -789,7 +789,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_set_repeat()
{
++position;
}
count = (unsigned)::boost::re_detail::distance(origin, position);
count = (unsigned)::boost::BOOST_REGEX_DETAIL_NS::distance(origin, position);
}
else
{
@ -854,7 +854,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_long_set_repeat()
BidiIterator end = position;
// Move end forward by "desired", preferably without using distance or advance if we can
// as these can be slow for some iterator types.
std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::re_detail::distance(position, last);
std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::BOOST_REGEX_DETAIL_NS::distance(position, last);
if(desired >= len)
end = last;
else
@ -864,7 +864,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_long_set_repeat()
{
++position;
}
count = (unsigned)::boost::re_detail::distance(origin, position);
count = (unsigned)::boost::BOOST_REGEX_DETAIL_NS::distance(origin, position);
}
else
{
@ -1077,14 +1077,14 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_paren(bool have_match
#endif
// unwind stack:
m_backup_state = pmp+1;
boost::re_detail::inplace_destroy(pmp);
boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp);
return true; // keep looking
}
template <class BidiIterator, class Allocator, class traits>
bool perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion_stopper(bool)
{
boost::re_detail::inplace_destroy(m_backup_state++);
boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(m_backup_state++);
pstate = 0; // nothing left to search
return false; // end of stack nothing more to search
}
@ -1097,7 +1097,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_assertion(bool r)
position = pmp->position;
bool result = (r == pmp->positive);
m_recursive_result = pmp->positive ? r : !r;
boost::re_detail::inplace_destroy(pmp++);
boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
m_backup_state = pmp;
return !result; // return false if the assertion was matched to stop search.
}
@ -1111,7 +1111,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_alt(bool r)
pstate = pmp->pstate;
position = pmp->position;
}
boost::re_detail::inplace_destroy(pmp++);
boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
m_backup_state = pmp;
return r;
}
@ -1120,7 +1120,7 @@ template <class BidiIterator, class Allocator, class traits>
bool perl_matcher<BidiIterator, Allocator, traits>::unwind_repeater_counter(bool)
{
saved_repeater<BidiIterator>* pmp = static_cast<saved_repeater<BidiIterator>*>(m_backup_state);
boost::re_detail::inplace_destroy(pmp++);
boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
m_backup_state = pmp;
return true; // keep looking
}
@ -1132,7 +1132,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_extra_block(bool)
void* condemmed = m_stack_base;
m_stack_base = pmp->base;
m_backup_state = pmp->end;
boost::re_detail::inplace_destroy(pmp);
boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp);
put_mem_block(condemmed);
return true; // keep looking
}
@ -1141,7 +1141,7 @@ template <class BidiIterator, class Allocator, class traits>
inline void perl_matcher<BidiIterator, Allocator, traits>::destroy_single_repeat()
{
saved_single_repeat<BidiIterator>* p = static_cast<saved_single_repeat<BidiIterator>*>(m_backup_state);
boost::re_detail::inplace_destroy(p++);
boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(p++);
m_backup_state = p;
}
@ -1533,7 +1533,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_non_greedy_repeat(boo
pstate = pmp->pstate;
++(*next_count);
}
boost::re_detail::inplace_destroy(pmp++);
boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
m_backup_state = pmp;
return r;
}
@ -1549,7 +1549,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion(bool r)
recursion_stack.back().preturn_address = pmp->preturn_address;
recursion_stack.back().results = pmp->results;
}
boost::re_detail::inplace_destroy(pmp++);
boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
m_backup_state = pmp;
return true;
}
@ -1562,7 +1562,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_recursion_pop(bool r)
{
recursion_stack.pop_back();
}
boost::re_detail::inplace_destroy(pmp++);
boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
m_backup_state = pmp;
return true;
}
@ -1590,7 +1590,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_parenthesis_pop(bool
{
--parenthesis_stack_position;
}
boost::re_detail::inplace_destroy(pmp++);
boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
m_backup_state = pmp;
return true;
}
@ -1618,7 +1618,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::unwind_parenthesis_push(bool
{
parenthesis_stack[parenthesis_stack_position++] = pmp->position;
}
boost::re_detail::inplace_destroy(pmp++);
boost::BOOST_REGEX_DETAIL_NS::inplace_destroy(pmp++);
m_backup_state = pmp;
return true;
}
@ -1638,7 +1638,7 @@ inline void perl_matcher<BidiIterator, Allocator, traits>::push_parenthesis_push
m_backup_state = pmp;
}
*/
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
} // namespace boost
#ifdef BOOST_MSVC

16
include/boost/regex/v4/perl_matcher_recursive.hpp
View File

@ -37,7 +37,7 @@
#endif
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
template <class BidiIterator>
class backup_subex
@ -472,7 +472,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_dot_repeat_fast()
#pragma warning(disable:4267)
#endif
bool greedy = (rep->greedy) && (!(m_match_flags & regex_constants::match_any) || m_independent);
std::size_t count = (std::min)(static_cast<std::size_t>(::boost::re_detail::distance(position, last)), static_cast<std::size_t>(greedy ? rep->max : rep->min));
std::size_t count = (std::min)(static_cast<std::size_t>(::boost::BOOST_REGEX_DETAIL_NS::distance(position, last)), static_cast<std::size_t>(greedy ? rep->max : rep->min));
if(rep->min > count)
{
position = last;
@ -539,7 +539,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_char_repeat()
desired =
(std::min)(
(std::size_t)(greedy ? rep->max : rep->min),
(std::size_t)::boost::re_detail::distance(position, last));
(std::size_t)::boost::BOOST_REGEX_DETAIL_NS::distance(position, last));
count = desired;
++desired;
if(icase)
@ -643,7 +643,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_set_repeat()
BidiIterator end = position;
// Move end forward by "desired", preferably without using distance or advance if we can
// as these can be slow for some iterator types.
std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::re_detail::distance(position, last);
std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::BOOST_REGEX_DETAIL_NS::distance(position, last);
if(desired >= len)
end = last;
else
@ -653,7 +653,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_set_repeat()
{
++position;
}
count = (unsigned)::boost::re_detail::distance(origin, position);
count = (unsigned)::boost::BOOST_REGEX_DETAIL_NS::distance(origin, position);
}
else
{
@ -739,7 +739,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_long_set_repeat()
BidiIterator end = position;
// Move end forward by "desired", preferably without using distance or advance if we can
// as these can be slow for some iterator types.
std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::re_detail::distance(position, last);
std::size_t len = (desired == (std::numeric_limits<std::size_t>::max)()) ? 0u : ::boost::BOOST_REGEX_DETAIL_NS::distance(position, last);
if(desired >= len)
end = last;
else
@ -749,7 +749,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_long_set_repeat()
{
++position;
}
count = (unsigned)::boost::re_detail::distance(origin, position);
count = (unsigned)::boost::BOOST_REGEX_DETAIL_NS::distance(origin, position);
}
else
{
@ -982,7 +982,7 @@ bool perl_matcher<BidiIterator, Allocator, traits>::match_match()
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
} // namespace boost
#ifdef BOOST_MSVC
#pragma warning(pop)

4
include/boost/regex/v4/primary_transform.hpp
View File

@ -32,7 +32,7 @@
#endif
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
enum{
@ -122,7 +122,7 @@ unsigned find_sort_syntax(const traits* pt, charT* delim)
}
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
} // namespace boost
#ifdef BOOST_MSVC

2
include/boost/regex/v4/protected_call.hpp
View File

@ -32,7 +32,7 @@
#endif
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
class BOOST_REGEX_DECL abstract_protected_call
{

28
include/boost/regex/v4/regex_format.hpp
View File

@ -55,7 +55,7 @@ namespace boost{
template <class BidiIterator, class Allocator = BOOST_DEDUCED_TYPENAME std::vector<sub_match<BidiIterator> >::allocator_type >
class match_results;
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
//
// struct trivial_format_traits:
@ -73,11 +73,11 @@ struct trivial_format_traits
}
static charT tolower(charT c)
{
return ::boost::re_detail::global_lower(c);
return ::boost::BOOST_REGEX_DETAIL_NS::global_lower(c);
}
static charT toupper(charT c)
{
return ::boost::re_detail::global_upper(c);
return ::boost::BOOST_REGEX_DETAIL_NS::global_upper(c);
}
static int value(const charT c, int radix)
{
@ -359,7 +359,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
default:
// see if we have a number:
{
std::ptrdiff_t len = ::boost::re_detail::distance(m_position, m_end);
std::ptrdiff_t len = ::boost::BOOST_REGEX_DETAIL_NS::distance(m_position, m_end);
//len = (std::min)(static_cast<std::ptrdiff_t>(2), len);
int v = this->toi(m_position, m_position + len, 10);
if((v < 0) || (have_brace && ((m_position == m_end) || (*m_position != '}'))))
@ -570,7 +570,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
}
else
{
std::ptrdiff_t len = ::boost::re_detail::distance(m_position, m_end);
std::ptrdiff_t len = ::boost::BOOST_REGEX_DETAIL_NS::distance(m_position, m_end);
len = (std::min)(static_cast<std::ptrdiff_t>(2), len);
int val = this->toi(m_position, m_position + len, 16);
if(val < 0)
@ -634,7 +634,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
break;
}
// see if we have a \n sed style backreference:
std::ptrdiff_t len = ::boost::re_detail::distance(m_position, m_end);
std::ptrdiff_t len = ::boost::BOOST_REGEX_DETAIL_NS::distance(m_position, m_end);
len = (std::min)(static_cast<std::ptrdiff_t>(1), len);
int v = this->toi(m_position, m_position+len, 10);
if((v > 0) || ((v == 0) && (m_flags & ::boost::regex_constants::format_sed)))
@ -646,7 +646,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
{
// octal ecape sequence:
--m_position;
len = ::boost::re_detail::distance(m_position, m_end);
len = ::boost::BOOST_REGEX_DETAIL_NS::distance(m_position, m_end);
len = (std::min)(static_cast<std::ptrdiff_t>(4), len);
v = this->toi(m_position, m_position + len, 8);
BOOST_ASSERT(v >= 0);
@ -693,7 +693,7 @@ void basic_regex_formatter<OutputIterator, Results, traits, ForwardIter>::format
}
else
{
std::ptrdiff_t len = ::boost::re_detail::distance(m_position, m_end);
std::ptrdiff_t len = ::boost::BOOST_REGEX_DETAIL_NS::distance(m_position, m_end);
len = (std::min)(static_cast<std::ptrdiff_t>(2), len);
v = this->toi(m_position, m_position + len, 10);
}
@ -835,10 +835,10 @@ OutputIterator regex_format_imp(OutputIterator out,
{
if(flags & regex_constants::format_literal)
{
return re_detail::copy(p1, p2, out);
return BOOST_REGEX_DETAIL_NS::copy(p1, p2, out);
}
re_detail::basic_regex_formatter<
BOOST_REGEX_DETAIL_NS::basic_regex_formatter<
OutputIterator,
match_results<Iterator, Alloc>,
traits, ForwardIter> f(out, m, t);
@ -1028,7 +1028,7 @@ struct format_functor1
template <class S, class OutputIter>
OutputIter do_format_string(const S& s, OutputIter i)
{
return re_detail::copy(s.begin(), s.end(), i);
return BOOST_REGEX_DETAIL_NS::copy(s.begin(), s.end(), i);
}
template <class S, class OutputIter>
inline OutputIter do_format_string(const S* s, OutputIter i)
@ -1085,7 +1085,7 @@ struct format_functor_container
OutputIter operator()(const Match& m, OutputIter i, boost::regex_constants::match_flag_type f, const Traits& t = Traits())
{
//typedef typename Match::char_type char_type;
return re_detail::regex_format_imp(i, m, func.begin(), func.end(), f, t);
return BOOST_REGEX_DETAIL_NS::regex_format_imp(i, m, func.begin(), func.end(), f, t);
}
private:
const Container& func;
@ -1093,7 +1093,7 @@ private:
format_functor_container& operator=(const format_functor_container&);
};
template <class Func, class Match, class OutputIterator, class Traits = re_detail::trivial_format_traits<typename Match::char_type> >
template <class Func, class Match, class OutputIterator, class Traits = BOOST_REGEX_DETAIL_NS::trivial_format_traits<typename Match::char_type> >
struct compute_functor_type
{
typedef typename format_traits<Func, Match, OutputIterator>::type tag;
@ -1114,7 +1114,7 @@ struct compute_functor_type
>::type type;
};
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
template <class OutputIterator, class Iterator, class Allocator, class Functor>
inline OutputIterator regex_format(OutputIterator out,

2
include/boost/regex/v4/regex_grep.hpp
View File

@ -50,7 +50,7 @@ inline unsigned int regex_grep(Predicate foo,
typedef typename match_results<BidiIterator>::allocator_type match_allocator_type;
match_results<BidiIterator> m;
re_detail::perl_matcher<BidiIterator, match_allocator_type, traits> matcher(first, last, m, e, flags, first);
BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, match_allocator_type, traits> matcher(first, last, m, e, flags, first);
unsigned int count = 0;
while(matcher.find())
{

6
include/boost/regex/v4/regex_iterator.hpp
View File

@ -82,14 +82,14 @@ private:
};
template <class BidirectionalIterator,
class charT = BOOST_DEDUCED_TYPENAME re_detail::regex_iterator_traits<BidirectionalIterator>::value_type,
class charT = BOOST_DEDUCED_TYPENAME BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::value_type,
class traits = regex_traits<charT> >
class regex_iterator
#ifndef BOOST_NO_STD_ITERATOR
: public std::iterator<
std::forward_iterator_tag,
match_results<BidirectionalIterator>,
typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type,
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type,
const match_results<BidirectionalIterator>*,
const match_results<BidirectionalIterator>& >
#endif
@ -100,7 +100,7 @@ private:
public:
typedef basic_regex<charT, traits> regex_type;
typedef match_results<BidirectionalIterator> value_type;
typedef typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type
typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type
difference_type;
typedef const value_type* pointer;
typedef const value_type& reference;

2
include/boost/regex/v4/regex_match.hpp
View File

@ -46,7 +46,7 @@ bool regex_match(BidiIterator first, BidiIterator last,
const basic_regex<charT, traits>& e,
match_flag_type flags = match_default)
{
re_detail::perl_matcher<BidiIterator, Allocator, traits> matcher(first, last, m, e, flags, first);
BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, Allocator, traits> matcher(first, last, m, e, flags, first);
return matcher.match();
}
template <class iterator, class charT, class traits>

4
include/boost/regex/v4/regex_raw_buffer.hpp
View File

@ -29,7 +29,7 @@
#include <cstddef>
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
#ifdef BOOST_MSVC
#pragma warning(push)
@ -198,7 +198,7 @@ inline raw_storage::raw_storage(size_type n)
#pragma warning(pop)
#endif
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
} // namespace boost
#endif

8
include/boost/regex/v4/regex_replace.hpp
View File

@ -48,7 +48,7 @@ OutputIterator regex_replace(OutputIterator out,
if(i == j)
{
if(!(flags & regex_constants::format_no_copy))
out = re_detail::copy(first, last, out);
out = BOOST_REGEX_DETAIL_NS::copy(first, last, out);
}
else
{
@ -56,7 +56,7 @@ OutputIterator regex_replace(OutputIterator out,
while(i != j)
{
if(!(flags & regex_constants::format_no_copy))
out = re_detail::copy(i->prefix().first, i->prefix().second, out);
out = BOOST_REGEX_DETAIL_NS::copy(i->prefix().first, i->prefix().second, out);
out = i->format(out, fmt, flags, e);
last_m = (*i)[0].second;
if(flags & regex_constants::format_first_only)
@ -64,7 +64,7 @@ OutputIterator regex_replace(OutputIterator out,
++i;
}
if(!(flags & regex_constants::format_no_copy))
out = re_detail::copy(last_m, last, out);
out = BOOST_REGEX_DETAIL_NS::copy(last_m, last, out);
}
return out;
}
@ -76,7 +76,7 @@ std::basic_string<charT> regex_replace(const std::basic_string<charT>& s,
match_flag_type flags = match_default)
{
std::basic_string<charT> result;
re_detail::string_out_iterator<std::basic_string<charT> > i(result);
BOOST_REGEX_DETAIL_NS::string_out_iterator<std::basic_string<charT> > i(result);
regex_replace(i, s.begin(), s.end(), e, fmt, flags);
return result;
}

4
include/boost/regex/v4/regex_search.hpp
View File

@ -52,7 +52,7 @@ bool regex_search(BidiIterator first, BidiIterator last,
if(e.flags() & regex_constants::failbit)
return false;
re_detail::perl_matcher<BidiIterator, Allocator, traits> matcher(first, last, m, e, flags, base);
BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, Allocator, traits> matcher(first, last, m, e, flags, base);
return matcher.find();
}
@ -141,7 +141,7 @@ bool regex_search(BidiIterator first, BidiIterator last,
match_results<BidiIterator> m;
typedef typename match_results<BidiIterator>::allocator_type match_alloc_type;
re_detail::perl_matcher<BidiIterator, match_alloc_type, traits> matcher(first, last, m, e, flags | regex_constants::match_any, first);
BOOST_REGEX_DETAIL_NS::perl_matcher<BidiIterator, match_alloc_type, traits> matcher(first, last, m, e, flags | regex_constants::match_any, first);
return matcher.find();
}

8
include/boost/regex/v4/regex_split.hpp
View File

@ -39,7 +39,7 @@ namespace boost{
# pragma warning(disable: 4800)
#endif
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
template <class charT>
const basic_regex<charT>& get_default_expression(charT)
@ -97,7 +97,7 @@ bool split_pred<OutputIterator, charT, Traits1, Alloc1>::operator()
return true;
}
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2>
std::size_t regex_split(OutputIterator out,
@ -110,7 +110,7 @@ std::size_t regex_split(OutputIterator out,
//typedef typename match_results<ci_t>::allocator_type match_allocator;
ci_t last = s.begin();
std::size_t init_size = max_split;
re_detail::split_pred<OutputIterator, charT, Traits1, Alloc1> pred(&last, &out, &max_split);
BOOST_REGEX_DETAIL_NS::split_pred<OutputIterator, charT, Traits1, Alloc1> pred(&last, &out, &max_split);
ci_t i, j;
i = s.begin();
j = s.end();
@ -147,7 +147,7 @@ template <class OutputIterator, class charT, class Traits1, class Alloc1>
inline std::size_t regex_split(OutputIterator out,
std::basic_string<charT, Traits1, Alloc1>& s)
{
return regex_split(out, s, re_detail::get_default_expression(charT(0)), match_default, UINT_MAX);
return regex_split(out, s, BOOST_REGEX_DETAIL_NS::get_default_expression(charT(0)), match_default, UINT_MAX);
}
#ifdef BOOST_MSVC

6
include/boost/regex/v4/regex_token_iterator.hpp
View File

@ -164,14 +164,14 @@ private:
};
template <class BidirectionalIterator,
class charT = BOOST_DEDUCED_TYPENAME re_detail::regex_iterator_traits<BidirectionalIterator>::value_type,
class charT = BOOST_DEDUCED_TYPENAME BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::value_type,
class traits = regex_traits<charT> >
class regex_token_iterator
#ifndef BOOST_NO_STD_ITERATOR
: public std::iterator<
std::forward_iterator_tag,
sub_match<BidirectionalIterator>,
typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type,
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type,
const sub_match<BidirectionalIterator>*,
const sub_match<BidirectionalIterator>& >
#endif
@ -182,7 +182,7 @@ private:
public:
typedef basic_regex<charT, traits> regex_type;
typedef sub_match<BidirectionalIterator> value_type;
typedef typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type
typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type
difference_type;
typedef const value_type* pointer;
typedef const value_type& reference;

16
include/boost/regex/v4/regex_traits.hpp
View File

@ -82,7 +82,7 @@ struct regex_traits : public implementationT
// interfaces that we support, in addition to the
// required "standard" ones:
//
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
#if !BOOST_WORKAROUND(__HP_aCC, < 60000)
BOOST_MPL_HAS_XXX_TRAIT_DEF(boost_extensions_tag)
#else
@ -99,7 +99,7 @@ struct default_wrapper : public BaseT
typedef typename BaseT::char_type char_type;
std::string error_string(::boost::regex_constants::error_type e)const
{
return ::boost::re_detail::get_default_error_string(e);
return ::boost::BOOST_REGEX_DETAIL_NS::get_default_error_string(e);
}
::boost::regex_constants::syntax_type syntax_type(char_type c)const
{
@ -111,7 +111,7 @@ struct default_wrapper : public BaseT
}
int toi(const char_type*& p1, const char_type* p2, int radix)const
{
return ::boost::re_detail::global_toi(p1, p2, radix, *this);
return ::boost::BOOST_REGEX_DETAIL_NS::global_toi(p1, p2, radix, *this);
}
char_type translate(char_type c, bool icase)const
{
@ -123,11 +123,11 @@ struct default_wrapper : public BaseT
}
char_type tolower(char_type c)const
{
return ::boost::re_detail::global_lower(c);
return ::boost::BOOST_REGEX_DETAIL_NS::global_lower(c);
}
char_type toupper(char_type c)const
{
return ::boost::re_detail::global_upper(c);
return ::boost::BOOST_REGEX_DETAIL_NS::global_upper(c);
}
};
@ -157,13 +157,13 @@ struct compute_wrapper_base<c_regex_traits<wchar_t>, false>
#endif
#endif
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
template <class BaseT>
struct regex_traits_wrapper
: public ::boost::re_detail::compute_wrapper_base<
: public ::boost::BOOST_REGEX_DETAIL_NS::compute_wrapper_base<
BaseT,
::boost::re_detail::has_boost_extensions_tag<BaseT>::value
::boost::BOOST_REGEX_DETAIL_NS::has_boost_extensions_tag<BaseT>::value
>::type
{
regex_traits_wrapper(){}

8
include/boost/regex/v4/regex_traits_defaults.hpp
View File

@ -30,6 +30,8 @@
#pragma warning(pop)
#endif
#include <boost/regex/config.hpp>
#ifndef BOOST_REGEX_SYNTAX_TYPE_HPP
#include <boost/regex/v4/syntax_type.hpp>
#endif
@ -43,7 +45,7 @@ namespace std{
}
#endif
namespace boost{ namespace re_detail{
namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
//
@ -153,7 +155,7 @@ struct character_pointer_range
// calling std::equal, but there is no other algorithm available:
// not even a non-standard MS one. So forward to unchecked_equal
// in the MS case.
return ((p2 - p1) == (r.p2 - r.p1)) && re_detail::equal(p1, p2, r.p1);
return ((p2 - p1) == (r.p2 - r.p1)) && BOOST_REGEX_DETAIL_NS::equal(p1, p2, r.p1);
}
};
template <class charT>
@ -354,7 +356,7 @@ inline const char* get_escape_R_string<char>()
#endif
}
} // re_detail
} // BOOST_REGEX_DETAIL_NS
} // boost
#ifdef BOOST_MSVC

7
include/boost/regex/v4/regex_workaround.hpp
View File

@ -42,6 +42,7 @@
#include <boost/scoped_array.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/mpl/bool_fwd.hpp>
#include <boost/regex/config.hpp>
#ifndef BOOST_NO_STD_LOCALE
# include <locale>
#endif
@ -52,7 +53,7 @@ namespace std{
}
#endif
namespace boost{ namespace re_detail{
namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
#ifdef BOOST_NO_STD_DISTANCE
template <class T>
std::ptrdiff_t distance(const T& x, const T& y)
@ -94,7 +95,7 @@ namespace std{
****************************************************************************/
#ifdef __cplusplus
namespace boost{ namespace re_detail{
namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
#ifdef BOOST_MSVC
#pragma warning (push)
@ -123,7 +124,7 @@ inline void pointer_construct(T* p, const T& t)
****************************************************************************/
#ifdef __cplusplus
namespace boost{ namespace re_detail{
namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
#if BOOST_WORKAROUND(BOOST_MSVC,>=1400) && BOOST_WORKAROUND(BOOST_MSVC, <1600) && defined(_CPPLIB_VER) && defined(BOOST_DINKUMWARE_STDLIB) && !(defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))
//
// MSVC 8 will either emit warnings or else refuse to compile

4
include/boost/regex/v4/states.hpp
View File

@ -31,7 +31,7 @@
#endif
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
/*** mask_type *******************************************************
Whenever we have a choice of two alternatives, we use an array of bytes
@ -281,7 +281,7 @@ iterator BOOST_REGEX_CALL re_is_set_member(iterator next,
const re_set_long<char_classT>* set_,
const regex_data<charT, traits_type>& e, bool icase);
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
} // namespace boost

138
include/boost/regex/v4/sub_match.hpp
View File

@ -35,11 +35,11 @@ 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;
typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidiIterator>::value_type value_type;
#if defined(BOOST_NO_STD_ITERATOR_TRAITS)
typedef std::ptrdiff_t difference_type;
#else
typedef typename re_detail::regex_iterator_traits<BidiIterator>::difference_type difference_type;
typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidiIterator>::difference_type difference_type;
#endif
typedef BidiIterator iterator_type;
typedef BidiIterator iterator;
@ -65,7 +65,7 @@ struct sub_match : public std::pair<BidiIterator, BidiIterator>
#endif
difference_type BOOST_REGEX_CALL length()const
{
difference_type n = matched ? ::boost::re_detail::distance((BidiIterator)this->first, (BidiIterator)this->second) : 0;
difference_type n = matched ? ::boost::BOOST_REGEX_DETAIL_NS::distance((BidiIterator)this->first, (BidiIterator)this->second) : 0;
return n;
}
std::basic_string<value_type> str()const
@ -73,7 +73,7 @@ struct sub_match : public std::pair<BidiIterator, BidiIterator>
std::basic_string<value_type> result;
if(matched)
{
std::size_t len = ::boost::re_detail::distance((BidiIterator)this->first, (BidiIterator)this->second);
std::size_t len = ::boost::BOOST_REGEX_DETAIL_NS::distance((BidiIterator)this->first, (BidiIterator)this->second);
result.reserve(len);
BidiIterator i = this->first;
while(i != this->second)
@ -195,235 +195,235 @@ typedef sub_match<std::wstring::const_iterator> wssub_match;
// 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,
inline bool operator == (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::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,
inline bool operator != (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::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,
inline bool operator < (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::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,
inline bool operator <= (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::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,
inline bool operator >= (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::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,
inline bool operator > (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::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)
const std::basic_string<typename BOOST_REGEX_DETAIL_NS::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)
const std::basic_string<typename BOOST_REGEX_DETAIL_NS::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)
const std::basic_string<typename BOOST_REGEX_DETAIL_NS::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)
const std::basic_string<typename BOOST_REGEX_DETAIL_NS::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)
const std::basic_string<typename BOOST_REGEX_DETAIL_NS::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)
const std::basic_string<typename BOOST_REGEX_DETAIL_NS::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)
typename BOOST_REGEX_DETAIL_NS::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)
typename BOOST_REGEX_DETAIL_NS::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)
typename BOOST_REGEX_DETAIL_NS::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)
typename BOOST_REGEX_DETAIL_NS::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)
typename BOOST_REGEX_DETAIL_NS::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)
typename BOOST_REGEX_DETAIL_NS::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,
inline bool operator == (typename BOOST_REGEX_DETAIL_NS::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,
inline bool operator != (typename BOOST_REGEX_DETAIL_NS::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,
inline bool operator < (typename BOOST_REGEX_DETAIL_NS::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,
inline bool operator > (typename BOOST_REGEX_DETAIL_NS::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,
inline bool operator <= (typename BOOST_REGEX_DETAIL_NS::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,
inline bool operator >= (typename BOOST_REGEX_DETAIL_NS::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)
typename BOOST_REGEX_DETAIL_NS::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)
typename BOOST_REGEX_DETAIL_NS::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)
typename BOOST_REGEX_DETAIL_NS::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)
typename BOOST_REGEX_DETAIL_NS::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)
typename BOOST_REGEX_DETAIL_NS::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)
typename BOOST_REGEX_DETAIL_NS::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,
inline bool operator == (typename BOOST_REGEX_DETAIL_NS::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,
inline bool operator != (typename BOOST_REGEX_DETAIL_NS::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,
inline bool operator < (typename BOOST_REGEX_DETAIL_NS::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,
inline bool operator > (typename BOOST_REGEX_DETAIL_NS::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,
inline bool operator <= (typename BOOST_REGEX_DETAIL_NS::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,
inline bool operator >= (typename BOOST_REGEX_DETAIL_NS::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,
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>
operator + (const std::basic_string<typename BOOST_REGEX_DETAIL_NS::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;
std::basic_string<typename BOOST_REGEX_DETAIL_NS::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>
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::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)
const std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator>& s)
{
std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type, traits, Allocator> result;
std::basic_string<typename BOOST_REGEX_DETAIL_NS::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,
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type>
operator + (typename BOOST_REGEX_DETAIL_NS::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);
std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> result;
result.reserve(std::char_traits<typename BOOST_REGEX_DETAIL_NS::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>
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type>
operator + (const sub_match<RandomAccessIterator>& m,
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const * s)
typename BOOST_REGEX_DETAIL_NS::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);
std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type> result;
result.reserve(std::char_traits<typename BOOST_REGEX_DETAIL_NS::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,
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type>
operator + (typename BOOST_REGEX_DETAIL_NS::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>
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type>
operator + (const sub_match<RandomAccessIterator>& m,
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const * s)
typename BOOST_REGEX_DETAIL_NS::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,
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type>
operator + (typename BOOST_REGEX_DETAIL_NS::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;
std::basic_string<typename BOOST_REGEX_DETAIL_NS::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>
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type>
operator + (const sub_match<RandomAccessIterator>& m,
typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<RandomAccessIterator>::value_type const& s)
{
std::basic_string<typename re_detail::regex_iterator_traits<RandomAccessIterator>::value_type> result;
std::basic_string<typename BOOST_REGEX_DETAIL_NS::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>
inline std::basic_string<typename BOOST_REGEX_DETAIL_NS::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;
std::basic_string<typename BOOST_REGEX_DETAIL_NS::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);
}
@ -445,7 +445,7 @@ std::ostream& operator << (std::ostream& os,
#endif
#ifdef BOOST_OLD_REGEX_H
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
template <class BidiIterator, class charT>
int do_toi(BidiIterator i, BidiIterator j, char c, int radix)
{
@ -484,7 +484,7 @@ sub_match<BidiIterator>::operator int()const
neg = -1;
++i;
}
neg *= re_detail::do_toi(i, j, *i);
neg *= BOOST_REGEX_DETAIL_NS::do_toi(i, j, *i);
if(i != j)raise_regex_exception("Bad sub-expression");
return neg;
}
@ -495,7 +495,7 @@ sub_match<BidiIterator>::operator unsigned int()const
BidiIterator j = second;
if(i == j)
raise_regex_exception("Bad sub-expression");
return re_detail::do_toi(i, j, *first);
return BOOST_REGEX_DETAIL_NS::do_toi(i, j, *first);
}
#endif

4
include/boost/regex/v4/u32regex_iterator.hpp
View File

@ -76,7 +76,7 @@ class u32regex_iterator
: public std::iterator<
std::forward_iterator_tag,
match_results<BidirectionalIterator>,
typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type,
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type,
const match_results<BidirectionalIterator>*,
const match_results<BidirectionalIterator>& >
#endif
@ -87,7 +87,7 @@ private:
public:
typedef u32regex regex_type;
typedef match_results<BidirectionalIterator> value_type;
typedef typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type
typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type
difference_type;
typedef const value_type* pointer;
typedef const value_type& reference;

4
include/boost/regex/v4/u32regex_token_iterator.hpp
View File

@ -159,7 +159,7 @@ class u32regex_token_iterator
: public std::iterator<
std::forward_iterator_tag,
sub_match<BidirectionalIterator>,
typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type,
typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type,
const sub_match<BidirectionalIterator>*,
const sub_match<BidirectionalIterator>& >
#endif
@ -170,7 +170,7 @@ private:
public:
typedef u32regex regex_type;
typedef sub_match<BidirectionalIterator> value_type;
typedef typename re_detail::regex_iterator_traits<BidirectionalIterator>::difference_type
typedef typename BOOST_REGEX_DETAIL_NS::regex_iterator_traits<BidirectionalIterator>::difference_type
difference_type;
typedef const value_type* pointer;
typedef const value_type& reference;

78
include/boost/regex/v4/w32_regex_traits.hpp
View File

@ -60,7 +60,7 @@ namespace boost{
template <class charT>
class w32_regex_traits;
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
//
// start by typedeffing the types we'll need:
@ -164,19 +164,19 @@ public:
map_iterator_type i = m_char_map.find(c);
if(i == m_char_map.end())
{
if(::boost::re_detail::w32_is_lower(c, this->m_locale)) return regex_constants::escape_type_class;
if(::boost::re_detail::w32_is_upper(c, this->m_locale)) return regex_constants::escape_type_not_class;
if(::boost::BOOST_REGEX_DETAIL_NS::w32_is_lower(c, this->m_locale)) return regex_constants::escape_type_class;
if(::boost::BOOST_REGEX_DETAIL_NS::w32_is_upper(c, this->m_locale)) return regex_constants::escape_type_not_class;
return 0;
}
return i->second;
}
charT tolower(charT c)const
{
return ::boost::re_detail::w32_tolower(c, this->m_locale);
return ::boost::BOOST_REGEX_DETAIL_NS::w32_tolower(c, this->m_locale);
}
bool isctype(boost::uint32_t mask, charT c)const
{
return ::boost::re_detail::w32_is(this->m_locale, mask, c);
return ::boost::BOOST_REGEX_DETAIL_NS::w32_is(this->m_locale, mask, c);
}
private:
@ -186,7 +186,7 @@ private:
};
template <class charT>
w32_regex_traits_char_layer<charT>::w32_regex_traits_char_layer(::boost::re_detail::lcid_type l)
w32_regex_traits_char_layer<charT>::w32_regex_traits_char_layer(::boost::BOOST_REGEX_DETAIL_NS::lcid_type l)
: w32_regex_traits_base<charT>(l)
{
// we need to start by initialising our syntax map so we know which
@ -195,12 +195,12 @@ w32_regex_traits_char_layer<charT>::w32_regex_traits_char_layer(::boost::re_deta
std::string cat_name(w32_regex_traits<charT>::get_catalog_name());
if(cat_name.size())
{
cat = ::boost::re_detail::w32_cat_open(cat_name);
cat = ::boost::BOOST_REGEX_DETAIL_NS::w32_cat_open(cat_name);
if(!cat)
{
std::string m("Unable to open message catalog: ");
std::runtime_error err(m + cat_name);
boost::re_detail::raise_runtime_error(err);
boost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(err);
}
}
//
@ -210,7 +210,7 @@ w32_regex_traits_char_layer<charT>::w32_regex_traits_char_layer(::boost::re_deta
{
for(regex_constants::syntax_type i = 1; i < regex_constants::syntax_max; ++i)
{
string_type mss = ::boost::re_detail::w32_cat_get(cat, this->m_locale, i, get_default_message(i));
string_type mss = ::boost::BOOST_REGEX_DETAIL_NS::w32_cat_get(cat, this->m_locale, i, get_default_message(i));
for(typename string_type::size_type j = 0; j < mss.size(); ++j)
{
this->m_char_map[mss[j]] = i;
@ -253,7 +253,7 @@ class BOOST_REGEX_DECL w32_regex_traits_char_layer<char> : public w32_regex_trai
{
typedef std::string string_type;
public:
w32_regex_traits_char_layer(::boost::re_detail::lcid_type l)
w32_regex_traits_char_layer(::boost::BOOST_REGEX_DETAIL_NS::lcid_type l)
: w32_regex_traits_base<char>(l)
{
init();
@ -300,7 +300,7 @@ public:
typedef std::basic_string<charT> string_type;
typedef charT char_type;
w32_regex_traits_implementation(::boost::re_detail::lcid_type l);
w32_regex_traits_implementation(::boost::BOOST_REGEX_DETAIL_NS::lcid_type l);
std::string error_string(regex_constants::error_type n) const
{
if(!m_error_strings.empty())
@ -327,7 +327,7 @@ public:
string_type transform_primary(const charT* p1, const charT* p2) const;
string_type transform(const charT* p1, const charT* p2) const
{
return ::boost::re_detail::w32_transform(this->m_locale, p1, p2);
return ::boost::BOOST_REGEX_DETAIL_NS::w32_transform(this->m_locale, p1, p2);
}
private:
std::map<int, std::string> m_error_strings; // error messages indexed by numberic ID
@ -430,19 +430,19 @@ typename w32_regex_traits_implementation<charT>::string_type
}
template <class charT>
w32_regex_traits_implementation<charT>::w32_regex_traits_implementation(::boost::re_detail::lcid_type l)
w32_regex_traits_implementation<charT>::w32_regex_traits_implementation(::boost::BOOST_REGEX_DETAIL_NS::lcid_type l)
: w32_regex_traits_char_layer<charT>(l)
{
cat_type cat;
std::string cat_name(w32_regex_traits<charT>::get_catalog_name());
if(cat_name.size())
{
cat = ::boost::re_detail::w32_cat_open(cat_name);
cat = ::boost::BOOST_REGEX_DETAIL_NS::w32_cat_open(cat_name);
if(!cat)
{
std::string m("Unable to open message catalog: ");
std::runtime_error err(m + cat_name);
boost::re_detail::raise_runtime_error(err);
boost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(err);
}
}
//
@ -464,7 +464,7 @@ w32_regex_traits_implementation<charT>::w32_regex_traits_implementation(::boost:
default_message.append(1, static_cast<charT>(*p));
++p;
}
string_type s = ::boost::re_detail::w32_cat_get(cat, this->m_locale, i+200, default_message);
string_type s = ::boost::BOOST_REGEX_DETAIL_NS::w32_cat_get(cat, this->m_locale, i+200, default_message);
std::string result;
for(std::string::size_type j = 0; j < s.size(); ++j)
{
@ -495,7 +495,7 @@ w32_regex_traits_implementation<charT>::w32_regex_traits_implementation(::boost:
static const string_type null_string;
for(unsigned int j = 0; j <= 13; ++j)
{
string_type s(::boost::re_detail::w32_cat_get(cat, this->m_locale, j+300, null_string));
string_type s(::boost::BOOST_REGEX_DETAIL_NS::w32_cat_get(cat, this->m_locale, j+300, null_string));
if(s.size())
this->m_custom_class_names[s] = masks[j];
}
@ -503,7 +503,7 @@ w32_regex_traits_implementation<charT>::w32_regex_traits_implementation(::boost:
//
// get the collation format used by m_pcollate:
//
m_collate_type = re_detail::find_sort_syntax(this, &m_collate_delim);
m_collate_type = BOOST_REGEX_DETAIL_NS::find_sort_syntax(this, &m_collate_delim);
}
template <class charT>
@ -542,7 +542,7 @@ typename w32_regex_traits_implementation<charT>::char_class_type
if(pos != m_custom_class_names.end())
return pos->second;
}
std::size_t state_id = 1 + re_detail::get_default_class_id(p1, p2);
std::size_t state_id = 1 + BOOST_REGEX_DETAIL_NS::get_default_class_id(p1, p2);
if(state_id < sizeof(masks) / sizeof(masks[0]))
return masks[state_id];
return masks[0];
@ -550,13 +550,13 @@ typename w32_regex_traits_implementation<charT>::char_class_type
template <class charT>
boost::shared_ptr<const w32_regex_traits_implementation<charT> > create_w32_regex_traits(::boost::re_detail::lcid_type l)
boost::shared_ptr<const w32_regex_traits_implementation<charT> > create_w32_regex_traits(::boost::BOOST_REGEX_DETAIL_NS::lcid_type l)
{
// TODO: create a cache for previously constructed objects.
return boost::object_cache< ::boost::re_detail::lcid_type, w32_regex_traits_implementation<charT> >::get(l, 5);
return boost::object_cache< ::boost::BOOST_REGEX_DETAIL_NS::lcid_type, w32_regex_traits_implementation<charT> >::get(l, 5);
}
} // re_detail
} // BOOST_REGEX_DETAIL_NS
template <class charT>
class w32_regex_traits
@ -565,13 +565,13 @@ public:
typedef charT char_type;
typedef std::size_t size_type;
typedef std::basic_string<char_type> string_type;
typedef ::boost::re_detail::lcid_type locale_type;
typedef ::boost::BOOST_REGEX_DETAIL_NS::lcid_type locale_type;
typedef boost::uint_least32_t char_class_type;
struct boost_extensions_tag{};
w32_regex_traits()
: m_pimpl(re_detail::create_w32_regex_traits<charT>(::boost::re_detail::w32_get_default_locale()))
: m_pimpl(BOOST_REGEX_DETAIL_NS::create_w32_regex_traits<charT>(::boost::BOOST_REGEX_DETAIL_NS::w32_get_default_locale()))
{ }
static size_type length(const char_type* p)
{
@ -603,11 +603,11 @@ public:
}
charT toupper(charT c) const
{
return ::boost::re_detail::w32_toupper(c, this->m_pimpl->m_locale);
return ::boost::BOOST_REGEX_DETAIL_NS::w32_toupper(c, this->m_pimpl->m_locale);
}
string_type transform(const charT* p1, const charT* p2) const
{
return ::boost::re_detail::w32_transform(this->m_pimpl->m_locale, p1, p2);
return ::boost::BOOST_REGEX_DETAIL_NS::w32_transform(this->m_pimpl->m_locale, p1, p2);
}
string_type transform_primary(const charT* p1, const charT* p2) const
{
@ -623,34 +623,34 @@ public:
}
bool isctype(charT c, char_class_type f) const
{
if((f & re_detail::w32_regex_traits_implementation<charT>::mask_base)
&& (this->m_pimpl->isctype(f & re_detail::w32_regex_traits_implementation<charT>::mask_base, c)))
if((f & BOOST_REGEX_DETAIL_NS::w32_regex_traits_implementation<charT>::mask_base)
&& (this->m_pimpl->isctype(f & BOOST_REGEX_DETAIL_NS::w32_regex_traits_implementation<charT>::mask_base, c)))
return true;
else if((f & re_detail::w32_regex_traits_implementation<charT>::mask_unicode) && re_detail::is_extended(c))
else if((f & BOOST_REGEX_DETAIL_NS::w32_regex_traits_implementation<charT>::mask_unicode) && BOOST_REGEX_DETAIL_NS::is_extended(c))
return true;
else if((f & re_detail::w32_regex_traits_implementation<charT>::mask_word) && (c == '_'))
else if((f & BOOST_REGEX_DETAIL_NS::w32_regex_traits_implementation<charT>::mask_word) && (c == '_'))
return true;
else if((f & re_detail::w32_regex_traits_implementation<charT>::mask_vertical)
&& (::boost::re_detail::is_separator(c) || (c == '\v')))
else if((f & BOOST_REGEX_DETAIL_NS::w32_regex_traits_implementation<charT>::mask_vertical)
&& (::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) || (c == '\v')))
return true;
else if((f & re_detail::w32_regex_traits_implementation<charT>::mask_horizontal)
&& this->isctype(c, 0x0008u) && !this->isctype(c, re_detail::w32_regex_traits_implementation<charT>::mask_vertical))
else if((f & BOOST_REGEX_DETAIL_NS::w32_regex_traits_implementation<charT>::mask_horizontal)
&& this->isctype(c, 0x0008u) && !this->isctype(c, BOOST_REGEX_DETAIL_NS::w32_regex_traits_implementation<charT>::mask_vertical))
return true;
return false;
}
int toi(const charT*& p1, const charT* p2, int radix)const
{
return ::boost::re_detail::global_toi(p1, p2, radix, *this);
return ::boost::BOOST_REGEX_DETAIL_NS::global_toi(p1, p2, radix, *this);
}
int value(charT c, int radix)const
{
int result = ::boost::re_detail::global_value(c);
int result = ::boost::BOOST_REGEX_DETAIL_NS::global_value(c);
return result < radix ? result : -1;
}
locale_type imbue(locale_type l)
{
::boost::re_detail::lcid_type result(getloc());
m_pimpl = re_detail::create_w32_regex_traits<charT>(l);
::boost::BOOST_REGEX_DETAIL_NS::lcid_type result(getloc());
m_pimpl = BOOST_REGEX_DETAIL_NS::create_w32_regex_traits<charT>(l);
return result;
}
locale_type getloc()const
@ -670,7 +670,7 @@ public:
static std::string get_catalog_name();
private:
boost::shared_ptr<const re_detail::w32_regex_traits_implementation<charT> > m_pimpl;
boost::shared_ptr<const BOOST_REGEX_DETAIL_NS::w32_regex_traits_implementation<charT> > m_pimpl;
//
// catalog name handler:
//

22
src/c_regex_traits.cpp
View File

@ -77,7 +77,7 @@ c_regex_traits<char>::string_type BOOST_REGEX_CALL c_regex_traits<char>::transfo
c_regex_traits<char>::string_type BOOST_REGEX_CALL c_regex_traits<char>::transform_primary(const char* p1, const char* p2)
{
static char s_delim;
static const int s_collate_type = ::boost::re_detail::find_sort_syntax(static_cast<c_regex_traits<char>*>(0), &s_delim);
static const int s_collate_type = ::boost::BOOST_REGEX_DETAIL_NS::find_sort_syntax(static_cast<c_regex_traits<char>*>(0), &s_delim);
std::string result;
//
// What we do here depends upon the format of the sort key returned by
@ -85,8 +85,8 @@ c_regex_traits<char>::string_type BOOST_REGEX_CALL c_regex_traits<char>::transfo
//
switch(s_collate_type)
{
case ::boost::re_detail::sort_C:
case ::boost::re_detail::sort_unknown:
case ::boost::BOOST_REGEX_DETAIL_NS::sort_C:
case ::boost::BOOST_REGEX_DETAIL_NS::sort_unknown:
// the best we can do is translate to lower case, then get a regular sort key:
{
result.assign(p1, p2);
@ -95,14 +95,14 @@ c_regex_traits<char>::string_type BOOST_REGEX_CALL c_regex_traits<char>::transfo
result = transform(&*result.begin(), &*result.begin() + result.size());
break;
}
case ::boost::re_detail::sort_fixed:
case ::boost::BOOST_REGEX_DETAIL_NS::sort_fixed:
{
// get a regular sort key, and then truncate it:
result = transform(p1, p2);
result.erase(s_delim);
break;
}
case ::boost::re_detail::sort_delim:
case ::boost::BOOST_REGEX_DETAIL_NS::sort_delim:
// get a regular sort key, and then truncate everything after the delim:
result = transform(p1, p2);
if(result.size() && (result[0] == s_delim))
@ -149,13 +149,13 @@ c_regex_traits<char>::char_class_type BOOST_REGEX_CALL c_regex_traits<char>::loo
char_class_xdigit,
};
int idx = ::boost::re_detail::get_default_class_id(p1, p2);
int idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(p1, p2);
if(idx < 0)
{
std::string s(p1, p2);
for(std::string::size_type i = 0; i < s.size(); ++i)
s[i] = static_cast<char>((std::tolower)(static_cast<unsigned char>(s[i])));
idx = ::boost::re_detail::get_default_class_id(&*s.begin(), &*s.begin() + s.size());
idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(&*s.begin(), &*s.begin() + s.size());
}
BOOST_ASSERT(std::size_t(idx+1) < sizeof(masks) / sizeof(masks[0]));
return masks[idx+1];
@ -173,16 +173,16 @@ bool BOOST_REGEX_CALL c_regex_traits<char>::isctype(char c, char_class_type mask
|| ((mask & char_class_digit) && (std::isdigit)(static_cast<unsigned char>(c)))
|| ((mask & char_class_punct) && (std::ispunct)(static_cast<unsigned char>(c)))
|| ((mask & char_class_xdigit) && (std::isxdigit)(static_cast<unsigned char>(c)))
|| ((mask & char_class_blank) && (std::isspace)(static_cast<unsigned char>(c)) && !::boost::re_detail::is_separator(c))
|| ((mask & char_class_blank) && (std::isspace)(static_cast<unsigned char>(c)) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c))
|| ((mask & char_class_word) && (c == '_'))
|| ((mask & char_class_vertical) && (::boost::re_detail::is_separator(c) || (c == '\v')))
|| ((mask & char_class_horizontal) && (std::isspace)(static_cast<unsigned char>(c)) && !::boost::re_detail::is_separator(c) && (c != '\v'));
|| ((mask & char_class_vertical) && (::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) || (c == '\v')))
|| ((mask & char_class_horizontal) && (std::isspace)(static_cast<unsigned char>(c)) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) && (c != '\v'));
}
c_regex_traits<char>::string_type BOOST_REGEX_CALL c_regex_traits<char>::lookup_collatename(const char* p1, const char* p2)
{
std::string s(p1, p2);
s = ::boost::re_detail::lookup_default_collate_name(s);
s = ::boost::BOOST_REGEX_DETAIL_NS::lookup_default_collate_name(s);
if(s.empty() && (p2-p1 == 1))
s.append(1, *p1);
return s;

6
src/cpp_regex_traits.cpp
View File

@ -28,7 +28,7 @@ namespace std{
}
#endif
namespace boost{ namespace re_detail{
namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
void cpp_regex_traits_char_layer<char>::init()
{
@ -51,7 +51,7 @@ void cpp_regex_traits_char_layer<char>::init()
{
std::string m("Unable to open message catalog: ");
std::runtime_error err(m + cat_name);
boost::re_detail::raise_runtime_error(err);
boost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(err);
}
}
//
@ -111,7 +111,7 @@ void cpp_regex_traits_char_layer<char>::init()
}while(0xFF != i++);
}
} // re_detail
} // BOOST_REGEX_DETAIL_NS
} // boost
#endif

80
src/cregex.cpp
View File

@ -68,7 +68,7 @@ inline std::string to_string(const char* i, const char* j)
}
}
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
class RegExData
{
@ -141,12 +141,12 @@ void RegExData::clean()
RegEx::RegEx()
{
pdata = new re_detail::RegExData();
pdata = new BOOST_REGEX_DETAIL_NS::RegExData();
}
RegEx::RegEx(const RegEx& o)
{
pdata = new re_detail::RegExData(*(o.pdata));
pdata = new BOOST_REGEX_DETAIL_NS::RegExData(*(o.pdata));
}
RegEx::~RegEx()
@ -156,13 +156,13 @@ RegEx::~RegEx()
RegEx::RegEx(const char* c, bool icase)
{
pdata = new re_detail::RegExData();
pdata = new BOOST_REGEX_DETAIL_NS::RegExData();
SetExpression(c, icase);
}
RegEx::RegEx(const std::string& s, bool icase)
{
pdata = new re_detail::RegExData();
pdata = new BOOST_REGEX_DETAIL_NS::RegExData();
SetExpression(s.c_str(), icase);
}
@ -200,7 +200,7 @@ std::string RegEx::Expression()const
//
bool RegEx::Match(const char* p, match_flag_type flags)
{
pdata->t = re_detail::RegExData::type_pc;
pdata->t = BOOST_REGEX_DETAIL_NS::RegExData::type_pc;
pdata->pbase = p;
const char* end = p;
while(*end)++end;
@ -215,7 +215,7 @@ bool RegEx::Match(const char* p, match_flag_type flags)
bool RegEx::Search(const char* p, match_flag_type flags)
{
pdata->t = re_detail::RegExData::type_pc;
pdata->t = BOOST_REGEX_DETAIL_NS::RegExData::type_pc;
pdata->pbase = p;
const char* end = p;
while(*end)++end;
@ -227,7 +227,7 @@ bool RegEx::Search(const char* p, match_flag_type flags)
}
return false;
}
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
struct pred1
{
GrepCallback cb;
@ -242,17 +242,17 @@ struct pred1
}
unsigned int RegEx::Grep(GrepCallback cb, const char* p, match_flag_type flags)
{
pdata->t = re_detail::RegExData::type_pc;
pdata->t = BOOST_REGEX_DETAIL_NS::RegExData::type_pc;
pdata->pbase = p;
const char* end = p;
while(*end)++end;
unsigned int result = regex_grep(re_detail::pred1(cb, this), p, end, pdata->e, flags);
unsigned int result = regex_grep(BOOST_REGEX_DETAIL_NS::pred1(cb, this), p, end, pdata->e, flags);
if(result)
pdata->update();
return result;
}
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
struct pred2
{
std::vector<std::string>& v;
@ -271,17 +271,17 @@ private:
unsigned int RegEx::Grep(std::vector<std::string>& v, const char* p, match_flag_type flags)
{
pdata->t = re_detail::RegExData::type_pc;
pdata->t = BOOST_REGEX_DETAIL_NS::RegExData::type_pc;
pdata->pbase = p;
const char* end = p;
while(*end)++end;
unsigned int result = regex_grep(re_detail::pred2(v, this), p, end, pdata->e, flags);
unsigned int result = regex_grep(BOOST_REGEX_DETAIL_NS::pred2(v, this), p, end, pdata->e, flags);
if(result)
pdata->update();
return result;
}
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
struct pred3
{
std::vector<std::size_t>& v;
@ -300,18 +300,18 @@ private:
}
unsigned int RegEx::Grep(std::vector<std::size_t>& v, const char* p, match_flag_type flags)
{
pdata->t = re_detail::RegExData::type_pc;
pdata->t = BOOST_REGEX_DETAIL_NS::RegExData::type_pc;
pdata->pbase = p;
const char* end = p;
while(*end)++end;
unsigned int result = regex_grep(re_detail::pred3(v, p, this), p, end, pdata->e, flags);
unsigned int result = regex_grep(BOOST_REGEX_DETAIL_NS::pred3(v, p, this), p, end, pdata->e, flags);
if(result)
pdata->update();
return result;
}
#ifndef BOOST_REGEX_NO_FILEITER
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
struct pred4
{
GrepFileCallback cb;
@ -338,17 +338,17 @@ void BuildFileList(std::list<std::string>* pl, const char* files, bool recurse)
{
// go through sub directories:
char buf[MAX_PATH];
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(buf, MAX_PATH, start.root()));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(buf, MAX_PATH, start.root()));
if(*buf == 0)
{
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(buf, MAX_PATH, "."));
re_detail::overflow_error_if_not_zero(re_detail::strcat_s(buf, MAX_PATH, directory_iterator::separator()));
re_detail::overflow_error_if_not_zero(re_detail::strcat_s(buf, MAX_PATH, "*"));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(buf, MAX_PATH, "."));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcat_s(buf, MAX_PATH, directory_iterator::separator()));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcat_s(buf, MAX_PATH, "*"));
}
else
{
re_detail::overflow_error_if_not_zero(re_detail::strcat_s(buf, MAX_PATH, directory_iterator::separator()));
re_detail::overflow_error_if_not_zero(re_detail::strcat_s(buf, MAX_PATH, "*"));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcat_s(buf, MAX_PATH, directory_iterator::separator()));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcat_s(buf, MAX_PATH, "*"));
}
directory_iterator dstart(buf);
directory_iterator dend;
@ -403,9 +403,9 @@ unsigned int RegEx::GrepFiles(GrepFileCallback cb, const char* files, bool recur
while(start != end)
{
mapfile map((*start).c_str());
pdata->t = re_detail::RegExData::type_pf;
pdata->t = BOOST_REGEX_DETAIL_NS::RegExData::type_pf;
pdata->fbase = map.begin();
re_detail::pred4 pred(cb, this, (*start).c_str());
BOOST_REGEX_DETAIL_NS::pred4 pred(cb, this, (*start).c_str());
int r = regex_grep(pred, map.begin(), map.end(), pdata->e, flags);
result += r;
++start;
@ -430,7 +430,7 @@ unsigned int RegEx::FindFiles(FindFilesCallback cb, const char* files, bool recu
while(start != end)
{
mapfile map((*start).c_str());
pdata->t = re_detail::RegExData::type_pf;
pdata->t = BOOST_REGEX_DETAIL_NS::RegExData::type_pf;
pdata->fbase = map.begin();
if(regex_search(map.begin(), map.end(), pdata->fm, pdata->e, flags))
@ -456,7 +456,7 @@ std::string RegEx::Merge(const std::string& in, const std::string& fmt,
bool copy, match_flag_type flags)
{
std::string result;
re_detail::string_out_iterator<std::string> i(result);
BOOST_REGEX_DETAIL_NS::string_out_iterator<std::string> i(result);
if(!copy) flags |= format_no_copy;
regex_replace(i, in.begin(), in.end(), pdata->e, fmt.c_str(), flags);
return result;
@ -467,7 +467,7 @@ std::string RegEx::Merge(const char* in, const char* fmt,
{
std::string result;
if(!copy) flags |= format_no_copy;
re_detail::string_out_iterator<std::string> i(result);
BOOST_REGEX_DETAIL_NS::string_out_iterator<std::string> i(result);
regex_replace(i, in, in + std::strlen(in), pdata->e, fmt, flags);
return result;
}
@ -489,13 +489,13 @@ std::size_t RegEx::Position(int i)const
{
switch(pdata->t)
{
case re_detail::RegExData::type_pc:
case BOOST_REGEX_DETAIL_NS::RegExData::type_pc:
return pdata->m[i].matched ? pdata->m[i].first - pdata->pbase : RegEx::npos;
#ifndef BOOST_REGEX_NO_FILEITER
case re_detail::RegExData::type_pf:
case BOOST_REGEX_DETAIL_NS::RegExData::type_pf:
return pdata->fm[i].matched ? pdata->fm[i].first - pdata->fbase : RegEx::npos;
#endif
case re_detail::RegExData::type_copy:
case BOOST_REGEX_DETAIL_NS::RegExData::type_copy:
{
std::map<int, std::ptrdiff_t, std::less<int> >::iterator pos = pdata->positions.find(i);
if(pos == pdata->positions.end())
@ -516,13 +516,13 @@ std::size_t RegEx::Length(int i)const
{
switch(pdata->t)
{
case re_detail::RegExData::type_pc:
case BOOST_REGEX_DETAIL_NS::RegExData::type_pc:
return pdata->m[i].matched ? pdata->m[i].second - pdata->m[i].first : RegEx::npos;
#ifndef BOOST_REGEX_NO_FILEITER
case re_detail::RegExData::type_pf:
case BOOST_REGEX_DETAIL_NS::RegExData::type_pf:
return pdata->fm[i].matched ? pdata->fm[i].second - pdata->fm[i].first : RegEx::npos;
#endif
case re_detail::RegExData::type_copy:
case BOOST_REGEX_DETAIL_NS::RegExData::type_copy:
{
std::map<int, std::string, std::less<int> >::iterator pos = pdata->strings.find(i);
if(pos == pdata->strings.end())
@ -537,13 +537,13 @@ bool RegEx::Matched(int i)const
{
switch(pdata->t)
{
case re_detail::RegExData::type_pc:
case BOOST_REGEX_DETAIL_NS::RegExData::type_pc:
return pdata->m[i].matched;
#ifndef BOOST_REGEX_NO_FILEITER
case re_detail::RegExData::type_pf:
case BOOST_REGEX_DETAIL_NS::RegExData::type_pf:
return pdata->fm[i].matched;
#endif
case re_detail::RegExData::type_copy:
case BOOST_REGEX_DETAIL_NS::RegExData::type_copy:
{
std::map<int, std::string, std::less<int> >::iterator pos = pdata->strings.find(i);
if(pos == pdata->strings.end())
@ -560,15 +560,15 @@ std::string RegEx::What(int i)const
std::string result;
switch(pdata->t)
{
case re_detail::RegExData::type_pc:
case BOOST_REGEX_DETAIL_NS::RegExData::type_pc:
if(pdata->m[i].matched)
result.assign(pdata->m[i].first, pdata->m[i].second);
break;
case re_detail::RegExData::type_pf:
case BOOST_REGEX_DETAIL_NS::RegExData::type_pf:
if(pdata->m[i].matched)
result.assign(to_string(pdata->m[i].first, pdata->m[i].second));
break;
case re_detail::RegExData::type_copy:
case BOOST_REGEX_DETAIL_NS::RegExData::type_copy:
{
std::map<int, std::string, std::less<int> >::iterator pos = pdata->strings.find(i);
if(pos != pdata->strings.end())

46
src/fileiter.cpp
View File

@ -58,7 +58,7 @@ namespace std{
#endif
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
// start with the operating system specific stuff:
#if (defined(__BORLANDC__) || defined(BOOST_REGEX_FI_WIN32_DIR) || defined(BOOST_MSVC)) && !defined(BOOST_RE_NO_WIN32)
@ -110,7 +110,7 @@ void mapfile::open(const char* file)
hmap = 0;
hfile = 0;
std::runtime_error err("Unable to create file mapping.");
boost::re_detail::raise_runtime_error(err);
boost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(err);
}
_first = static_cast<const char*>(MapViewOfFile(hmap, FILE_MAP_READ, 0, 0, 0));
if(_first == 0)
@ -397,9 +397,9 @@ inline void copy_find_file_result_with_overflow_check(const _fi_find_data& data,
{
#ifdef BOOST_NO_ANSI_APIS
if (::WideCharToMultiByte(CP_ACP, 0, data.cFileName, -1, path, max_size, NULL, NULL) == 0)
re_detail::overflow_error_if_not_zero(1);
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(1);
#else
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(path, max_size, data.cFileName));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(path, max_size, data.cFileName));
#endif
}
@ -454,22 +454,22 @@ file_iterator::file_iterator(const char* wild)
BOOST_REGEX_NOEH_ASSERT(_root)
_path = new char[MAX_PATH];
BOOST_REGEX_NOEH_ASSERT(_path)
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_root, MAX_PATH, wild));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(_root, MAX_PATH, wild));
ptr = _root;
while(*ptr)++ptr;
while((ptr > _root) && (*ptr != *_fi_sep) && (*ptr != *_fi_sep_alt))--ptr;
if((ptr == _root) && ( (*ptr== *_fi_sep) || (*ptr==*_fi_sep_alt) ) )
{
_root[1]='\0';
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, _root));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(_path, MAX_PATH, _root));
}
else
{
*ptr = 0;
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, _root));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(_path, MAX_PATH, _root));
if(*_path == 0)
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, "."));
re_detail::overflow_error_if_not_zero(re_detail::strcat_s(_path, MAX_PATH, _fi_sep));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(_path, MAX_PATH, "."));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcat_s(_path, MAX_PATH, _fi_sep));
}
ptr = _path + std::strlen(_path);
@ -512,8 +512,8 @@ file_iterator::file_iterator(const file_iterator& other)
BOOST_REGEX_NOEH_ASSERT(_root)
_path = new char[MAX_PATH];
BOOST_REGEX_NOEH_ASSERT(_path)
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_root, MAX_PATH, other._root));
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, other._path));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(_root, MAX_PATH, other._root));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(_path, MAX_PATH, other._path));
ptr = _path + (other.ptr - other._path);
ref = other.ref;
#ifndef BOOST_NO_EXCEPTIONS
@ -530,8 +530,8 @@ file_iterator::file_iterator(const file_iterator& other)
file_iterator& file_iterator::operator=(const file_iterator& other)
{
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_root, MAX_PATH, other._root));
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, other._path));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(_root, MAX_PATH, other._root));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(_path, MAX_PATH, other._path));
ptr = _path + (other.ptr - other._path);
if(--(ref->count) == 0)
{
@ -632,7 +632,7 @@ directory_iterator::directory_iterator(const char* wild)
BOOST_REGEX_NOEH_ASSERT(_root)
_path = new char[MAX_PATH];
BOOST_REGEX_NOEH_ASSERT(_path)
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_root, MAX_PATH, wild));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(_root, MAX_PATH, wild));
ptr = _root;
while(*ptr)++ptr;
while((ptr > _root) && (*ptr != *_fi_sep) && (*ptr != *_fi_sep_alt))--ptr;
@ -640,15 +640,15 @@ directory_iterator::directory_iterator(const char* wild)
if((ptr == _root) && ( (*ptr== *_fi_sep) || (*ptr==*_fi_sep_alt) ) )
{
_root[1]='\0';
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, _root));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(_path, MAX_PATH, _root));
}
else
{
*ptr = 0;
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, _root));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(_path, MAX_PATH, _root));
if(*_path == 0)
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, "."));
re_detail::overflow_error_if_not_zero(re_detail::strcat_s(_path, MAX_PATH, _fi_sep));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(_path, MAX_PATH, "."));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcat_s(_path, MAX_PATH, _fi_sep));
}
ptr = _path + std::strlen(_path);
@ -702,8 +702,8 @@ directory_iterator::directory_iterator(const directory_iterator& other)
BOOST_REGEX_NOEH_ASSERT(_root)
_path = new char[MAX_PATH];
BOOST_REGEX_NOEH_ASSERT(_path)
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_root, MAX_PATH, other._root));
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, other._path));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(_root, MAX_PATH, other._root));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(_path, MAX_PATH, other._path));
ptr = _path + (other.ptr - other._path);
ref = other.ref;
#ifndef BOOST_NO_EXCEPTIONS
@ -720,8 +720,8 @@ directory_iterator::directory_iterator(const directory_iterator& other)
directory_iterator& directory_iterator::operator=(const directory_iterator& other)
{
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_root, MAX_PATH, other._root));
re_detail::overflow_error_if_not_zero(re_detail::strcpy_s(_path, MAX_PATH, other._path));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(_root, MAX_PATH, other._root));
BOOST_REGEX_DETAIL_NS::overflow_error_if_not_zero(BOOST_REGEX_DETAIL_NS::strcpy_s(_path, MAX_PATH, other._path));
ptr = _path + (other.ptr - other._path);
if(--(ref->count) == 0)
{
@ -910,7 +910,7 @@ bool _fi_FindClose(_fi_find_handle dat)
#endif
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS
} // namspace boost
#endif // BOOST_REGEX_NO_FILEITER

22
src/icu.cpp
View File

@ -28,7 +28,7 @@
namespace boost{
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
icu_regex_traits_implementation::string_type icu_regex_traits_implementation::do_transform(const char_type* p1, const char_type* p2, const U_NAMESPACE_QUALIFIER Collator* pcoll) const
{
@ -191,7 +191,7 @@ icu_regex_traits::char_class_type icu_regex_traits::lookup_icu_mask(const ::UCha
/* zs */ 'z', 's',
};
static const re_detail::character_pointer_range< ::UChar32> range_data[] = {
static const BOOST_REGEX_DETAIL_NS::character_pointer_range< ::UChar32> range_data[] = {
{ prop_name_table+0, prop_name_table+3, }, // any
{ prop_name_table+3, prop_name_table+8, }, // ascii
{ prop_name_table+8, prop_name_table+16, }, // assigned
@ -354,11 +354,11 @@ icu_regex_traits::char_class_type icu_regex_traits::lookup_icu_mask(const ::UCha
};
static const re_detail::character_pointer_range< ::UChar32>* ranges_begin = range_data;
static const re_detail::character_pointer_range< ::UChar32>* ranges_end = range_data + (sizeof(range_data)/sizeof(range_data[0]));
static const BOOST_REGEX_DETAIL_NS::character_pointer_range< ::UChar32>* ranges_begin = range_data;
static const BOOST_REGEX_DETAIL_NS::character_pointer_range< ::UChar32>* ranges_end = range_data + (sizeof(range_data)/sizeof(range_data[0]));
re_detail::character_pointer_range< ::UChar32> t = { p1, p2, };
const re_detail::character_pointer_range< ::UChar32>* p = std::lower_bound(ranges_begin, ranges_end, t);
BOOST_REGEX_DETAIL_NS::character_pointer_range< ::UChar32> t = { p1, p2, };
const BOOST_REGEX_DETAIL_NS::character_pointer_range< ::UChar32>* p = std::lower_bound(ranges_begin, ranges_end, t);
if((p != ranges_end) && (t == *p))
return icu_class_map[p - ranges_begin];
return 0;
@ -392,7 +392,7 @@ icu_regex_traits::char_class_type icu_regex_traits::lookup_classname(const char_
char_class_type(U_GC_ND_MASK) | mask_xdigit,
};
int idx = ::boost::re_detail::get_default_class_id(p1, p2);
int idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(p1, p2);
if(idx >= 0)
return masks[idx+1];
char_class_type result = lookup_icu_mask(p1, p2);
@ -415,7 +415,7 @@ icu_regex_traits::char_class_type icu_regex_traits::lookup_classname(const char_
}
}
if(s.size())
idx = ::boost::re_detail::get_default_class_id(&*s.begin(), &*s.begin() + s.size());
idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(&*s.begin(), &*s.begin() + s.size());
if(idx >= 0)
return masks[idx+1];
if(s.size())
@ -457,7 +457,7 @@ icu_regex_traits::string_type icu_regex_traits::lookup_collatename(const char_ty
return result;
}
// try POSIX name:
s = ::boost::re_detail::lookup_default_collate_name(s);
s = ::boost::BOOST_REGEX_DETAIL_NS::lookup_default_collate_name(s);
#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
result.assign(s.begin(), s.end());
#else
@ -495,9 +495,9 @@ bool icu_regex_traits::isctype(char_type c, char_class_type f) const
return true;
if(((f & mask_ascii) != 0) && (c <= 0x7F))
return true;
if(((f & mask_vertical) != 0) && (::boost::re_detail::is_separator(c) || (c == static_cast<char_type>('\v')) || (m == U_GC_ZL_MASK) || (m == U_GC_ZP_MASK)))
if(((f & mask_vertical) != 0) && (::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) || (c == static_cast<char_type>('\v')) || (m == U_GC_ZL_MASK) || (m == U_GC_ZP_MASK)))
return true;
if(((f & mask_horizontal) != 0) && !::boost::re_detail::is_separator(c) && u_isspace(c) && (c != static_cast<char_type>('\v')))
if(((f & mask_horizontal) != 0) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) && u_isspace(c) && (c != static_cast<char_type>('\v')))
return true;
return false;
}

10
src/posix_api.cpp
View File

@ -154,7 +154,7 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorA(int code, const regex_tA*
{
result = std::strlen(names[code]) + 1;
if(buf_size >= result)
re_detail::strcpy_s(buf, buf_size, names[code]);
BOOST_REGEX_DETAIL_NS::strcpy_s(buf, buf_size, names[code]);
return result;
}
return result;
@ -180,7 +180,7 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorA(int code, const regex_tA*
if(r < 0)
return 0; // sprintf failed
if(std::strlen(localbuf) < buf_size)
re_detail::strcpy_s(buf, buf_size, localbuf);
BOOST_REGEX_DETAIL_NS::strcpy_s(buf, buf_size, localbuf);
return std::strlen(localbuf) + 1;
}
}
@ -190,7 +190,7 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorA(int code, const regex_tA*
(std::sprintf)(localbuf, "%d", 0);
#endif
if(std::strlen(localbuf) < buf_size)
re_detail::strcpy_s(buf, buf_size, localbuf);
BOOST_REGEX_DETAIL_NS::strcpy_s(buf, buf_size, localbuf);
return std::strlen(localbuf) + 1;
}
if(code <= (int)REG_E_UNKNOWN)
@ -200,12 +200,12 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorA(int code, const regex_tA*
p = static_cast<c_regex_type*>(e->guts)->get_traits().error_string(static_cast< ::boost::regex_constants::error_type>(code));
else
{
p = re_detail::get_default_error_string(static_cast< ::boost::regex_constants::error_type>(code));
p = BOOST_REGEX_DETAIL_NS::get_default_error_string(static_cast< ::boost::regex_constants::error_type>(code));
}
std::size_t len = p.size();
if(len < buf_size)
{
re_detail::strcpy_s(buf, buf_size, p.c_str());
BOOST_REGEX_DETAIL_NS::strcpy_s(buf, buf_size, p.c_str());
}
return len + 1;
}

6
src/regex.cpp
View File

@ -64,7 +64,7 @@ regex_error::regex_error(const std::string& s, regex_constants::error_type err,
}
regex_error::regex_error(regex_constants::error_type err)
: std::runtime_error(::boost::re_detail::get_default_error_string(err))
: std::runtime_error(::boost::BOOST_REGEX_DETAIL_NS::get_default_error_string(err))
, m_error_code(err)
, m_position(0)
{
@ -83,7 +83,7 @@ void regex_error::raise()const
namespace re_detail{
namespace BOOST_REGEX_DETAIL_NS{
BOOST_REGEX_DECL void BOOST_REGEX_CALL raise_runtime_error(const std::runtime_error& ex)
{
@ -211,7 +211,7 @@ BOOST_REGEX_DECL void BOOST_REGEX_CALL put_mem_block(void* p)
#endif
} // namespace re_detail
} // namespace BOOST_REGEX_DETAIL_NS

2
src/regex_raw_buffer.cpp
View File

@ -32,7 +32,7 @@ namespace std{
#endif
namespace boost{ namespace re_detail{
namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
void BOOST_REGEX_CALL raw_storage::resize(size_type n)
{

4
src/regex_traits_defaults.cpp
View File

@ -36,7 +36,7 @@ namespace std{
#endif
namespace boost{ namespace re_detail{
namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
BOOST_REGEX_DECL const char* BOOST_REGEX_CALL get_default_syntax(regex_constants::syntax_type n)
{
@ -688,5 +688,5 @@ BOOST_REGEX_DECL regex_constants::syntax_type BOOST_REGEX_CALL get_default_synta
}
} // re_detail
} // BOOST_REGEX_DETAIL_NS
} // boost

14
src/w32_regex_traits.cpp
View File

@ -40,7 +40,7 @@ namespace std{
}
#endif
namespace boost{ namespace re_detail{
namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
#ifdef BOOST_NO_ANSI_APIS
UINT get_code_page_for_locale_id(lcid_type idx)
@ -63,12 +63,12 @@ void w32_regex_traits_char_layer<char>::init()
std::string cat_name(w32_regex_traits<char>::get_catalog_name());
if(cat_name.size())
{
cat = ::boost::re_detail::w32_cat_open(cat_name);
cat = ::boost::BOOST_REGEX_DETAIL_NS::w32_cat_open(cat_name);
if(!cat)
{
std::string m("Unable to open message catalog: ");
std::runtime_error err(m + cat_name);
::boost::re_detail::raise_runtime_error(err);
::boost::BOOST_REGEX_DETAIL_NS::raise_runtime_error(err);
}
}
//
@ -78,7 +78,7 @@ void w32_regex_traits_char_layer<char>::init()
{
for(regex_constants::syntax_type i = 1; i < regex_constants::syntax_max; ++i)
{
string_type mss = ::boost::re_detail::w32_cat_get(cat, this->m_locale, i, get_default_syntax(i));
string_type mss = ::boost::BOOST_REGEX_DETAIL_NS::w32_cat_get(cat, this->m_locale, i, get_default_syntax(i));
for(string_type::size_type j = 0; j < mss.size(); ++j)
{
m_char_map[static_cast<unsigned char>(mss[j])] = i;
@ -105,9 +105,9 @@ void w32_regex_traits_char_layer<char>::init()
{
if(m_char_map[i] == 0)
{
if(::boost::re_detail::w32_is(this->m_locale, 0x0002u, (char)i))
if(::boost::BOOST_REGEX_DETAIL_NS::w32_is(this->m_locale, 0x0002u, (char)i))
m_char_map[i] = regex_constants::escape_type_class;
else if(::boost::re_detail::w32_is(this->m_locale, 0x0001u, (char)i))
else if(::boost::BOOST_REGEX_DETAIL_NS::w32_is(this->m_locale, 0x0001u, (char)i))
m_char_map[i] = regex_constants::escape_type_not_class;
}
}while(0xFF != i++);
@ -645,7 +645,7 @@ BOOST_REGEX_DECL bool BOOST_REGEX_CALL w32_is(lcid_type idx, boost::uint32_t m,
#endif
#endif
} // re_detail
} // BOOST_REGEX_DETAIL_NS
} // boost
#endif

22
src/wc_regex_traits.cpp
View File

@ -117,7 +117,7 @@ c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::t
c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::transform_primary(const wchar_t* p1, const wchar_t* p2)
{
static wchar_t s_delim;
static const int s_collate_type = ::boost::re_detail::find_sort_syntax(static_cast<const c_regex_traits<wchar_t>*>(0), &s_delim);
static const int s_collate_type = ::boost::BOOST_REGEX_DETAIL_NS::find_sort_syntax(static_cast<const c_regex_traits<wchar_t>*>(0), &s_delim);
std::wstring result;
//
// What we do here depends upon the format of the sort key returned by
@ -125,8 +125,8 @@ c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::t
//
switch(s_collate_type)
{
case ::boost::re_detail::sort_C:
case ::boost::re_detail::sort_unknown:
case ::boost::BOOST_REGEX_DETAIL_NS::sort_C:
case ::boost::BOOST_REGEX_DETAIL_NS::sort_unknown:
// the best we can do is translate to lower case, then get a regular sort key:
{
result.assign(p1, p2);
@ -135,14 +135,14 @@ c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::t
result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());
break;
}
case ::boost::re_detail::sort_fixed:
case ::boost::BOOST_REGEX_DETAIL_NS::sort_fixed:
{
// get a regular sort key, and then truncate it:
result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());
result.erase(s_delim);
break;
}
case ::boost::re_detail::sort_delim:
case ::boost::BOOST_REGEX_DETAIL_NS::sort_delim:
// get a regular sort key, and then truncate everything after the delim:
result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());
if(result.size() && (result[0] == s_delim))
@ -189,13 +189,13 @@ c_regex_traits<wchar_t>::char_class_type BOOST_REGEX_CALL c_regex_traits<wchar_t
char_class_xdigit,
};
int idx = ::boost::re_detail::get_default_class_id(p1, p2);
int idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(p1, p2);
if(idx < 0)
{
std::wstring s(p1, p2);
for(std::wstring::size_type i = 0; i < s.size(); ++i)
s[i] = (std::towlower)(s[i]);
idx = ::boost::re_detail::get_default_class_id(&*s.begin(), &*s.begin() + s.size());
idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(&*s.begin(), &*s.begin() + s.size());
}
BOOST_ASSERT(idx+1 < static_cast<int>(sizeof(masks) / sizeof(masks[0])));
return masks[idx+1];
@ -213,11 +213,11 @@ bool BOOST_REGEX_CALL c_regex_traits<wchar_t>::isctype(wchar_t c, char_class_typ
|| ((mask & char_class_digit) && (std::iswdigit)(c))
|| ((mask & char_class_punct) && (std::iswpunct)(c))
|| ((mask & char_class_xdigit) && (std::iswxdigit)(c))
|| ((mask & char_class_blank) && (std::iswspace)(c) && !::boost::re_detail::is_separator(c))
|| ((mask & char_class_blank) && (std::iswspace)(c) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c))
|| ((mask & char_class_word) && (c == '_'))
|| ((mask & char_class_unicode) && (c & ~static_cast<wchar_t>(0xff)))
|| ((mask & char_class_vertical) && (::boost::re_detail::is_separator(c) || (c == L'\v')))
|| ((mask & char_class_horizontal) && (std::iswspace)(c) && !::boost::re_detail::is_separator(c) && (c != L'\v'));
|| ((mask & char_class_vertical) && (::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) || (c == L'\v')))
|| ((mask & char_class_horizontal) && (std::iswspace)(c) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) && (c != L'\v'));
}
c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::lookup_collatename(const wchar_t* p1, const wchar_t* p2)
@ -232,7 +232,7 @@ c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::l
while(p0 != p2)
name.append(1, char(*p0++));
#endif
name = ::boost::re_detail::lookup_default_collate_name(name);
name = ::boost::BOOST_REGEX_DETAIL_NS::lookup_default_collate_name(name);
#if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\
&& !BOOST_WORKAROUND(BOOST_MSVC, < 1300)\
&& !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)

4
src/wide_posix_api.cpp
View File

@ -218,12 +218,12 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int code, const regex_tW*
p = static_cast<wc_regex_type*>(e->guts)->get_traits().error_string(static_cast< ::boost::regex_constants::error_type>(code));
else
{
p = re_detail::get_default_error_string(static_cast< ::boost::regex_constants::error_type>(code));
p = BOOST_REGEX_DETAIL_NS::get_default_error_string(static_cast< ::boost::regex_constants::error_type>(code));
}
std::size_t len = p.size();
if(len < buf_size)
{
re_detail::copy(p.c_str(), p.c_str() + p.size() + 1, buf);
BOOST_REGEX_DETAIL_NS::copy(p.c_str(), p.c_str() + p.size() + 1, buf);
}
return len + 1;
}

10
test/collate_info/collate_info.cpp
View File

@ -150,24 +150,24 @@ void print_sort_syntax(const traits& pt, const char* name)
std::cout << "Sort Key Syntax for type " << name << ":\n";
typedef typename traits::char_type char_type;
char_type delim;
unsigned result = ::boost::re_detail::find_sort_syntax(&pt, &delim);
unsigned result = ::boost::BOOST_REGEX_DETAIL_NS::find_sort_syntax(&pt, &delim);
std::cout << " ";
switch(result)
{
case boost::re_detail::sort_C:
case boost::BOOST_REGEX_DETAIL_NS::sort_C:
std::cout << "sort_C";
break;
case boost::re_detail::sort_fixed:
case boost::BOOST_REGEX_DETAIL_NS::sort_fixed:
std::cout << "sort_fixed" << " " << static_cast<int>(delim);
break;
case boost::re_detail::sort_delim:
case boost::BOOST_REGEX_DETAIL_NS::sort_delim:
{
std::cout << "sort_delim" << " ";
std::basic_string<char_type> s(1, delim);
print_string(s);
}
break;
case boost::re_detail::sort_unknown:
case boost::BOOST_REGEX_DETAIL_NS::sort_unknown:
std::cout << "sort_unknown";
break;
default:

4
test/regress/test_icu.cpp
View File

@ -86,7 +86,7 @@ void compare_result(const MR1& w1, const MR2& w2, boost::mpl::int_<2> const*)
{
BOOST_REGEX_TEST_ERROR("Matched mismatch in match_results class", UChar32);
}
if((w1.position(i) != boost::re_detail::distance(iterator_type(w2.prefix().first), iterator_type(w2[i].first))) || (w1.length(i) != boost::re_detail::distance(iterator_type(w2[i].first), iterator_type(w2[i].second))))
if((w1.position(i) != boost::BOOST_REGEX_DETAIL_NS::distance(iterator_type(w2.prefix().first), iterator_type(w2[i].first))) || (w1.length(i) != boost::BOOST_REGEX_DETAIL_NS::distance(iterator_type(w2[i].first), iterator_type(w2[i].second))))
{
BOOST_REGEX_TEST_ERROR("Iterator mismatch in match_results class", UChar32);
}
@ -116,7 +116,7 @@ void compare_result(const MR1& w1, const MR2& w2, boost::mpl::int_<1> const*)
{
BOOST_REGEX_TEST_ERROR("Matched mismatch in match_results class", UChar32);
}
if((w1.position(i) != boost::re_detail::distance(iterator_type(w2.prefix().first), iterator_type(w2[i].first))) || (w1.length(i) != boost::re_detail::distance(iterator_type(w2[i].first), iterator_type(w2[i].second))))
if((w1.position(i) != boost::BOOST_REGEX_DETAIL_NS::distance(iterator_type(w2.prefix().first), iterator_type(w2[i].first))) || (w1.length(i) != boost::BOOST_REGEX_DETAIL_NS::distance(iterator_type(w2[i].first), iterator_type(w2[i].second))))
{
BOOST_REGEX_TEST_ERROR("Iterator mismatch in match_results class", UChar32);
}

16
test/regress/test_mfc.cpp
View File

@ -170,21 +170,21 @@ void test_mfc(const char&, const test_regex_search_tag&)
#pragma warning(push)
#pragma warning(disable:4244)
#endif
if(boost::re_detail::distance(s.GetString(), tstart2->first) != last_end2)
if(boost::BOOST_REGEX_DETAIL_NS::distance(s.GetString(), tstart2->first) != last_end2)
{
BOOST_REGEX_TEST_ERROR(
"Error in location of start of field split, found: "
<< boost::re_detail::distance(s.GetString(), tstart2->first)
<< boost::BOOST_REGEX_DETAIL_NS::distance(s.GetString(), tstart2->first)
<< ", expected: "
<< last_end2
<< ".", char);
}
int expected_end = static_cast<int>(answer_table[0] < 0 ? s.GetLength() : answer_table[0]);
if(boost::re_detail::distance(s.GetString(), tstart2->second) != expected_end)
if(boost::BOOST_REGEX_DETAIL_NS::distance(s.GetString(), tstart2->second) != expected_end)
{
BOOST_REGEX_TEST_ERROR(
"Error in location of end2 of field split, found: "
<< boost::re_detail::distance(s.GetString(), tstart2->second)
<< boost::BOOST_REGEX_DETAIL_NS::distance(s.GetString(), tstart2->second)
<< ", expected: "
<< expected_end
<< ".", char);
@ -348,21 +348,21 @@ void test_mfc(const wchar_t&, const test_regex_search_tag&)
#pragma warning(push)
#pragma warning(disable:4244)
#endif
if(boost::re_detail::distance(s.GetString(), tstart2->first) != last_end2)
if(boost::BOOST_REGEX_DETAIL_NS::distance(s.GetString(), tstart2->first) != last_end2)
{
BOOST_REGEX_TEST_ERROR(
"Error in location of start of field split, found: "
<< boost::re_detail::distance(s.GetString(), tstart2->first)
<< boost::BOOST_REGEX_DETAIL_NS::distance(s.GetString(), tstart2->first)
<< ", expected: "
<< last_end2
<< ".", wchar_t);
}
int expected_end = static_cast<int>(answer_table[0] < 0 ? s.GetLength() : answer_table[0]);
if(boost::re_detail::distance(s.GetString(), tstart2->second) != expected_end)
if(boost::BOOST_REGEX_DETAIL_NS::distance(s.GetString(), tstart2->second) != expected_end)
{
BOOST_REGEX_TEST_ERROR(
"Error in location of end2 of field split, found: "
<< boost::re_detail::distance(s.GetString(), tstart2->second)
<< boost::BOOST_REGEX_DETAIL_NS::distance(s.GetString(), tstart2->second)
<< ", expected: "
<< expected_end
<< ".", wchar_t);

16
test/regress/test_partial_match.hpp
View File

@ -47,18 +47,18 @@ void test_sub_match(const boost::sub_match<BidirectionalIterator>& sub, Bidirect
}
else
{
if(boost::re_detail::distance(base, sub.first) != answer_table[2*i])
if(boost::BOOST_REGEX_DETAIL_NS::distance(base, sub.first) != answer_table[2*i])
{
BOOST_REGEX_TEST_ERROR(
"Error in start location of sub-expression "
<< i << ", found " << boost::re_detail::distance(base, sub.first)
<< i << ", found " << boost::BOOST_REGEX_DETAIL_NS::distance(base, sub.first)
<< ", expected " << answer_table[2*i] << ".", charT);
}
if(boost::re_detail::distance(base, sub.second) != answer_table[1+ 2*i])
if(boost::BOOST_REGEX_DETAIL_NS::distance(base, sub.second) != answer_table[1+ 2*i])
{
BOOST_REGEX_TEST_ERROR(
"Error in end location of sub-expression "
<< i << ", found " << boost::re_detail::distance(base, sub.second)
<< i << ", found " << boost::BOOST_REGEX_DETAIL_NS::distance(base, sub.second)
<< ", expected " << answer_table[1 + 2*i] << ".", charT);
}
}
@ -238,21 +238,21 @@ void test_regex_token_iterator(boost::basic_regex<charT, traits>& r)
#pragma warning(push)
#pragma warning(disable:4244)
#endif
if(boost::re_detail::distance(search_text.begin(), start2->first) != last_end2)
if(boost::BOOST_REGEX_DETAIL_NS::distance(search_text.begin(), start2->first) != last_end2)
{
BOOST_REGEX_TEST_ERROR(
"Error in location of start of field split, found: "
<< boost::re_detail::distance(search_text.begin(), start2->first)
<< boost::BOOST_REGEX_DETAIL_NS::distance(search_text.begin(), start2->first)
<< ", expected: "
<< last_end2
<< ".", charT);
}
int expected_end = static_cast<int>(answer_table[0] < 0 ? search_text.size() : answer_table[0]);
if(boost::re_detail::distance(search_text.begin(), start2->second) != expected_end)
if(boost::BOOST_REGEX_DETAIL_NS::distance(search_text.begin(), start2->second) != expected_end)
{
BOOST_REGEX_TEST_ERROR(
"Error in location of end2 of field split, found: "
<< boost::re_detail::distance(search_text.begin(), start2->second)
<< boost::BOOST_REGEX_DETAIL_NS::distance(search_text.begin(), start2->second)
<< ", expected: "
<< expected_end
<< ".", charT);

24
test/regress/test_regex_search.hpp
View File

@ -55,18 +55,18 @@ void test_sub_match(const boost::sub_match<BidirectionalIterator>& sub, Bidirect
}
else
{
if(boost::re_detail::distance(base, sub.first) != answer_table[2*i])
if(boost::BOOST_REGEX_DETAIL_NS::distance(base, sub.first) != answer_table[2*i])
{
BOOST_REGEX_TEST_ERROR(
"Error in start location of sub-expression "
<< i << ", found " << boost::re_detail::distance(base, sub.first)
<< i << ", found " << boost::BOOST_REGEX_DETAIL_NS::distance(base, sub.first)
<< ", expected " << answer_table[2*i] << ".", charT);
}
if(boost::re_detail::distance(base, sub.second) != answer_table[1+ 2*i])
if(boost::BOOST_REGEX_DETAIL_NS::distance(base, sub.second) != answer_table[1+ 2*i])
{
BOOST_REGEX_TEST_ERROR(
"Error in end location of sub-expression "
<< i << ", found " << boost::re_detail::distance(base, sub.second)
<< i << ", found " << boost::BOOST_REGEX_DETAIL_NS::distance(base, sub.second)
<< ", expected " << answer_table[1 + 2*i] << ".", charT);
}
}
@ -291,21 +291,21 @@ void test_regex_token_iterator(boost::basic_regex<charT, traits>& r)
#pragma warning(push)
#pragma warning(disable:4244)
#endif
if(boost::re_detail::distance(search_text.begin(), start2->first) != last_end2)
if(boost::BOOST_REGEX_DETAIL_NS::distance(search_text.begin(), start2->first) != last_end2)
{
BOOST_REGEX_TEST_ERROR(
"Error in location of start of field split, found: "
<< boost::re_detail::distance(search_text.begin(), start2->first)
<< boost::BOOST_REGEX_DETAIL_NS::distance(search_text.begin(), start2->first)
<< ", expected: "
<< last_end2
<< ".", charT);
}
int expected_end = static_cast<int>(answer_table[0] < 0 ? search_text.size() : answer_table[0]);
if(boost::re_detail::distance(search_text.begin(), start2->second) != expected_end)
if(boost::BOOST_REGEX_DETAIL_NS::distance(search_text.begin(), start2->second) != expected_end)
{
BOOST_REGEX_TEST_ERROR(
"Error in location of end2 of field split, found: "
<< boost::re_detail::distance(search_text.begin(), start2->second)
<< boost::BOOST_REGEX_DETAIL_NS::distance(search_text.begin(), start2->second)
<< ", expected: "
<< expected_end
<< ".", charT);
@ -350,21 +350,21 @@ void test_regex_token_iterator(boost::basic_regex<charT, traits>& r)
#pragma warning(push)
#pragma warning(disable:4244)
#endif
if(boost::re_detail::distance(search_text.begin(), start2->first) != last_end2)
if(boost::BOOST_REGEX_DETAIL_NS::distance(search_text.begin(), start2->first) != last_end2)
{
BOOST_REGEX_TEST_ERROR(
"Error in location of start of field split, found: "
<< boost::re_detail::distance(search_text.begin(), start2->first)
<< boost::BOOST_REGEX_DETAIL_NS::distance(search_text.begin(), start2->first)
<< ", expected: "
<< last_end2
<< ".", charT);
}
int expected_end = static_cast<int>(answer_table[0] < 0 ? search_text.size() : answer_table[0]);
if(boost::re_detail::distance(search_text.begin(), start2->second) != expected_end)
if(boost::BOOST_REGEX_DETAIL_NS::distance(search_text.begin(), start2->second) != expected_end)
{
BOOST_REGEX_TEST_ERROR(
"Error in location of end2 of field split, found: "
<< boost::re_detail::distance(search_text.begin(), start2->second)
<< boost::BOOST_REGEX_DETAIL_NS::distance(search_text.begin(), start2->second)
<< ", expected: "
<< expected_end
<< ".", charT);

2
tools/generate/tables.cpp
View File

@ -75,7 +75,7 @@ void generate_code()
std::cout << "};\n\n";
// now the iterator table:
std::cout << "static const re_detail::character_pointer_range<" << g_char_type << "> range_data[] = {\n";
std::cout << "static const BOOST_REGEX_DETAIL_NS::character_pointer_range<" << g_char_type << "> range_data[] = {\n";
std::size_t index = 0;
for(i = g_table.begin(), j = g_table.end(); i != j; ++i)
{