+/*

+ *

+ * Copyright (c) 1998-2002

+ * John Maddock

+ *

+ * Use, modification and distribution are subject to the

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

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

+ *

+ */

+

+ /*

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

+ * FILE config.hpp

+ * VERSION see <boost/version.hpp>

+ * DESCRIPTION: regex extended config setup.

+ */

+

+#ifndef BOOST_REGEX_CONFIG_HPP

+#define BOOST_REGEX_CONFIG_HPP

+/*

+ * Borland C++ Fix/error check

+ * this has to go *before* we include any std lib headers:

+ */

+#if defined(__BORLANDC__)

+# include <boost/regex/config/borland.hpp>

+#endif

+

+/*****************************************************************************

+ *

+ * Include all the headers we need here:

+ *

+ ****************************************************************************/

+

+#ifdef __cplusplus

+

+# ifndef BOOST_REGEX_USER_CONFIG

+# define BOOST_REGEX_USER_CONFIG <boost/regex/user.hpp>

+# endif

+

+# include BOOST_REGEX_USER_CONFIG

+

+# include <boost/config.hpp>

+

+#else

+ /*

+ * C build,

+ * don't include <boost/config.hpp> because that may

+ * do C++ specific things in future...

+ */

+# include <stdlib.h>

+# include <stddef.h>

+# ifdef _MSC_VER

+# define BOOST_MSVC _MSC_VER

+# endif

+#endif

+

+/*****************************************************************************

+ *

+ * Boilerplate regex config options:

+ *

+ ****************************************************************************/

+

+/* Obsolete macro, use BOOST_VERSION instead: */

+#define BOOST_RE_VERSION 320

+

+/* fix: */

+#if defined(_UNICODE) && !defined(UNICODE)

+#define UNICODE

+#endif

+

+/*

+ * Fix for gcc prior to 3.4: std::ctype<wchar_t> doesn't allow

+ * masks to be combined, for example:

+ * std::use_facet<std::ctype<wchar_t> >.is(std::ctype_base::lower|std::ctype_base::upper, L'a');

+ * returns *false*.

+ */

+#ifdef __GLIBCPP__

+# define BOOST_REGEX_BUGGY_CTYPE_FACET

+#endif

+

+/*

+ * Intel C++ before 8.0 ends up with unresolved externals unless we turn off

+ * extern template support:

+ */

+#if defined(BOOST_INTEL) && defined(__cplusplus) && (BOOST_INTEL <= 800)

+# define BOOST_REGEX_NO_EXTERNAL_TEMPLATES

+#endif

+/*

+ * Visual C++ doesn't support external templates with C++ extensions turned off:

+ */

+#if defined(_MSC_VER) && !defined(_MSC_EXTENSIONS)

+# define BOOST_REGEX_NO_EXTERNAL_TEMPLATES

+#endif

+

+/*

+ * If there isn't good enough wide character support then there will

+ * be no wide character regular expressions:

+ */

+#if (defined(BOOST_NO_CWCHAR) || defined(BOOST_NO_CWCTYPE) || defined(BOOST_NO_STD_WSTRING))

+# if !defined(BOOST_NO_WREGEX)

+# define BOOST_NO_WREGEX

+# endif

+#else

+# if defined(__sgi) && (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))

+ /* STLPort on IRIX is misconfigured: <cwctype> does not compile

+ * as a temporary fix include <wctype.h> instead and prevent inclusion

+ * of STLPort version of <cwctype> */

+# include <wctype.h>

+# define __STLPORT_CWCTYPE

+# define _STLP_CWCTYPE

+# endif

+

+#ifdef __cplusplus

+# include <boost/regex/config/cwchar.hpp>

+#endif

+

+#endif

+

+/*

+ * If Win32 support has been disabled for boost in general, then

+ * it is for regex in particular:

+ */

+#if defined(BOOST_DISABLE_WIN32) && !defined(BOOST_REGEX_NO_W32)

+# define BOOST_REGEX_NO_W32

+#endif

+

+/* disable our own file-iterators and mapfiles if we can't

+ * support them: */

+#if !defined(BOOST_HAS_DIRENT_H) && !(defined(_WIN32) && !defined(BOOST_REGEX_NO_W32))

+# define BOOST_REGEX_NO_FILEITER

+#endif

+

+/* backwards compatibitity: */

+#if defined(BOOST_RE_NO_LIB)

+# define BOOST_REGEX_NO_LIB

+#endif

+

+#if defined(__GNUC__) && (defined(_WIN32) || defined(__CYGWIN__))

+/* gcc on win32 has problems if you include <windows.h>

+ (sporadically generates bad code). */

+# define BOOST_REGEX_NO_W32

+#endif

+#if defined(__COMO__) && !defined(BOOST_REGEX_NO_W32) && !defined(_MSC_EXTENSIONS)

+# define BOOST_REGEX_NO_W32

+#endif

+

+/*****************************************************************************

+ *

+ * Wide character workarounds:

+ *

+ ****************************************************************************/

+

+/*

+ * define BOOST_REGEX_HAS_OTHER_WCHAR_T when wchar_t is a native type, but the users

+ * code may be built with wchar_t as unsigned short: basically when we're building

+ * with MSVC and the /Zc:wchar_t option we place some extra unsigned short versions

+ * of the non-inline functions in the library, so that users can still link to the lib,

+ * irrespective of whether their own code is built with /Zc:wchar_t.

+ */

+#if defined(__cplusplus) && (defined(BOOST_MSVC) || defined(__ICL)) && !defined(BOOST_NO_INTRINSIC_WCHAR_T) && defined(BOOST_WINDOWS) && !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) && !defined(BOOST_RWSTD_VER)

+# define BOOST_REGEX_HAS_OTHER_WCHAR_T

+# ifdef BOOST_MSVC

+# pragma warning(push)

+# pragma warning(disable : 4251 4231 4660)

+# endif

+# ifdef _DLL

+# include <string>

+ extern template class __declspec(dllimport) std::basic_string<unsigned short>;

+# endif

+# ifdef BOOST_MSVC

+# pragma warning(pop)

+# endif

+#endif

+

+

+/*****************************************************************************

+ *

+ * Set up dll import/export options:

+ *

+ ****************************************************************************/

+

+#if defined(BOOST_HAS_DECLSPEC) && (defined(BOOST_REGEX_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)) && !defined(BOOST_REGEX_STATIC_LINK)

+# if defined(BOOST_REGEX_SOURCE)

+# define BOOST_REGEX_DECL __declspec(dllexport)

+# define BOOST_REGEX_BUILD_DLL

+# else

+# define BOOST_REGEX_DECL __declspec(dllimport)

+# endif

+#endif

+

+#ifndef BOOST_REGEX_DECL

+# define BOOST_REGEX_DECL

+#endif

+

+#if !defined(BOOST_REGEX_NO_LIB) && !defined(BOOST_REGEX_SOURCE) && !defined(BOOST_ALL_NO_LIB) && defined(__cplusplus)

+# define BOOST_LIB_NAME boost_regex

+# if defined(BOOST_REGEX_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)

+# define BOOST_DYN_LINK

+# endif

+# ifdef BOOST_REGEX_DIAG

+# define BOOST_LIB_DIAGNOSTIC

+# endif

+# include <boost/config/auto_link.hpp>

+#endif

+

+/*****************************************************************************

+ *

+ * Set up function call type:

+ *

+ ****************************************************************************/

+

+#if defined(BOOST_MSVC) && (BOOST_MSVC >= 1200) && defined(_MSC_EXTENSIONS)

+#if defined(_DEBUG) || defined(__MSVC_RUNTIME_CHECKS) || defined(_MANAGED)

+# define BOOST_REGEX_CALL __cdecl

+#else

+# define BOOST_REGEX_CALL __fastcall

+#endif

+# define BOOST_REGEX_CCALL __cdecl

+#endif

+

+#if defined(__BORLANDC__) && !defined(BOOST_DISABLE_WIN32)

+# define BOOST_REGEX_CALL __fastcall

+# define BOOST_REGEX_CCALL __stdcall

+#endif

+

+#ifndef BOOST_REGEX_CALL

+# define BOOST_REGEX_CALL

+#endif

+#ifndef BOOST_REGEX_CCALL

+#define BOOST_REGEX_CCALL

+#endif

+

+/*****************************************************************************

+ *

+ * Set up localisation model:

+ *

+ ****************************************************************************/

+

+/* backwards compatibility: */

+#ifdef BOOST_RE_LOCALE_C

+# define BOOST_REGEX_USE_C_LOCALE

+#endif

+

+#ifdef BOOST_RE_LOCALE_CPP

+# define BOOST_REGEX_USE_CPP_LOCALE

+#endif

+

+/* Win32 defaults to native Win32 locale: */

+#if defined(_WIN32) && !defined(BOOST_REGEX_USE_WIN32_LOCALE) && !defined(BOOST_REGEX_USE_C_LOCALE) && !defined(BOOST_REGEX_USE_CPP_LOCALE) && !defined(BOOST_REGEX_NO_W32)

+# define BOOST_REGEX_USE_WIN32_LOCALE

+#endif

+/* otherwise use C++ locale if supported: */

+#if !defined(BOOST_REGEX_USE_WIN32_LOCALE) && !defined(BOOST_REGEX_USE_C_LOCALE) && !defined(BOOST_REGEX_USE_CPP_LOCALE) && !defined(BOOST_NO_STD_LOCALE)

+# define BOOST_REGEX_USE_CPP_LOCALE

+#endif

+/* otherwise use C+ locale: */

+#if !defined(BOOST_REGEX_USE_WIN32_LOCALE) && !defined(BOOST_REGEX_USE_C_LOCALE) && !defined(BOOST_REGEX_USE_CPP_LOCALE)

+# define BOOST_REGEX_USE_C_LOCALE

+#endif

+

+#ifndef BOOST_REGEX_MAX_STATE_COUNT

+# define BOOST_REGEX_MAX_STATE_COUNT 100000000

+#endif

+

+

+/*****************************************************************************

+ *

+ * Error Handling for exception free compilers:

+ *

+ ****************************************************************************/

+

+#ifdef BOOST_NO_EXCEPTIONS

+/*

+ * If there are no exceptions then we must report critical-errors

+ * the only way we know how; by terminating.

+ */

+#include <stdexcept>

+#include <string>

+#include <boost/throw_exception.hpp>

+

+# define BOOST_REGEX_NOEH_ASSERT(x)\

+if(0 == (x))\

+{\

+ std::string s("Error: critical regex++ failure in: ");\

+ s.append(#x);\

+ std::runtime_error e(s);\

+ boost::throw_exception(e);\

+}

+#else

+/*

+ * With exceptions then error handling is taken care of and

+ * there is no need for these checks:

+ */

+# define BOOST_REGEX_NOEH_ASSERT(x)

+#endif

+

+

+/*****************************************************************************

+ *

+ * Stack protection under MS Windows:

+ *

+ ****************************************************************************/

+

+#if !defined(BOOST_REGEX_NO_W32) && !defined(BOOST_REGEX_V3)

+# if(defined(_WIN32) || defined(_WIN64) || defined(_WINCE)) \

+ && !defined(__GNUC__) \

+ && !(defined(__BORLANDC__) && (__BORLANDC__ >= 0x600)) \

+ && !(defined(__MWERKS__) && (__MWERKS__ <= 0x3003))

+# define BOOST_REGEX_HAS_MS_STACK_GUARD

+# endif

+#elif defined(BOOST_REGEX_HAS_MS_STACK_GUARD)

+# undef BOOST_REGEX_HAS_MS_STACK_GUARD

+#endif

+

+#if defined(__cplusplus) && defined(BOOST_REGEX_HAS_MS_STACK_GUARD)

+

+namespace boost{

+namespace re_detail{

+

+BOOST_REGEX_DECL void BOOST_REGEX_CALL reset_stack_guard_page();

+

+}

+}

+

+#endif

+

+

+/*****************************************************************************

+ *

+ * Algorithm selection and configuration:

+ *

+ ****************************************************************************/

+

+#if !defined(BOOST_REGEX_RECURSIVE) && !defined(BOOST_REGEX_NON_RECURSIVE)

+# if defined(BOOST_REGEX_HAS_MS_STACK_GUARD) && !defined(_STLP_DEBUG) && !defined(__STL_DEBUG) && !(defined(BOOST_MSVC) && (BOOST_MSVC >= 1400))

+# define BOOST_REGEX_RECURSIVE

+# else

+# define BOOST_REGEX_NON_RECURSIVE

+# endif

+#endif

+

+#ifdef BOOST_REGEX_NON_RECURSIVE

+# ifdef BOOST_REGEX_RECURSIVE

+# error "Can't set both BOOST_REGEX_RECURSIVE and BOOST_REGEX_NON_RECURSIVE"

+# endif

+# ifndef BOOST_REGEX_BLOCKSIZE

+# define BOOST_REGEX_BLOCKSIZE 4096

+# endif

+# if BOOST_REGEX_BLOCKSIZE < 512

+# error "BOOST_REGEX_BLOCKSIZE must be at least 512"

+# endif

+# ifndef BOOST_REGEX_MAX_BLOCKS

+# define BOOST_REGEX_MAX_BLOCKS 1024

+# endif

+# ifdef BOOST_REGEX_HAS_MS_STACK_GUARD

+# undef BOOST_REGEX_HAS_MS_STACK_GUARD

+# endif

+# ifndef BOOST_REGEX_MAX_CACHE_BLOCKS

+# define BOOST_REGEX_MAX_CACHE_BLOCKS 16

+# endif

+#endif

+

+

+/*****************************************************************************

+ *

+ * helper memory allocation functions:

+ *

+ ****************************************************************************/

+

+#if defined(__cplusplus) && defined(BOOST_REGEX_NON_RECURSIVE)

+namespace boost{ namespace re_detail{

+

+BOOST_REGEX_DECL void* BOOST_REGEX_CALL get_mem_block();

+BOOST_REGEX_DECL void BOOST_REGEX_CALL put_mem_block(void*);

+

+}} /* namespaces */

+#endif

+

+/*****************************************************************************

+ *

+ * Diagnostics:

+ *

+ ****************************************************************************/

+

+#ifdef BOOST_REGEX_CONFIG_INFO

+BOOST_REGEX_DECL void BOOST_REGEX_CALL print_regex_library_info();

+#endif

+

+#if defined(BOOST_REGEX_DIAG)

+# pragma message ("BOOST_REGEX_DECL" BOOST_STRINGIZE(=BOOST_REGEX_DECL))

+# pragma message ("BOOST_REGEX_CALL" BOOST_STRINGIZE(=BOOST_REGEX_CALL))

+# pragma message ("BOOST_REGEX_CCALL" BOOST_STRINGIZE(=BOOST_REGEX_CCALL))

+#ifdef BOOST_REGEX_USE_C_LOCALE

+# pragma message ("Using C locale in regex traits class")

+#elif BOOST_REGEX_USE_CPP_LOCALE

+# pragma message ("Using C++ locale in regex traits class")

+#else

+# pragma message ("Using Win32 locale in regex traits class")

+#endif

+#if defined(BOOST_REGEX_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)

+# pragma message ("Dynamic linking enabled")

+#endif

+#if defined(BOOST_REGEX_NO_LIB) || defined(BOOST_ALL_NO_LIB)

+# pragma message ("Auto-linking disabled")

+#endif

+#ifdef BOOST_REGEX_NO_EXTERNAL_TEMPLATES

+# pragma message ("Extern templates disabled")

+#endif

+

+#endif

+

+#endif

+

+

+

+

+/*

+ *

+ * Copyright (c) 1998-2002

+ * John Maddock

+ *

+ * Use, modification and distribution are subject to the

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

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

+ *

+ */

+

+ /*

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

+ * FILE boost/regex/config/borland.hpp

+ * VERSION see <boost/version.hpp>

+ * DESCRIPTION: regex borland-specific config setup.

+ */

+

+

+#if defined(__BORLANDC__)

+# if (__BORLANDC__ == 0x550) || (__BORLANDC__ == 0x551)

+ // problems with std::basic_string and dll RTL:

+# if defined(_RTLDLL) && defined(_RWSTD_COMPILE_INSTANTIATE)

+# ifdef BOOST_REGEX_BUILD_DLL

+# error _RWSTD_COMPILE_INSTANTIATE must not be defined when building regex++ as a DLL

+# else

+# pragma message("Defining _RWSTD_COMPILE_INSTANTIATE when linking to the DLL version of the RTL may produce memory corruption problems in std::basic_string, as a result of separate versions of basic_string's static data in the RTL and you're exe/dll: be warned!!")

+# endif

+# endif

+# ifndef _RTLDLL

+ // this is harmless for a staic link:

+# define _RWSTD_COMPILE_INSTANTIATE

+# endif

+ // external templates cause problems for some reason:

+# define BOOST_REGEX_NO_EXTERNAL_TEMPLATES

+# endif

+# if (__BORLANDC__ <= 0x540) && !defined(BOOST_REGEX_NO_LIB) && !defined(_NO_VCL)

+ // C++ Builder 4 and earlier, we can't tell whether we should be using

+ // the VCL runtime or not, do a static link instead:

+# define BOOST_REGEX_STATIC_LINK

+# endif

+ //

+ // VCL support:

+ // if we're building a console app then there can't be any VCL (can there?)

+# if !defined(__CONSOLE__) && !defined(_NO_VCL)

+# define BOOST_REGEX_USE_VCL

+# endif

+ //

+ // if this isn't Win32 then don't automatically select link

+ // libraries:

+ //

+# ifndef _Windows

+# ifndef BOOST_REGEX_NO_LIB

+# define BOOST_REGEX_NO_LIB

+# endif

+# ifndef BOOST_REGEX_STATIC_LINK

+# define BOOST_REGEX_STATIC_LINK

+# endif

+# endif

+

+#if __BORLANDC__ < 0x600

+//

+// string workarounds:

+//

+#include <cstring>

+#undef strcmp

+#undef strcpy

+#endif

+

+#endif

+

+

+/*

+ *

+ * Copyright (c) 1998-2002

+ * John Maddock

+ *

+ * Use, modification and distribution are subject to the

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

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

+ *

+ */

+

+ /*

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

+ * FILE boost/regex/config/cwchar.hpp

+ * VERSION see <boost/version.hpp>

+ * DESCRIPTION: regex wide character string fixes.

+ */

+

+#ifndef BOOST_REGEX_CONFIG_CWCHAR_HPP

+#define BOOST_REGEX_CONFIG_CWCHAR_HPP

+

+#include <cwchar>

+#include <cwctype>

+#include <boost/config.hpp>

+

+#if defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)

+// apparently this is required for the RW STL on Linux:

+#undef iswalnum

+#undef iswalpha

+#undef iswblank

+#undef iswcntrl

+#undef iswdigit

+#undef iswgraph

+#undef iswlower

+#undef iswprint

+#undef iswprint

+#undef iswpunct

+#undef iswspace

+#undef iswupper

+#undef iswxdigit

+#undef iswctype

+#undef towlower

+#undef towupper

+#undef towctrans

+#undef wctrans

+#undef wctype

+#endif

+

+namespace std{

+

+#ifndef BOOST_NO_STDC_NAMESPACE

+extern "C"{

+#endif

+

+#ifdef iswalnum

+inline int (iswalnum)(wint_t i)

+{ return iswalnum(i); }

+#undef iswalnum

+#elif defined(BOOST_NO_STDC_NAMESPACE)

+using ::iswalnum;

+#endif

+

+#ifdef iswalpha

+inline int (iswalpha)(wint_t i)

+{ return iswalpha(i); }

+#undef iswalpha

+#elif defined(BOOST_NO_STDC_NAMESPACE)

+using ::iswalpha;

+#endif

+

+#ifdef iswcntrl

+inline int (iswcntrl)(wint_t i)

+{ return iswcntrl(i); }

+#undef iswcntrl

+#elif defined(BOOST_NO_STDC_NAMESPACE)

+using ::iswcntrl;

+#endif

+

+#ifdef iswdigit

+inline int (iswdigit)(wint_t i)

+{ return iswdigit(i); }

+#undef iswdigit

+#elif defined(BOOST_NO_STDC_NAMESPACE)

+using ::iswdigit;

+#endif

+

+#ifdef iswgraph

+inline int (iswgraph)(wint_t i)

+{ return iswgraph(i); }

+#undef iswgraph

+#elif defined(BOOST_NO_STDC_NAMESPACE)

+using ::iswgraph;

+#endif

+

+#ifdef iswlower

+inline int (iswlower)(wint_t i)

+{ return iswlower(i); }

+#undef iswlower

+#elif defined(BOOST_NO_STDC_NAMESPACE)

+using ::iswlower;

+#endif

+

+#ifdef iswprint

+inline int (iswprint)(wint_t i)

+{ return iswprint(i); }

+#undef iswprint

+#elif defined(BOOST_NO_STDC_NAMESPACE)

+using ::iswprint;

+#endif

+

+#ifdef iswpunct

+inline int (iswpunct)(wint_t i)

+{ return iswpunct(i); }

+#undef iswpunct

+#elif defined(BOOST_NO_STDC_NAMESPACE)

+using ::iswpunct;

+#endif

+

+#ifdef iswspace

+inline int (iswspace)(wint_t i)

+{ return iswspace(i); }

+#undef iswspace

+#elif defined(BOOST_NO_STDC_NAMESPACE)

+using ::iswspace;

+#endif

+

+#ifdef iswupper

+inline int (iswupper)(wint_t i)

+{ return iswupper(i); }

+#undef iswupper

+#elif defined(BOOST_NO_STDC_NAMESPACE)

+using ::iswupper;

+#endif

+

+#ifdef iswxdigit

+inline int (iswxdigit)(wint_t i)

+{ return iswxdigit(i); }

+#undef iswxdigit

+#elif defined(BOOST_NO_STDC_NAMESPACE)

+using ::iswxdigit;

+#endif

+

+#ifdef towlower

+inline wint_t (towlower)(wint_t i)

+{ return towlower(i); }

+#undef towlower

+#elif defined(BOOST_NO_STDC_NAMESPACE)

+using ::towlower;

+#endif

+

+#ifdef towupper

+inline wint_t (towupper)(wint_t i)

+{ return towupper(i); }

+#undef towupper

+#elif defined(BOOST_NO_STDC_NAMESPACE)

+using :: towupper;

+#endif

+

+#ifdef wcscmp

+inline int (wcscmp)(const wchar_t *p1, const wchar_t *p2)

+{ return wcscmp(p1,p2); }

+#undef wcscmp

+#elif defined(BOOST_NO_STDC_NAMESPACE)

+using ::wcscmp;

+#endif

+

+#ifdef wcscoll

+inline int (wcscoll)(const wchar_t *p1, const wchar_t *p2)

+{ return wcscoll(p1,p2); }

+#undef wcscoll

+#elif defined(BOOST_NO_STDC_NAMESPACE) && !defined(UNDER_CE)

+using ::wcscoll;

+#endif

+

+#ifdef wcscpy

+inline wchar_t *(wcscpy)(wchar_t *p1, const wchar_t *p2)

+{ return wcscpy(p1,p2); }

+#undef wcscpy

+#elif defined(BOOST_NO_STDC_NAMESPACE)

+using ::wcscpy;

+#endif

+

+#ifdef wcslen

+inline size_t (wcslen)(const wchar_t *p)

+{ return wcslen(p); }

+#undef wcslen

+#elif defined(BOOST_NO_STDC_NAMESPACE)

+using ::wcslen;

+#endif

+

+#ifdef wcsxfrm

+size_t wcsxfrm(wchar_t *p1, const wchar_t *p2, size_t s)

+{ return wcsxfrm(p1,p2,s); }

+#undef wcsxfrm

+#elif defined(BOOST_NO_STDC_NAMESPACE)

+using ::wcsxfrm;

+#endif

+

+

+#ifndef BOOST_NO_STDC_NAMESPACE

+} // extern "C"

+#endif

+

+} // namespace std

+

+#endif

+

+/*

+ *

+ * Copyright (c) 2004

+ * John Maddock

+ *

+ * Use, modification and distribution are subject to the

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

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

+ *

+ */

+

+ /*

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

+ * FILE icu.hpp

+ * VERSION see <boost/version.hpp>

+ * DESCRIPTION: Unicode regular expressions on top of the ICU Library.

+ */

+

+#ifndef BOOST_REGEX_ICU_HPP

+#define BOOST_REGEX_ICU_HPP

+

+#include <unicode/utypes.h>

+#include <unicode/uchar.h>

+#include <unicode/coll.h>

+#include <boost/regex.hpp>

+#include <boost/regex/pending/unicode_iterator.hpp>

+#include <boost/mpl/int_fwd.hpp>

+#include <bitset>

+

+

+namespace boost{

+

+namespace re_detail{

+

+//

+// Implementation details:

+//

+class BOOST_REGEX_DECL icu_regex_traits_implementation

+{

+ typedef UChar32 char_type;

+ typedef std::size_t size_type;

+ typedef std::vector<char_type> string_type;

+ typedef U_NAMESPACE_QUALIFIER Locale locale_type;

+ typedef boost::uint_least32_t char_class_type;

+public:

+ icu_regex_traits_implementation(const U_NAMESPACE_QUALIFIER Locale& l)

+ : m_locale(l)

+ {

+ UErrorCode success = U_ZERO_ERROR;

+ m_collator.reset(U_NAMESPACE_QUALIFIER Collator::createInstance(l, success));

+ if(U_SUCCESS(success) == 0)

+ init_error();

+ m_collator->setStrength(U_NAMESPACE_QUALIFIER Collator::IDENTICAL);

+ success = U_ZERO_ERROR;

+ m_primary_collator.reset(U_NAMESPACE_QUALIFIER Collator::createInstance(l, success));

+ if(U_SUCCESS(success) == 0)

+ init_error();

+ m_primary_collator->setStrength(U_NAMESPACE_QUALIFIER Collator::PRIMARY);

+ }

+ U_NAMESPACE_QUALIFIER Locale getloc()const

+ {

+ return m_locale;

+ }

+ string_type do_transform(const char_type* p1, const char_type* p2, const U_NAMESPACE_QUALIFIER Collator* pcoll) const;

+ string_type transform(const char_type* p1, const char_type* p2) const

+ {

+ return do_transform(p1, p2, m_collator.get());

+ }

+ string_type transform_primary(const char_type* p1, const char_type* p2) const

+ {

+ return do_transform(p1, p2, m_primary_collator.get());

+ }

+private:

+ void init_error()

+ {

+ std::runtime_error e("Could not initialize ICU resources");

+ boost::throw_exception(e);

+ }

+ U_NAMESPACE_QUALIFIER Locale m_locale; // The ICU locale that we're using

+ boost::scoped_ptr< U_NAMESPACE_QUALIFIER Collator> m_collator; // The full collation object

+ boost::scoped_ptr< U_NAMESPACE_QUALIFIER Collator> m_primary_collator; // The primary collation object

+};

+

+inline boost::shared_ptr<icu_regex_traits_implementation> get_icu_regex_traits_implementation(const U_NAMESPACE_QUALIFIER Locale& loc)

+{

+ return boost::shared_ptr<icu_regex_traits_implementation>(new icu_regex_traits_implementation(loc));

+}

+

+}

+

+class BOOST_REGEX_DECL icu_regex_traits

+{

+public:

+ typedef UChar32 char_type;

+ typedef std::size_t size_type;

+ typedef std::vector<char_type> string_type;

+ typedef U_NAMESPACE_QUALIFIER Locale locale_type;

+#ifdef BOOST_NO_INT64_T

+ typedef std::bitset<64> char_class_type;

+#else

+ typedef boost::uint64_t char_class_type;

+#endif

+

+ struct boost_extensions_tag{};

+

+ icu_regex_traits()

+ : m_pimpl(re_detail::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;

+ }

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

+ }

+ char_type translate(char_type c) const

+ {

+ return c;

+ }

+ char_type translate_nocase(char_type c) const

+ {

+ return ::u_tolower(c);

+ }

+ char_type translate(char_type c, bool icase) const

+ {

+ return icase ? translate_nocase(c) : translate(c);

+ }

+ char_type tolower(char_type c) const

+ {

+ return ::u_tolower(c);

+ }

+ char_type toupper(char_type c) const

+ {

+ return ::u_toupper(c);

+ }

+ string_type transform(const char_type* p1, const char_type* p2) const

+ {

+ return m_pimpl->transform(p1, p2);

+ }

+ string_type transform_primary(const char_type* p1, const char_type* p2) const

+ {

+ return m_pimpl->transform_primary(p1, p2);

+ }

+ char_class_type lookup_classname(const char_type* p1, const char_type* p2) const;

+ string_type lookup_collatename(const char_type* p1, const char_type* p2) const;

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

+ }

+ int value(char_type c, int radix)const

+ {

+ return u_digit(c, static_cast< ::int8_t>(radix));

+ }

+ locale_type imbue(locale_type l)

+ {

+ locale_type result(m_pimpl->getloc());

+ m_pimpl = re_detail::get_icu_regex_traits_implementation(l);

+ return result;

+ }

+ locale_type getloc()const

+ {

+ return locale_type();

+ }

+ std::string error_string(::boost::regex_constants::error_type n) const

+ {

+ return re_detail::get_default_error_string(n);

+ }

+private:

+ icu_regex_traits(const icu_regex_traits&);

+ icu_regex_traits& operator=(const icu_regex_traits&);

+

+ //

+ // define the bitmasks offsets we need for additional character properties:

+ //

+ enum{

+ offset_blank = U_CHAR_CATEGORY_COUNT,

+ offset_space = U_CHAR_CATEGORY_COUNT+1,

+ offset_xdigit = U_CHAR_CATEGORY_COUNT+2,

+ offset_underscore = U_CHAR_CATEGORY_COUNT+3,

+ offset_unicode = U_CHAR_CATEGORY_COUNT+4,

+ offset_any = U_CHAR_CATEGORY_COUNT+5,

+ offset_ascii = U_CHAR_CATEGORY_COUNT+6

+ };

+

+ //

+ // and now the masks:

+ //

+ static const char_class_type mask_blank;

+ static const char_class_type mask_space;

+ static const char_class_type mask_xdigit;

+ static const char_class_type mask_underscore;

+ static const char_class_type mask_unicode;

+ static const char_class_type mask_any;

+ static const char_class_type mask_ascii;

+

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

+};

+

+} // namespace boost

+

+//

+// template instances:

+//

+#define BOOST_REGEX_CHAR_T UChar32

+#undef BOOST_REGEX_TRAITS_T

+#define BOOST_REGEX_TRAITS_T , icu_regex_traits

+#define BOOST_REGEX_ICU_INSTANCES

+#ifdef BOOST_REGEX_ICU_INSTANTIATE

+# define BOOST_REGEX_INSTANTIATE

+#endif

+#include <boost/regex/v4/instances.hpp>

+#undef BOOST_REGEX_CHAR_T

+#undef BOOST_REGEX_TRAITS_T

+#undef BOOST_REGEX_ICU_INSTANCES

+#ifdef BOOST_REGEX_INSTANTIATE

+# undef BOOST_REGEX_INSTANTIATE

+#endif

+

+namespace boost{

+

+// types:

+typedef basic_regex< ::UChar32, icu_regex_traits> u32regex;

+typedef match_results<const ::UChar32*> u32match;

+typedef match_results<const ::UChar*> u16match;

+

+//

+// Construction of 32-bit regex types from UTF-8 and UTF-16 primitives:

+//

+namespace re_detail{

+

+#if !defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(__IBMCPP__)

+template <class InputIterator>

+inline u32regex do_make_u32regex(InputIterator i,

+ InputIterator j,

+ boost::regex_constants::syntax_option_type opt,

+ const boost::mpl::int_<1>*)

+{

+ typedef boost::u8_to_u32_iterator<InputIterator, UChar32> conv_type;

+ return u32regex(conv_type(i), conv_type(j), opt);

+}

+

+template <class InputIterator>

+inline u32regex do_make_u32regex(InputIterator i,

+ InputIterator j,

+ boost::regex_constants::syntax_option_type opt,

+ const boost::mpl::int_<2>*)

+{

+ typedef boost::u16_to_u32_iterator<InputIterator, UChar32> conv_type;

+ return u32regex(conv_type(i), conv_type(j), opt);

+}

+

+template <class InputIterator>

+inline u32regex do_make_u32regex(InputIterator i,

+ InputIterator j,

+ boost::regex_constants::syntax_option_type opt,

+ const boost::mpl::int_<4>*)

+{

+ return u32regex(i, j, opt);

+}

+#else

+template <class InputIterator>

+inline u32regex do_make_u32regex(InputIterator i,

+ InputIterator j,

+ boost::regex_constants::syntax_option_type opt,

+ const boost::mpl::int_<1>*)

+{

+ typedef boost::u8_to_u32_iterator<InputIterator, UChar32> conv_type;

+ typedef std::vector<UChar32> vector_type;

+ vector_type v;

+ conv_type a(i), b(j);

+ while(a != b)

+ {

+ v.push_back(*a);

+ ++a;

+ }

+ if(v.size())

+ return u32regex(&*v.begin(), v.size(), opt);

+ return u32regex(static_cast<UChar32 const*>(0), static_cast<u32regex::size_type>(0), opt);

+}

+

+template <class InputIterator>

+inline u32regex do_make_u32regex(InputIterator i,

+ InputIterator j,

+ boost::regex_constants::syntax_option_type opt,

+ const boost::mpl::int_<2>*)

+{

+ typedef boost::u16_to_u32_iterator<InputIterator, UChar32> conv_type;

+ typedef std::vector<UChar32> vector_type;

+ vector_type v;

+ conv_type a(i), b(j);

+ while(a != b)

+ {

+ v.push_back(*a);

+ ++a;

+ }

+ if(v.size())

+ return u32regex(&*v.begin(), v.size(), opt);

+ return u32regex(static_cast<UChar32 const*>(0), static_cast<u32regex::size_type>(0), opt);

+}

+

+template <class InputIterator>

+inline u32regex do_make_u32regex(InputIterator i,

+ InputIterator j,

+ boost::regex_constants::syntax_option_type opt,

+ const boost::mpl::int_<4>*)

+{

+ typedef std::vector<UCHAR32> vector_type;

+ vector_type v;

+ while(i != j)

+ {

+ v.push_back((UCHAR32)(*i));

+ ++a;

+ }

+ if(v.size())

+ return u32regex(&*v.begin(), v.size(), opt);

+ return u32regex(static_cast<UChar32 const*>(0), static_cast<u32regex::size_type>(0), opt);

+}

+#endif

+}

+

+//

+// Construction from an iterator pair:

+//

+template <class InputIterator>

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

+}

+//

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

+}

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

+}

+//

+// construction from UTF-16 nul-terminated strings:

+//

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

+}

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

+}

+#endif

+//

+// construction from basic_string class-template:

+//

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

+}

+//

+// Construction from ICU string type:

+//

+inline u32regex make_u32regex(const 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));

+}

+

+//

+// regex_match overloads that widen the character type as appropriate:

+//

+namespace re_detail{

+template<class MR1, class MR2>

+void copy_results(MR1& out, MR2 const& in)

+{

+ // copy results from an adapted MR2 match_results:

+ out.set_size(in.size(), in.prefix().first.base(), in.suffix().second.base());

+ out.set_base(in.base().base());

+ for(int i = 0; i < (int)in.size(); ++i)

+ {

+ if(in[i].matched)

+ {

+ out.set_first(in[i].first.base(), i);

+ out.set_second(in[i].second.base(), i);

+ }

+ }

+}

+

+template <class BidiIterator, class Allocator>

+inline bool do_regex_match(BidiIterator first, BidiIterator last,

+ match_results<BidiIterator, Allocator>& m,

+ const u32regex& e,

+ match_flag_type flags,

+ boost::mpl::int_<4> const*)

+{

+ return ::boost::regex_match(first, last, m, e, flags);

+}

+template <class BidiIterator, class Allocator>

+bool do_regex_match(BidiIterator first, BidiIterator last,

+ match_results<BidiIterator, Allocator>& m,

+ const u32regex& e,

+ match_flag_type flags,

+ boost::mpl::int_<2> const*)

+{

+ typedef u16_to_u32_iterator<BidiIterator, UChar32> conv_type;

+ typedef match_results<conv_type> match_type;

+ typedef typename match_type::allocator_type alloc_type;

+ match_type what;

+ bool result = ::boost::regex_match(conv_type(first), conv_type(last), what, e, flags);

+ // copy results across to m:

+ if(result) copy_results(m, what);

+ return result;

+}

+template <class BidiIterator, class Allocator>

+bool do_regex_match(BidiIterator first, BidiIterator last,

+ match_results<BidiIterator, Allocator>& m,

+ const u32regex& e,

+ match_flag_type flags,

+ boost::mpl::int_<1> const*)

+{

+ typedef u8_to_u32_iterator<BidiIterator, UChar32> conv_type;

+ typedef match_results<conv_type> match_type;

+ typedef typename match_type::allocator_type alloc_type;

+ match_type what;

+ bool result = ::boost::regex_match(conv_type(first), conv_type(last), what, e, flags);

+ // copy results across to m:

+ if(result) copy_results(m, what);

+ return result;

+}

+} // namespace re_detail

+

+template <class BidiIterator, class Allocator>

+inline bool u32regex_match(BidiIterator first, BidiIterator last,

+ match_results<BidiIterator, Allocator>& m,

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

+}

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

+}

+#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)

+inline bool u32regex_match(const wchar_t* p,

+ match_results<const wchar_t*>& m,

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

+}

+#endif

+inline bool u32regex_match(const char* p,

+ match_results<const char*>& m,

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

+}

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

+}

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

+}

+#ifndef BOOST_NO_STD_WSTRING

+inline bool u32regex_match(const std::wstring& s,

+ match_results<std::wstring::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_<sizeof(wchar_t)> const*>(0));

+}

+#endif

+inline bool u32regex_match(const UnicodeString& s,

+ match_results<const UChar*>& m,

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

+}

+//

+// regex_match overloads that do not return what matched:

+//

+template <class BidiIterator>

+inline bool u32regex_match(BidiIterator first, BidiIterator last,

+ const u32regex& e,

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

+}

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

+}

+#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)

+inline bool u32regex_match(const wchar_t* p,

+ const u32regex& e,

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

+}

+#endif

+inline bool u32regex_match(const char* p,

+ const u32regex& e,

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

+}

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

+}

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

+}

+#ifndef BOOST_NO_STD_WSTRING

+inline bool u32regex_match(const std::wstring& s,

+ const u32regex& e,

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

+}

+#endif

+inline bool u32regex_match(const UnicodeString& s,

+ const u32regex& e,

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

+}

+

+//

+// regex_search overloads that widen the character type as appropriate:

+//

+namespace re_detail{

+template <class BidiIterator, class Allocator>

+inline bool do_regex_search(BidiIterator first, BidiIterator last,

+ match_results<BidiIterator, Allocator>& m,

+ const u32regex& e,

+ match_flag_type flags,

+ BidiIterator base,

+ boost::mpl::int_<4> const*)

+{

+ return ::boost::regex_search(first, last, m, e, flags, base);

+}

+template <class BidiIterator, class Allocator>

+bool do_regex_search(BidiIterator first, BidiIterator last,

+ match_results<BidiIterator, Allocator>& m,

+ const u32regex& e,

+ match_flag_type flags,

+ BidiIterator base,

+ boost::mpl::int_<2> const*)

+{

+ typedef u16_to_u32_iterator<BidiIterator, UChar32> conv_type;

+ typedef match_results<conv_type> match_type;

+ typedef typename match_type::allocator_type alloc_type;

+ match_type what;

+ bool result = ::boost::regex_search(conv_type(first), conv_type(last), what, e, flags, conv_type(base));

+ // copy results across to m:

+ if(result) copy_results(m, what);

+ return result;

+}

+template <class BidiIterator, class Allocator>

+bool do_regex_search(BidiIterator first, BidiIterator last,

+ match_results<BidiIterator, Allocator>& m,

+ const u32regex& e,

+ match_flag_type flags,

+ BidiIterator base,

+ boost::mpl::int_<1> const*)

+{

+ typedef u8_to_u32_iterator<BidiIterator, UChar32> conv_type;

+ typedef match_results<conv_type> match_type;

+ typedef typename match_type::allocator_type alloc_type;

+ match_type what;

+ bool result = ::boost::regex_search(conv_type(first), conv_type(last), what, e, flags, conv_type(base));

+ // copy results across to m:

+ if(result) copy_results(m, what);

+ return result;

+}

+}

+

+template <class BidiIterator, class Allocator>

+inline bool u32regex_search(BidiIterator first, BidiIterator last,

+ match_results<BidiIterator, Allocator>& m,

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

+}

+template <class BidiIterator, class Allocator>

+inline bool u32regex_search(BidiIterator first, BidiIterator last,

+ match_results<BidiIterator, Allocator>& m,

+ const u32regex& e,

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

+}

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

+}

+#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)

+inline bool u32regex_search(const wchar_t* p,

+ match_results<const wchar_t*>& m,

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

+}

+#endif

+inline bool u32regex_search(const char* p,

+ match_results<const char*>& m,

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

+}

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

+}

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

+}

+#ifndef BOOST_NO_STD_WSTRING

+inline bool u32regex_search(const std::wstring& s,

+ match_results<std::wstring::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_<sizeof(wchar_t)> const*>(0));

+}

+#endif

+inline bool u32regex_search(const UnicodeString& s,

+ match_results<const UChar*>& m,

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

+}

+template <class BidiIterator>

+inline bool u32regex_search(BidiIterator first, BidiIterator last,

+ const u32regex& e,

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

+}

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

+}

+#if !defined(U_WCHAR_IS_UTF16) && (U_SIZEOF_WCHAR_T != 2) && !defined(BOOST_NO_WREGEX)

+inline bool u32regex_search(const wchar_t* p,

+ const u32regex& e,

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

+}

+#endif

+inline bool u32regex_search(const char* p,

+ const u32regex& e,

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

+}

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

+}

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

+}

+#ifndef BOOST_NO_STD_WSTRING

+inline bool u32regex_search(const std::wstring& s,

+ const u32regex& e,

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

+}

+#endif

+inline bool u32regex_search(const UnicodeString& s,

+ const u32regex& e,

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

+}

+

+//

+// overloads for regex_replace with utf-8 and utf-16 data types:

+//

+namespace re_detail{

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

+{

+ return std::pair< boost::u8_to_u32_iterator<I>, boost::u8_to_u32_iterator<I> >(boost::u8_to_u32_iterator<I>(i), boost::u8_to_u32_iterator<I>(j));

+}

+template <class I>

+inline std::pair< boost::u16_to_u32_iterator<I>, boost::u16_to_u32_iterator<I> >

+ make_utf32_seq(I i, I j, mpl::int_<2> const*)

+{

+ return std::pair< boost::u16_to_u32_iterator<I>, boost::u16_to_u32_iterator<I> >(boost::u16_to_u32_iterator<I>(i), boost::u16_to_u32_iterator<I>(j));

+}

+template <class I>

+inline std::pair< I, I >

+ make_utf32_seq(I i, I j, mpl::int_<4> const*)

+{

+ return std::pair< I, I >(i, j);

+}

+template <class charT>

+inline std::pair< boost::u8_to_u32_iterator<const charT*>, boost::u8_to_u32_iterator<const charT*> >

+ make_utf32_seq(const charT* p, mpl::int_<1> const*)

+{

+ return std::pair< boost::u8_to_u32_iterator<const charT*>, boost::u8_to_u32_iterator<const charT*> >(boost::u8_to_u32_iterator<const charT*>(p), boost::u8_to_u32_iterator<const charT*>(p+std::strlen((const char*)p)));

+}

+template <class charT>

+inline std::pair< boost::u16_to_u32_iterator<const charT*>, boost::u16_to_u32_iterator<const charT*> >

+ make_utf32_seq(const charT* p, mpl::int_<2> const*)

+{

+ return std::pair< boost::u16_to_u32_iterator<const charT*>, boost::u16_to_u32_iterator<const charT*> >(boost::u16_to_u32_iterator<const charT*>(p), boost::u16_to_u32_iterator<const charT*>(p+u_strlen((const UChar*)p)));

+}

+template <class charT>

+inline std::pair< const charT*, const charT* >

+ make_utf32_seq(const charT* p, mpl::int_<4> const*)

+{

+ return std::pair< const charT*, const charT* >(p, p+icu_regex_traits::length((UChar32 const*)p));

+}

+template <class OutputIterator>

+inline OutputIterator make_utf32_out(OutputIterator o, mpl::int_<4> const*)

+{

+ return o;

+}

+template <class OutputIterator>

+inline utf16_output_iterator<OutputIterator> make_utf32_out(OutputIterator o, mpl::int_<2> const*)

+{

+ return o;

+}

+template <class OutputIterator>

+inline utf8_output_iterator<OutputIterator> make_utf32_out(OutputIterator o, mpl::int_<1> const*)

+{

+ return o;

+}

+

+template <class OutputIterator, class I1, class I2>

+OutputIterator do_regex_replace(OutputIterator out,

+ std::pair<I1, I1> const& in,

+ const u32regex& e,

+ const std::pair<I2, I2>& fmt,

+ match_flag_type flags

+ )

+{

+ // unfortunately we have to copy the format string in order to pass in onward:

+ std::vector<UChar32> f;

+#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS

+ f.assign(fmt.first, fmt.second);

+#else

+ f.clear();

+ I2 pos = fmt.first;

+ while(pos != fmt.second)

+ f.push_back(*pos++);

+#endif

+

+ regex_iterator<I1, UChar32, icu_regex_traits> i(in.first, in.second, e, flags);

+ regex_iterator<I1, UChar32, icu_regex_traits> j;

+ if(i == j)

+ {

+ if(!(flags & regex_constants::format_no_copy))

+ out = re_detail::copy(in.first, in.second, out);

+ }

+ else

+ {

+ I1 last_m = in.first;

+ while(i != j)

+ {

+ if(!(flags & regex_constants::format_no_copy))

+ out = re_detail::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());

+ else

+ out = ::boost::re_detail::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);

+ }

+ return out;

+}

+template <class BaseIterator>

+inline const BaseIterator& extract_output_base(const BaseIterator& b)

+{

+ return b;

+}

+template <class BaseIterator>

+inline BaseIterator extract_output_base(const utf8_output_iterator<BaseIterator>& b)

+{

+ return b.base();

+}

+template <class BaseIterator>

+inline BaseIterator extract_output_base(const utf16_output_iterator<BaseIterator>& b)

+{

+ return b.base();

+}

+} // re_detail

+

+template <class OutputIterator, class BidirectionalIterator, class charT>

+inline OutputIterator u32regex_replace(OutputIterator out,

+ BidirectionalIterator first,

+ BidirectionalIterator last,

+ const u32regex& e,

+ const charT* fmt,

+ match_flag_type flags = match_default)

+{

+ return re_detail::extract_output_base

+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)

+ <OutputIterator>

+#endif

+ (

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

+ e,

+ re_detail::make_utf32_seq(fmt, static_cast<mpl::int_<sizeof(*fmt)> const*>(0)),

+ flags)

+ );

+}

+

+template <class OutputIterator, class Iterator, class charT>

+inline OutputIterator u32regex_replace(OutputIterator out,

+ Iterator first,

+ Iterator last,

+ const u32regex& e,

+ const std::basic_string<charT>& fmt,

+ match_flag_type flags = match_default)

+{

+ return re_detail::extract_output_base

+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)

+ <OutputIterator>

+#endif

+ (

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

+ e,

+ re_detail::make_utf32_seq(fmt.begin(), fmt.end(), static_cast<mpl::int_<sizeof(charT)> const*>(0)),

+ flags)

+ );

+}

+

+template <class OutputIterator, class Iterator>

+inline OutputIterator u32regex_replace(OutputIterator out,

+ Iterator first,

+ Iterator last,

+ const u32regex& e,

+ const UnicodeString& fmt,

+ match_flag_type flags = match_default)

+{

+ return re_detail::extract_output_base

+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)

+ <OutputIterator>

+#endif

+ (

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

+ e,

+ re_detail::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast<mpl::int_<2> const*>(0)),

+ flags)

+ );

+}

+

+template <class charT>

+std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,

+ const u32regex& e,

+ const charT* fmt,

+ match_flag_type flags = match_default)

+{

+ std::basic_string<charT> result;

+ re_detail::string_out_iterator<std::basic_string<charT> > i(result);

+ u32regex_replace(i, s.begin(), s.end(), e, fmt, flags);

+ return result;

+}

+

+template <class charT>

+std::basic_string<charT> u32regex_replace(const std::basic_string<charT>& s,

+ const u32regex& e,

+ const std::basic_string<charT>& fmt,

+ match_flag_type flags = match_default)

+{

+ std::basic_string<charT> result;

+ re_detail::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{

+

+class unicode_string_out_iterator

+{

+ UnicodeString* out;

+public:

+ unicode_string_out_iterator(UnicodeString& s) : out(&s) {}

+ unicode_string_out_iterator& operator++() { return *this; }

+ unicode_string_out_iterator& operator++(int) { return *this; }

+ unicode_string_out_iterator& operator*() { return *this; }

+ unicode_string_out_iterator& operator=(UChar v)

+ {

+ *out += v;

+ return *this;

+ }

+ typedef std::ptrdiff_t difference_type;

+ typedef UChar value_type;

+ typedef value_type* pointer;

+ typedef value_type& reference;

+ typedef std::output_iterator_tag iterator_category;

+};

+

+}

+

+inline UnicodeString u32regex_replace(const UnicodeString& s,

+ const u32regex& e,

+ const UChar* fmt,

+ match_flag_type flags = match_default)

+{

+ UnicodeString result;

+ re_detail::unicode_string_out_iterator i(result);

+ u32regex_replace(i, s.getBuffer(), s.getBuffer()+s.length(), e, fmt, flags);

+ return result;

+}

+

+inline UnicodeString u32regex_replace(const UnicodeString& s,

+ const u32regex& e,

+ const UnicodeString& fmt,

+ match_flag_type flags = match_default)

+{

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

+ e,

+ re_detail::make_utf32_seq(fmt.getBuffer(), fmt.getBuffer() + fmt.length(), static_cast<mpl::int_<2> const*>(0)),

+ flags);

+ return result;

+}

+

+} // namespace boost.

+

+#include <boost/regex/v4/u32regex_iterator.hpp>

+#include <boost/regex/v4/u32regex_token_iterator.hpp>

+

+#endif

+/*

+ *

+ * Copyright (c) 1998-2002

+ * John Maddock

+ *

+ * Use, modification and distribution are subject to the

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

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

+ *

+ */

+

+ /*

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

+ * FILE pattern_except.hpp

+ * VERSION see <boost/version.hpp>

+ * DESCRIPTION: Declares pattern-matching exception classes.

+ */

+

+#ifndef BOOST_RE_PAT_EXCEPT_HPP

+#define BOOST_RE_PAT_EXCEPT_HPP

+

+#ifndef BOOST_REGEX_CONFIG_HPP

+#include <boost/regex/config.hpp>

+#endif

+

+#include <stdexcept>

+#include <cstddef>

+#include <boost/regex/v4/error_type.hpp>

+

+namespace boost{

+

+#ifdef BOOST_MSVC

+#pragma warning(push)

+#pragma warning(disable: 4103)

+#endif

+#ifdef BOOST_HAS_ABI_HEADERS

+# include BOOST_ABI_PREFIX

+#endif

+#ifdef BOOST_MSVC

+#pragma warning(pop)

+#endif

+

+#ifdef BOOST_MSVC

+#pragma warning(push)

+#pragma warning(disable : 4275)

+#endif

+class BOOST_REGEX_DECL regex_error : public std::runtime_error

+{

+public:

+ explicit regex_error(const std::string& s, regex_constants::error_type err = regex_constants::error_unknown, std::ptrdiff_t pos = 0);

+ explicit regex_error(regex_constants::error_type err);

+ ~regex_error() throw();

+ regex_constants::error_type code()const

+ { return m_error_code; }

+ std::ptrdiff_t position()const

+ { return m_position; }

+ void raise()const;

+private:

+ regex_constants::error_type m_error_code;

+ std::ptrdiff_t m_position;

+};

+

+typedef regex_error bad_pattern;

+typedef regex_error bad_expression;

+

+namespace re_detail{

+

+BOOST_REGEX_DECL void BOOST_REGEX_CALL raise_runtime_error(const std::runtime_error& ex);

+

+template <class traits>

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

+}

+

+}

+

+#ifdef BOOST_MSVC

+#pragma warning(pop)

+#endif

+

+#ifdef BOOST_MSVC

+#pragma warning(push)

+#pragma warning(disable: 4103)

+#endif

+#ifdef BOOST_HAS_ABI_HEADERS

+# include BOOST_ABI_SUFFIX

+#endif

+#ifdef BOOST_MSVC

+#pragma warning(pop)

+#endif

+

+} // namespace boost

+

+#endif

+

+

+

+/*

+ *

+ * Copyright (c) 2004

+ * John Maddock

+ *

+ * Use, modification and distribution are subject to the

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

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

+ *

+ */

+

+ /*

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

+ * FILE object_cache.hpp

+ * VERSION see <boost/version.hpp>

+ * DESCRIPTION: Implements a generic object cache.

+ */

+

+#ifndef BOOST_REGEX_OBJECT_CACHE_HPP

+#define BOOST_REGEX_OBJECT_CACHE_HPP

+

+#include <map>

+#include <list>

+#include <stdexcept>

+#include <string>

+#include <boost/config.hpp>

+#include <boost/shared_ptr.hpp>

+#ifdef BOOST_HAS_THREADS

+#include <boost/regex/pending/static_mutex.hpp>

+#endif

+

+namespace boost{

+

+template <class Key, class Object>

+class object_cache

+{

+public:

+ typedef std::pair< ::boost::shared_ptr<Object const>, Key const*> value_type;

+ typedef std::list<value_type> list_type;

+ typedef typename list_type::iterator list_iterator;

+ typedef std::map<Key, list_iterator> map_type;

+ typedef typename map_type::iterator map_iterator;

+ typedef typename list_type::size_type size_type;

+ static boost::shared_ptr<Object const> get(const Key& k, size_type max_cache_size);

+

+private:

+ static boost::shared_ptr<Object const> do_get(const Key& k, size_type max_cache_size);

+

+ struct data

+ {

+ list_type cont;

+ map_type index;

+ };

+

+ // Needed by compilers not implementing the resolution to DR45. For reference,

+ // see http://www.open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#45.

+ friend struct data;

+};

+

+template <class Key, class Object>

+boost::shared_ptr<Object const> object_cache<Key, Object>::get(const Key& k, size_type max_cache_size)

+{

+#ifdef BOOST_HAS_THREADS

+ static boost::static_mutex mut = BOOST_STATIC_MUTEX_INIT;

+

+ boost::static_mutex::scoped_lock l(mut);

+ if(l)

+ {

+ return do_get(k, max_cache_size);

+ }

+ //

+ // what do we do if the lock fails?

+ // for now just throw, but we should never really get here...

+ //

+ ::boost::throw_exception(std::runtime_error("Error in thread safety code: could not acquire a lock"));

+ return boost::shared_ptr<Object>();

+#else

+ return do_get(k, max_cache_size);

+#endif

+}

+

+template <class Key, class Object>

+boost::shared_ptr<Object const> object_cache<Key, Object>::do_get(const Key& k, size_type max_cache_size)

+{

+ typedef typename object_cache<Key, Object>::data object_data;

+ typedef typename map_type::size_type map_size_type;

+ static object_data s_data;

+

+ //

+ // see if the object is already in the cache:

+ //

+ map_iterator mpos = s_data.index.find(k);

+ if(mpos != s_data.index.end())

+ {

+ //

+ // Eureka!

+ // We have a cached item, bump it up the list and return it:

+ //

+ if(--(s_data.cont.end()) != mpos->second)

+ {

+ // splice out the item we want to move:

+ list_type temp;

+ temp.splice(temp.end(), s_data.cont, mpos->second);

+ // and now place it at the end of the list:

+ s_data.cont.splice(s_data.cont.end(), temp, temp.begin());

+ BOOST_ASSERT(*(s_data.cont.back().second) == k);

+ // update index with new position:

+ mpos->second = --(s_data.cont.end());

+ BOOST_ASSERT(&(mpos->first) == mpos->second->second);

+ BOOST_ASSERT(&(mpos->first) == s_data.cont.back().second);

+ }

+ return s_data.cont.back().first;

+ }

+ //

+ // if we get here then the item is not in the cache,

+ // so create it:

+ //

+ boost::shared_ptr<Object const> result(new Object(k));

+ //

+ // Add it to the list, and index it:

+ //

+ s_data.cont.push_back(value_type(result, static_cast<Key const*>(0)));

+ s_data.index.insert(std::make_pair(k, --(s_data.cont.end())));

+ s_data.cont.back().second = &(s_data.index.find(k)->first);

+ map_size_type s = s_data.index.size();

+ BOOST_ASSERT(s_data.index[k]->first.get() == result.get());

+ BOOST_ASSERT(&(s_data.index.find(k)->first) == s_data.cont.back().second);

+ BOOST_ASSERT(s_data.index.find(k)->first == k);

+ if(s > max_cache_size)

+ {

+ //

+ // We have too many items in the list, so we need to start

+ // popping them off the back of the list, but only if they're

+ // being held uniquely by us:

+ //

+ list_iterator pos = s_data.cont.begin();

+ list_iterator last = s_data.cont.end();

+ while((pos != last) && (s > max_cache_size))

+ {

+ if(pos->first.unique())

+ {

+ list_iterator condemmed(pos);

+ ++pos;

+ // now remove the items from our containers,

+ // then order has to be as follows:

+ BOOST_ASSERT(s_data.index.find(*(condemmed->second)) != s_data.index.end());

+ s_data.index.erase(*(condemmed->second));

+ s_data.cont.erase(condemmed);

+ --s;

+ }

+ else

+ --pos;

+ }

+ BOOST_ASSERT(s_data.index[k]->first.get() == result.get());

+ BOOST_ASSERT(&(s_data.index.find(k)->first) == s_data.cont.back().second);

+ BOOST_ASSERT(s_data.index.find(k)->first == k);

+ }

+ return result;

+}

+

+}

+

+#endif

+/*

+ *

+ * Copyright (c) 2004

+ * John Maddock

+ *

+ * Use, modification and distribution are subject to the

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

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

+ *

+ */

+

+ /*

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

+ * FILE static_mutex.hpp

+ * VERSION see <boost/version.hpp>

+ * DESCRIPTION: Declares static_mutex lock type, there are three different

+ * implementations: POSIX pthreads, WIN32 threads, and portable,

+ * these are described in more detail below.

+ */

+

+#ifndef BOOST_REGEX_STATIC_MUTEX_HPP

+#define BOOST_REGEX_STATIC_MUTEX_HPP

+

+#include <boost/config.hpp>

+#include <boost/regex/config.hpp> // dll import/export options.

+

+#ifdef BOOST_HAS_PTHREADS

+#include <pthread.h>

+#endif

+

+#if defined(BOOST_HAS_PTHREADS) && defined(PTHREAD_MUTEX_INITIALIZER)

+//

+// pthreads version:

+// simple wrap around a pthread_mutex_t initialized with

+// PTHREAD_MUTEX_INITIALIZER.

+//

+namespace boost{

+

+class BOOST_REGEX_DECL scoped_static_mutex_lock;

+

+class static_mutex

+{

+public:

+ typedef scoped_static_mutex_lock scoped_lock;

+ pthread_mutex_t m_mutex;

+};

+

+#define BOOST_STATIC_MUTEX_INIT { PTHREAD_MUTEX_INITIALIZER, }

+

+class BOOST_REGEX_DECL scoped_static_mutex_lock

+{

+public:

+ scoped_static_mutex_lock(static_mutex& mut, bool lk = true);

+ ~scoped_static_mutex_lock();

+ inline bool locked()const

+ {

+ return m_have_lock;

+ }

+ inline operator void const*()const

+ {

+ return locked() ? this : 0;

+ }

+ void lock();

+ void unlock();

+private:

+ static_mutex& m_mutex;

+ bool m_have_lock;

+};

+

+

+} // namespace boost

+#elif defined(BOOST_HAS_WINTHREADS)

+//

+// Win32 version:

+// Use a 32-bit int as a lock, along with a test-and-set

+// implementation using InterlockedCompareExchange.

+//

+

+#include <boost/cstdint.hpp>

+

+namespace boost{

+

+class BOOST_REGEX_DECL scoped_static_mutex_lock;

+

+class static_mutex

+{

+public:

+ typedef scoped_static_mutex_lock scoped_lock;

+ boost::int32_t m_mutex;

+};

+

+#define BOOST_STATIC_MUTEX_INIT { 0, }

+

+class BOOST_REGEX_DECL scoped_static_mutex_lock

+{

+public:

+ scoped_static_mutex_lock(static_mutex& mut, bool lk = true);

+ ~scoped_static_mutex_lock();

+ operator void const*()const;

+ bool locked()const;

+ void lock();

+ void unlock();

+private:

+ static_mutex& m_mutex;

+ bool m_have_lock;

+ scoped_static_mutex_lock(const scoped_static_mutex_lock&);

+ scoped_static_mutex_lock& operator=(const scoped_static_mutex_lock&);

+};

+

+inline scoped_static_mutex_lock::operator void const*()const

+{

+ return locked() ? this : 0;

+}

+

+inline bool scoped_static_mutex_lock::locked()const

+{

+ return m_have_lock;

+}

+

+} // namespace

+

+#else

+//

+// Portable version of a static mutex based on Boost.Thread library:

+// This has to use a single mutex shared by all instances of static_mutex

+// because boost::call_once doesn't alow us to pass instance information

+// down to the initialisation proceedure. In fact the initialisation routine

+// may need to be called more than once - but only once per instance.

+//

+// Since this preprocessor path is almost never taken, we hide these header

+// dependencies so that build tools don't find them.

+//

+#define B1 <boost/thread/once.hpp>

+#define B2 <boost/thread/recursive_mutex.hpp>

+#include B1

+#include B2

+#undef B1

+#undef B2

+

+namespace boost{

+

+class BOOST_REGEX_DECL scoped_static_mutex_lock;

+extern "C" BOOST_REGEX_DECL void free_static_mutex();

+

+class BOOST_REGEX_DECL static_mutex

+{

+public:

+ typedef scoped_static_mutex_lock scoped_lock;

+ static void init();

+ static boost::recursive_mutex* m_pmutex;

+ static boost::once_flag m_once;

+};

+

+#define BOOST_STATIC_MUTEX_INIT { }

+

+class BOOST_REGEX_DECL scoped_static_mutex_lock

+{

+public:

+ scoped_static_mutex_lock(static_mutex& mut, bool lk = true);

+ ~scoped_static_mutex_lock();

+ operator void const*()const;

+ bool locked()const;

+ void lock();

+ void unlock();

+private:

+ boost::recursive_mutex::scoped_lock* m_plock;

+ bool m_have_lock;

+};

+

+inline scoped_static_mutex_lock::operator void const*()const

+{

+ return locked() ? this : 0;

+}

+

+inline bool scoped_static_mutex_lock::locked()const

+{

+ return m_have_lock;

+}

+

+} // namespace

+

+#endif

+

+#endif

+/*

+ *

+ * Copyright (c) 2004

+ * John Maddock

+ *

+ * Use, modification and distribution are subject to the

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

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

+ *

+ */

+

+ /*

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

+ * FILE unicode_iterator.hpp

+ * VERSION see <boost/version.hpp>

+ * DESCRIPTION: Iterator adapters for converting between different Unicode encodings.

+ */

+

+/****************************************************************************

+

+Contents:

+~~~~~~~~~

+

+1) Read Only, Input Adapters:

+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+

+template <class BaseIterator, class U8Type = ::boost::uint8_t>

+class u32_to_u8_iterator;

+

+Adapts sequence of UTF-32 code points to "look like" a sequence of UTF-8.

+

+template <class BaseIterator, class U32Type = ::boost::uint32_t>

+class u8_to_u32_iterator;

+

+Adapts sequence of UTF-8 code points to "look like" a sequence of UTF-32.

+

+template <class BaseIterator, class U16Type = ::boost::uint16_t>

+class u32_to_u16_iterator;

+

+Adapts sequence of UTF-32 code points to "look like" a sequence of UTF-16.

+

+template <class BaseIterator, class U32Type = ::boost::uint32_t>

+class u16_to_u32_iterator;

+

+Adapts sequence of UTF-16 code points to "look like" a sequence of UTF-32.

+

+2) Single pass output iterator adapters:

+

+template <class BaseIterator>

+class utf8_output_iterator;

+

+Accepts UTF-32 code points and forwards them on as UTF-8 code points.

+

+template <class BaseIterator>

+class utf16_output_iterator;

+

+Accepts UTF-32 code points and forwards them on as UTF-16 code points.

+

+****************************************************************************/

+

+#ifndef BOOST_REGEX_UNICODE_ITERATOR_HPP

+#define BOOST_REGEX_UNICODE_ITERATOR_HPP

+#include <boost/cstdint.hpp>

+#include <boost/assert.hpp>

+#include <boost/iterator/iterator_facade.hpp>

+#include <boost/static_assert.hpp>

+#include <boost/throw_exception.hpp>

+#include <stdexcept>

+#ifndef BOOST_NO_STD_LOCALE

+#include <sstream>

+#include <ios>

+#endif

+#include <limits.h> // CHAR_BIT

+

+namespace boost{

+

+namespace detail{

+

+static const ::boost::uint16_t high_surrogate_base = 0xD7C0u;

+static const ::boost::uint16_t low_surrogate_base = 0xDC00u;

+static const ::boost::uint32_t ten_bit_mask = 0x3FFu;

+

+inline bool is_high_surrogate(::boost::uint16_t v)

+{

+ return (v & 0xFC00u) == 0xd800u;

+}

+inline bool is_low_surrogate(::boost::uint16_t v)

+{

+ return (v & 0xFC00u) == 0xdc00u;

+}

+template <class T>

+inline bool is_surrogate(T v)

+{

+ return (v & 0xF800u) == 0xd800;

+}

+

+inline unsigned utf8_byte_count(boost::uint8_t c)

+{

+ // if the most significant bit with a zero in it is in position

+ // 8-N then there are N bytes in this UTF-8 sequence:

+ boost::uint8_t mask = 0x80u;

+ unsigned result = 0;

+ while(c & mask)

+ {

+ ++result;

+ mask >>= 1;

+ }

+ return (result == 0) ? 1 : ((result > 4) ? 4 : result);

+}

+

+inline unsigned utf8_trailing_byte_count(boost::uint8_t c)

+{

+ return utf8_byte_count(c) - 1;

+}

+

+inline void invalid_utf32_code_point(::boost::uint32_t val)

+{

+#ifndef BOOST_NO_STD_LOCALE

+ std::stringstream ss;

+ ss << "Invalid UTF-32 code point U+" << std::showbase << std::hex << val << " encountered while trying to encode UTF-16 sequence";

+ std::out_of_range e(ss.str());

+#else

+ std::out_of_range e("Invalid UTF-32 code point encountered while trying to encode UTF-16 sequence");

+#endif

+ boost::throw_exception(e);

+}

+

+

+} // namespace detail

+

+template <class BaseIterator, class U16Type = ::boost::uint16_t>

+class u32_to_u16_iterator

+ : public boost::iterator_facade<u32_to_u16_iterator<BaseIterator, U16Type>, U16Type, std::bidirectional_iterator_tag, const U16Type>

+{

+ typedef boost::iterator_facade<u32_to_u16_iterator<BaseIterator, U16Type>, U16Type, std::bidirectional_iterator_tag, const U16Type> base_type;

+

+#if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

+ typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;

+

+ BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 32);

+ BOOST_STATIC_ASSERT(sizeof(U16Type)*CHAR_BIT == 16);

+#endif

+

+public:

+ typename base_type::reference

+ dereference()const

+ {

+ if(m_current == 2)

+ extract_current();

+ return m_values[m_current];

+ }

+ bool equal(const u32_to_u16_iterator& that)const

+ {

+ if(m_position == that.m_position)

+ {

+ // Both m_currents must be equal, or both even

+ // this is the same as saying their sum must be even:

+ return (m_current + that.m_current) & 1u ? false : true;

+ }

+ return false;

+ }

+ void increment()

+ {

+ // if we have a pending read then read now, so that we know whether

+ // to skip a position, or move to a low-surrogate:

+ if(m_current == 2)

+ {

+ // pending read:

+ extract_current();

+ }

+ // move to the next surrogate position:

+ ++m_current;

+ // if we've reached the end skip a position:

+ if(m_values[m_current] == 0)

+ {

+ m_current = 2;

+ ++m_position;

+ }

+ }

+ void decrement()

+ {

+ if(m_current != 1)

+ {

+ // decrementing an iterator always leads to a valid position:

+ --m_position;

+ extract_current();

+ m_current = m_values[1] ? 1 : 0;

+ }

+ else

+ {

+ m_current = 0;

+ }

+ }

+ BaseIterator base()const

+ {

+ return m_position;

+ }

+ // construct:

+ u32_to_u16_iterator() : m_position(), m_current(0)

+ {

+ m_values[0] = 0;

+ m_values[1] = 0;

+ m_values[2] = 0;

+ }

+ u32_to_u16_iterator(BaseIterator b) : m_position(b), m_current(2)

+ {

+ m_values[0] = 0;

+ m_values[1] = 0;

+ m_values[2] = 0;

+ }

+private:

+

+ void extract_current()const

+ {

+ // begin by checking for a code point out of range:

+ ::boost::uint32_t v = *m_position;

+ if(v >= 0x10000u)

+ {

+ if(v > 0x10FFFFu)

+ detail::invalid_utf32_code_point(*m_position);

+ // split into two surrogates:

+ m_values[0] = static_cast<U16Type>(v >> 10) + detail::high_surrogate_base;

+ m_values[1] = static_cast<U16Type>(v & detail::ten_bit_mask) + detail::low_surrogate_base;

+ m_current = 0;

+ BOOST_ASSERT(detail::is_high_surrogate(m_values[0]));

+ BOOST_ASSERT(detail::is_low_surrogate(m_values[1]));

+ }

+ else

+ {

+ // 16-bit code point:

+ m_values[0] = static_cast<U16Type>(*m_position);

+ m_values[1] = 0;

+ m_current = 0;

+ // value must not be a surrogate:

+ if(detail::is_surrogate(m_values[0]))

+ detail::invalid_utf32_code_point(*m_position);

+ }

+ }

+ BaseIterator m_position;

+ mutable U16Type m_values[3];

+ mutable unsigned m_current;

+};

+

+template <class BaseIterator, class U32Type = ::boost::uint32_t>

+class u16_to_u32_iterator

+ : public boost::iterator_facade<u16_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type>

+{

+ typedef boost::iterator_facade<u16_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type> base_type;

+ // special values for pending iterator reads:

+ BOOST_STATIC_CONSTANT(U32Type, pending_read = 0xffffffffu);

+

+#if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

+ typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;

+

+ BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 16);

+ BOOST_STATIC_ASSERT(sizeof(U32Type)*CHAR_BIT == 32);

+#endif

+

+public:

+ typename base_type::reference

+ dereference()const

+ {

+ if(m_value == pending_read)

+ extract_current();

+ return m_value;

+ }

+ bool equal(const u16_to_u32_iterator& that)const

+ {

+ return m_position == that.m_position;

+ }

+ void increment()

+ {

+ // skip high surrogate first if there is one:

+ if(detail::is_high_surrogate(*m_position)) ++m_position;

+ ++m_position;

+ m_value = pending_read;

+ }

+ void decrement()

+ {

+ --m_position;

+ // if we have a low surrogate then go back one more:

+ if(detail::is_low_surrogate(*m_position))

+ --m_position;

+ m_value = pending_read;

+ }

+ BaseIterator base()const

+ {

+ return m_position;

+ }

+ // construct:

+ u16_to_u32_iterator() : m_position()

+ {

+ m_value = pending_read;

+ }

+ u16_to_u32_iterator(BaseIterator b) : m_position(b)

+ {

+ m_value = pending_read;

+ }

+private:

+ static void invalid_code_point(::boost::uint16_t val)

+ {

+#ifndef BOOST_NO_STD_LOCALE

+ std::stringstream ss;

+ ss << "Misplaced UTF-16 surrogate U+" << std::showbase << std::hex << val << " encountered while trying to encode UTF-32 sequence";

+ std::out_of_range e(ss.str());

+#else

+ std::out_of_range e("Misplaced UTF-16 surrogate encountered while trying to encode UTF-32 sequence");

+#endif

+ boost::throw_exception(e);

+ }

+ void extract_current()const

+ {

+ m_value = static_cast<U32Type>(static_cast< ::boost::uint16_t>(*m_position));

+ // if the last value is a high surrogate then adjust m_position and m_value as needed:

+ if(detail::is_high_surrogate(*m_position))

+ {

+ // precondition; next value must have be a low-surrogate:

+ BaseIterator next(m_position);

+ ::boost::uint16_t t = *++next;

+ if((t & 0xFC00u) != 0xDC00u)

+ invalid_code_point(t);

+ m_value = (m_value - detail::high_surrogate_base) << 10;

+ m_value |= (static_cast<U32Type>(static_cast< ::boost::uint16_t>(t)) & detail::ten_bit_mask);

+ }

+ // postcondition; result must not be a surrogate:

+ if(detail::is_surrogate(m_value))

+ invalid_code_point(static_cast< ::boost::uint16_t>(m_value));

+ }

+ BaseIterator m_position;

+ mutable U32Type m_value;

+};

+

+template <class BaseIterator, class U8Type = ::boost::uint8_t>

+class u32_to_u8_iterator

+ : public boost::iterator_facade<u32_to_u8_iterator<BaseIterator, U8Type>, U8Type, std::bidirectional_iterator_tag, const U8Type>

+{

+ typedef boost::iterator_facade<u32_to_u8_iterator<BaseIterator, U8Type>, U8Type, std::bidirectional_iterator_tag, const U8Type> base_type;

+

+#if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

+ typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;

+

+ BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 32);

+ BOOST_STATIC_ASSERT(sizeof(U8Type)*CHAR_BIT == 8);

+#endif

+

+public:

+ typename base_type::reference

+ dereference()const

+ {

+ if(m_current == 4)

+ extract_current();

+ return m_values[m_current];

+ }

+ bool equal(const u32_to_u8_iterator& that)const

+ {

+ if(m_position == that.m_position)

+ {

+ // either the m_current's must be equal, or one must be 0 and

+ // the other 4: which means neither must have bits 1 or 2 set:

+ return (m_current == that.m_current)

+ || (((m_current | that.m_current) & 3) == 0);

+ }

+ return false;

+ }

+ void increment()

+ {

+ // if we have a pending read then read now, so that we know whether

+ // to skip a position, or move to a low-surrogate:

+ if(m_current == 4)

+ {

+ // pending read:

+ extract_current();

+ }

+ // move to the next surrogate position:

+ ++m_current;

+ // if we've reached the end skip a position:

+ if(m_values[m_current] == 0)

+ {

+ m_current = 4;

+ ++m_position;

+ }

+ }

+ void decrement()

+ {

+ if((m_current & 3) == 0)

+ {

+ --m_position;

+ extract_current();

+ m_current = 3;

+ while(m_current && (m_values[m_current] == 0))

+ --m_current;

+ }

+ else

+ --m_current;

+ }

+ BaseIterator base()const

+ {

+ return m_position;

+ }

+ // construct:

+ u32_to_u8_iterator() : m_position(), m_current(0)

+ {

+ m_values[0] = 0;

+ m_values[1] = 0;

+ m_values[2] = 0;

+ m_values[3] = 0;

+ m_values[4] = 0;

+ }

+ u32_to_u8_iterator(BaseIterator b) : m_position(b), m_current(4)

+ {

+ m_values[0] = 0;

+ m_values[1] = 0;

+ m_values[2] = 0;

+ m_values[3] = 0;

+ m_values[4] = 0;

+ }

+private:

+

+ void extract_current()const

+ {

+ boost::uint32_t c = *m_position;

+ if(c > 0x10FFFFu)

+ detail::invalid_utf32_code_point(c);

+ if(c < 0x80u)

+ {

+ m_values[0] = static_cast<unsigned char>(c);

+ m_values[1] = static_cast<unsigned char>(0u);

+ m_values[2] = static_cast<unsigned char>(0u);

+ m_values[3] = static_cast<unsigned char>(0u);

+ }

+ else if(c < 0x800u)

+ {

+ m_values[0] = static_cast<unsigned char>(0xC0u + (c >> 6));

+ m_values[1] = static_cast<unsigned char>(0x80u + (c & 0x3Fu));

+ m_values[2] = static_cast<unsigned char>(0u);

+ m_values[3] = static_cast<unsigned char>(0u);

+ }

+ else if(c < 0x10000u)

+ {

+ m_values[0] = static_cast<unsigned char>(0xE0u + (c >> 12));

+ m_values[1] = static_cast<unsigned char>(0x80u + ((c >> 6) & 0x3Fu));

+ m_values[2] = static_cast<unsigned char>(0x80u + (c & 0x3Fu));

+ m_values[3] = static_cast<unsigned char>(0u);

+ }

+ else

+ {

+ m_values[0] = static_cast<unsigned char>(0xF0u + (c >> 18));

+ m_values[1] = static_cast<unsigned char>(0x80u + ((c >> 12) & 0x3Fu));

+ m_values[2] = static_cast<unsigned char>(0x80u + ((c >> 6) & 0x3Fu));

+ m_values[3] = static_cast<unsigned char>(0x80u + (c & 0x3Fu));

+ }

+ m_current= 0;

+ }

+ BaseIterator m_position;

+ mutable U8Type m_values[5];

+ mutable unsigned m_current;

+};

+

+template <class BaseIterator, class U32Type = ::boost::uint32_t>

+class u8_to_u32_iterator

+ : public boost::iterator_facade<u8_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type>

+{

+ typedef boost::iterator_facade<u8_to_u32_iterator<BaseIterator, U32Type>, U32Type, std::bidirectional_iterator_tag, const U32Type> base_type;

+ // special values for pending iterator reads:

+ BOOST_STATIC_CONSTANT(U32Type, pending_read = 0xffffffffu);

+

+#if !defined(BOOST_NO_STD_ITERATOR_TRAITS) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)

+ typedef typename std::iterator_traits<BaseIterator>::value_type base_value_type;

+

+ BOOST_STATIC_ASSERT(sizeof(base_value_type)*CHAR_BIT == 8);

+ BOOST_STATIC_ASSERT(sizeof(U32Type)*CHAR_BIT == 32);

+#endif

+

+public:

+ typename base_type::reference

+ dereference()const

+ {

+ if(m_value == pending_read)

+ extract_current();

+ return m_value;

+ }

+ bool equal(const u8_to_u32_iterator& that)const

+ {

+ return m_position == that.m_position;

+ }

+ void increment()

+ {

+ // skip high surrogate first if there is one:

+ unsigned c = detail::utf8_byte_count(*m_position);

+ std::advance(m_position, c);

+ m_value = pending_read;

+ }

+ void decrement()

+ {

+ // Keep backtracking until we don't have a trailing character:

+ unsigned count = 0;

+ while((*--m_position & 0xC0u) == 0x80u) ++count;

+ // now check that the sequence was valid:

+ if(count != detail::utf8_trailing_byte_count(*m_position))

+ invalid_sequnce();

+ m_value = pending_read;

+ }

+ BaseIterator base()const

+ {

+ return m_position;

+ }

+ // construct:

+ u8_to_u32_iterator() : m_position()

+ {

+ m_value = pending_read;

+ }

+ u8_to_u32_iterator(BaseIterator b) : m_position(b)

+ {

+ m_value = pending_read;

+ }

+private:

+ static void invalid_sequnce()

+ {

+ std::out_of_range e("Invalid UTF-8 sequence encountered while trying to encode UTF-32 character");

+ boost::throw_exception(e);

+ }

+ void extract_current()const

+ {

+ m_value = static_cast<U32Type>(static_cast< ::boost::uint8_t>(*m_position));

+ // we must not have a continuation character:

+ if((m_value & 0xC0u) == 0x80u)

+ invalid_sequnce();

+ // see how many extra byts we have:

+ unsigned extra = detail::utf8_trailing_byte_count(*m_position);

+ // extract the extra bits, 6 from each extra byte:

+ BaseIterator next(m_position);

+ for(unsigned c = 0; c < extra; ++c)

+ {

+ ++next;

+ m_value <<= 6;

+ m_value += static_cast<boost::uint8_t>(*next) & 0x3Fu;

+ }

+ // we now need to remove a few of the leftmost bits, but how many depends

+ // upon how many extra bytes we've extracted:

+ static const boost::uint32_t masks[4] =

+ {

+ 0x7Fu,

+ 0x7FFu,

+ 0xFFFFu,

+ 0x1FFFFFu,

+ };

+ m_value &= masks[extra];

+ // check the result:

+ if(m_value > static_cast<U32Type>(0x10FFFFu))

+ invalid_sequnce();

+ }

+ BaseIterator m_position;

+ mutable U32Type m_value;

+};

+

+template <class BaseIterator>

+class utf16_output_iterator

+{

+public:

+ typedef void difference_type;

+ typedef void value_type;

+ typedef boost::uint32_t* pointer;

+ typedef boost::uint32_t& reference;

+ typedef std::output_iterator_tag iterator_category;

+

+ utf16_output_iterator(const BaseIterator& b)

+ : m_position(b){}

+ utf16_output_iterator(const utf16_output_iterator& that)

+ : m_position(that.m_position){}

+ utf16_output_iterator& operator=(const utf16_output_iterator& that)

+ {

+ m_position = that.m_position;

+ return *this;

+ }

+ const utf16_output_iterator& operator*()const

+ {

+ return *this;

+ }

+ void operator=(boost::uint32_t val)const

+ {

+ push(val);

+ }

+ utf16_output_iterator& operator++()

+ {

+ return *this;

+ }

+ utf16_output_iterator& operator++(int)

+ {

+ return *this;

+ }

+ BaseIterator base()const

+ {

+ return m_position;

+ }

+private:

+ void push(boost::uint32_t v)const

+ {

+ if(v >= 0x10000u)

+ {

+ // begin by checking for a code point out of range:

+ if(v > 0x10FFFFu)

+ detail::invalid_utf32_code_point(v);

+ // split into two surrogates:

+ *m_position++ = static_cast<boost::uint16_t>(v >> 10) + detail::high_surrogate_base;

+ *m_position++ = static_cast<boost::uint16_t>(v & detail::ten_bit_mask) + detail::low_surrogate_base;

+ }

+ else

+ {

+ // 16-bit code point:

+ // value must not be a surrogate:

+ if(detail::is_surrogate(v))

+ detail::invalid_utf32_code_point(v);

+ *m_position++ = static_cast<boost::uint16_t>(v);

+ }

+ }

+ mutable BaseIterator m_position;

+};

+

+template <class BaseIterator>

+class utf8_output_iterator

+{

+public:

+ typedef void difference_type;

+ typedef void value_type;

+ typedef boost::uint32_t* pointer;

+ typedef boost::uint32_t& reference;

+ typedef std::output_iterator_tag iterator_category;

+

+ utf8_output_iterator(const BaseIterator& b)

+ : m_position(b){}

+ utf8_output_iterator(const utf8_output_iterator& that)

+ : m_position(that.m_position){}

+ utf8_output_iterator& operator=(const utf8_output_iterator& that)

+ {

+ m_position = that.m_position;

+ return *this;

+ }

+ const utf8_output_iterator& operator*()const

+ {

+ return *this;

+ }

+ void operator=(boost::uint32_t val)const

+ {

+ push(val);

+ }

+ utf8_output_iterator& operator++()

+ {

+ return *this;

+ }

+ utf8_output_iterator& operator++(int)

+ {

+ return *this;

+ }

+ BaseIterator base()const

+ {

+ return m_position;

+ }

+private:

+ void push(boost::uint32_t c)const

+ {

+ if(c > 0x10FFFFu)

+ detail::invalid_utf32_code_point(c);

+ if(c < 0x80u)

+ {

+ *m_position++ = static_cast<unsigned char>(c);

+ }

+ else if(c < 0x800u)

+ {

+ *m_position++ = static_cast<unsigned char>(0xC0u + (c >> 6));

+ *m_position++ = static_cast<unsigned char>(0x80u + (c & 0x3Fu));

+ }

+ else if(c < 0x10000u)

+ {

+ *m_position++ = static_cast<unsigned char>(0xE0u + (c >> 12));

+ *m_position++ = static_cast<unsigned char>(0x80u + ((c >> 6) & 0x3Fu));

+ *m_position++ = static_cast<unsigned char>(0x80u + (c & 0x3Fu));

+ }

+ else

+ {

+ *m_position++ = static_cast<unsigned char>(0xF0u + (c >> 18));

+ *m_position++ = static_cast<unsigned char>(0x80u + ((c >> 12) & 0x3Fu));

+ *m_position++ = static_cast<unsigned char>(0x80u + ((c >> 6) & 0x3Fu));

+ *m_position++ = static_cast<unsigned char>(0x80u + (c & 0x3Fu));

+ }

+ }

+ mutable BaseIterator m_position;

+};

+

+} // namespace boost

+

+#endif // BOOST_REGEX_UNICODE_ITERATOR_HPP

+

+/*

+ *

+ * Copyright (c) 1998-2002

+ * John Maddock

+ *

+ * Use, modification and distribution are subject to the

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

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

+ *

+ */

+

+ /*

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

+ * FILE regex_traits.hpp

+ * VERSION see <boost/version.hpp>

+ * DESCRIPTION: Declares regular expression traits classes.

+ */

+

+#ifndef BOOST_REGEX_TRAITS_HPP

+#define BOOST_REGEX_TRAITS_HPP

+

+#ifndef BOOST_REGEX_CONFIG_HPP

+# include <boost/regex/config.hpp>

+#endif

+

+# ifndef BOOST_REGEX_TRAITS_HPP_INCLUDED

+# include <boost/regex/v4/regex_traits.hpp>

+# endif

+

+#endif // include

+

+

+

+

+

+/*

+ *

+ * Copyright (c) 1998-2002

+ * John Maddock

+ *

+ * Use, modification and distribution are subject to the

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

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

+ *

+ */

+

+ /*

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

+ * FILE user.hpp

+ * VERSION see <boost/version.hpp>

+ * DESCRIPTION: User settable options.

+ */

+

+// define if you want the regex library to use the C locale

+// even on Win32:

+// #define BOOST_REGEX_USE_C_LOCALE

+

+// define this is you want the regex library to use the C++

+// locale:

+// #define BOOST_REGEX_USE_CPP_LOCALE

+

+// define this if the runtime library is a dll, and you

+// want BOOST_REGEX_DYN_LINK to set up dll exports/imports

+// with __declspec(dllexport)/__declspec(dllimport.)

+// #define BOOST_REGEX_HAS_DLL_RUNTIME

+

+// define this if you want to dynamically link to regex,

+// if the runtime library is also a dll (Probably Win32 specific,

+// and has no effect unless BOOST_REGEX_HAS_DLL_RUNTIME is set):

+// #define BOOST_REGEX_DYN_LINK

+

+// define this if you don't want the lib to automatically

+// select its link libraries:

+// #define BOOST_REGEX_NO_LIB

+

+// define this if templates with switch statements cause problems:

+// #define BOOST_REGEX_NO_TEMPLATE_SWITCH_MERGE

+

+// define this to disable Win32 support when available:

+// #define BOOST_REGEX_NO_W32

+

+// define this if bool is not a real type:

+// #define BOOST_REGEX_NO_BOOL

+

+// define this if no template instances are to be placed in

+// the library rather than users object files:

+// #define BOOST_REGEX_NO_EXTERNAL_TEMPLATES

+

+// define this if the forward declarations in regex_fwd.hpp

+// cause more problems than they are worth:

+// #define BOOST_REGEX_NO_FWD

+

+// define this if your compiler supports MS Windows structured

+// exception handling.

+// #define BOOST_REGEX_HAS_MS_STACK_GUARD

+

+// define this if you want to use the recursive algorithm

+// even if BOOST_REGEX_HAS_MS_STACK_GUARD is not defined.

+// #define BOOST_REGEX_RECURSIVE

+

+// define this if you want to use the non-recursive

+// algorithm, even if the recursive version would be the default.

+// #define BOOST_REGEX_NON_RECURSIVE

+

+// define this if you want to set the size of the memory blocks

+// used by the non-recursive algorithm.

+// #define BOOST_REGEX_BLOCKSIZE 4096

+

+// define this if you want to set the maximum number of memory blocks

+// used by the non-recursive algorithm.

+// #define BOOST_REGEX_MAX_BLOCKS 1024

+

+// define this if you want to set the maximum number of memory blocks

+// cached by the non-recursive algorithm: Normally this is 16, but can be

+// higher if you have multiple threads all using boost.regex, or lower

+// if you don't want boost.regex to cache memory.

+// #define BOOST_REGEX_MAX_CACHE_BLOCKS 16

+

+// define this if you want to be able to access extended capture

+// information in your sub_match's (caution this will slow things

+// down quite a bit).

+// #define BOOST_REGEX_MATCH_EXTRA

+

+// define this if you want to enable support for Unicode via ICU.

+// #define BOOST_HAS_ICU

+/*

+ *

+ * Copyright (c) 1998-2004

+ * John Maddock

+ *

+ * Distributed under the Boost Software License, Version 1.0.

+ * (See accompanying file LICENSE_1_0.txt or copy at

+ * http://www.boost.org/LICENSE_1_0.txt)

+ *

+ */

+

+ /*

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

+ * FILE basic_regex.cpp

+ * VERSION see <boost/version.hpp>

+ * DESCRIPTION: Declares template class basic_regex.

+ */

+

+#ifndef BOOST_REGEX_V4_BASIC_REGEX_HPP

+#define BOOST_REGEX_V4_BASIC_REGEX_HPP

+

+#ifdef BOOST_MSVC

+#pragma warning(push)

+#pragma warning(disable: 4103)

+#endif

+#ifdef BOOST_HAS_ABI_HEADERS

+# include BOOST_ABI_PREFIX

+#endif

+#ifdef BOOST_MSVC

+#pragma warning(pop)

+#endif

+

+namespace boost{

+#ifdef BOOST_MSVC

+#pragma warning(push)

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

+#endif

+

+namespace re_detail{

+

+//

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

+//

+template <class charT, class traits>

+class basic_regex_parser;

+

+//

+// class regex_data:

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

+//

+template <class charT, class traits>

+struct regex_data

+{

+ typedef regex_constants::syntax_option_type flag_type;

+ typedef std::size_t size_type;

+

+ regex_data(const ::boost::shared_ptr<

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

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

+ regex_data()

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

+

+ ::boost::shared_ptr<

+ ::boost::regex_traits_wrapper<traits>

+ > m_ptraits; // traits class instance

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

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

+ const charT* m_expression; // the original expression

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

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

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

+ unsigned m_restart_type; // search optimisation type

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

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

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

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

+ std::vector<

+ std::pair<

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

+};

+//

+// class basic_regex_implementation

+// pimpl implementation class for basic_regex.

+//

+template <class charT, class traits>

+class basic_regex_implementation

+ : public regex_data<charT, traits>

+{

+public:

+ typedef regex_constants::syntax_option_type flag_type;

+ typedef std::ptrdiff_t difference_type;

+ typedef std::size_t size_type;

+ typedef typename traits::locale_type locale_type;

+ typedef const charT* const_iterator;

+

+ basic_regex_implementation(){}

+ basic_regex_implementation(const ::boost::shared_ptr<

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

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

+ void assign(const charT* arg_first,

+ const charT* arg_last,

+ flag_type f)

+ {

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

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

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

+ }

+

+ locale_type BOOST_REGEX_CALL imbue(locale_type l)

+ {

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

+ }

+ locale_type BOOST_REGEX_CALL getloc()const

+ {

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

+ }

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

+ {

+ std::basic_string<charT> result;

+ if(this->m_status == 0)

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

+ return result;

+ }

+ const_iterator BOOST_REGEX_CALL expression()const

+ {

+ return this->m_expression;

+ }

+ std::pair<const_iterator, const_iterator> BOOST_REGEX_CALL subexpression(std::size_t n)const

+ {

+ if(n == 0)

+ throw std::out_of_range("0 is not a valid subexpression index.");

+ const std::pair<std::size_t, std::size_t>& pi = this->m_subs.at(n - 1);

+ std::pair<const_iterator, const_iterator> p(expression() + pi.first, expression() + pi.second);

+ return p;

+ }

+ //

+ // begin, end:

+ const_iterator BOOST_REGEX_CALL begin()const

+ {

+ return (!this->m_status ? 0 : this->m_expression);

+ }

+ const_iterator BOOST_REGEX_CALL end()const

+ {

+ return (!this->m_status ? 0 : this->m_expression + this->m_expression_len);

+ }

+ flag_type BOOST_REGEX_CALL flags()const

+ {

+ return this->m_flags;

+ }

+ size_type BOOST_REGEX_CALL size()const

+ {

+ return this->m_expression_len;

+ }

+ int BOOST_REGEX_CALL status()const

+ {

+ return this->m_status;

+ }

+ size_type BOOST_REGEX_CALL mark_count()const

+ {

+ return this->m_mark_count;

+ }

+ const re_detail::re_syntax_base* get_first_state()const

+ {

+ return this->m_first_state;

+ }

+ unsigned get_restart_type()const

+ {

+ return this->m_restart_type;

+ }

+ const unsigned char* get_map()const

+ {

+ return this->m_startmap;

+ }

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

+ {

+ return *(this->m_ptraits);

+ }

+ bool can_be_null()const

+ {

+ return this->m_can_be_null;

+ }

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

+ {

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

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

+ }

+};

+

+} // namespace re_detail

+//

+// class basic_regex:

+// represents the compiled

+// regular expression:

+//

+

+#ifdef BOOST_REGEX_NO_FWD

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

+#else

+template <class charT, class traits >

+#endif

+class basic_regex : public regbase

+{

+public:

+ // typedefs:

+ typedef std::size_t traits_size_type;

+ typedef typename traits::string_type traits_string_type;

+ typedef charT char_type;

+ typedef traits traits_type;

+

+ typedef charT value_type;

+ typedef charT& reference;

+ typedef const charT& const_reference;

+ typedef const charT* const_iterator;

+ typedef const_iterator iterator;

+ typedef std::ptrdiff_t difference_type;

+ typedef std::size_t size_type;

+ typedef regex_constants::syntax_option_type flag_type;

+ // locale_type

+ // placeholder for actual locale type used by the

+ // traits class to localise *this.

+ typedef typename traits::locale_type locale_type;

+

+public:

+ explicit basic_regex(){}

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

+ {

+ assign(p, f);

+ }

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

+ {

+ assign(p1, p2, f);

+ }

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

+ {

+ assign(p, len, f);

+ }

+ basic_regex(const basic_regex& that)

+ : m_pimpl(that.m_pimpl) {}

+ ~basic_regex(){}

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

+ {

+ return assign(that);

+ }

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

+ {

+ return assign(ptr);

+ }

+

+ //

+ // assign:

+ basic_regex& assign(const basic_regex& that)

+ {

+ m_pimpl = that.m_pimpl;

+ return *this;

+ }

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

+ {

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

+ }

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

+ {

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

+ }

+private:

+ basic_regex& do_assign(const charT* p1,

+ const charT* p2,

+ flag_type f);

+public:

+ basic_regex& assign(const charT* p1,

+ const charT* p2,

+ flag_type f = regex_constants::normal)

+ {

+ return do_assign(p1, p2, f);

+ }

+#if !defined(BOOST_NO_MEMBER_TEMPLATES)

+

+ template <class ST, class SA>

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

+ {

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

+ }

+

+ template <class ST, class SA>

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

+ {

+ assign(p, f);

+ }

+

+ template <class InputIterator>

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

+ {

+ typedef typename traits::string_type seq_type;

+ seq_type a(arg_first, arg_last);

+ if(a.size())

+ assign(&*a.begin(), &*a.begin() + a.size(), f);

+ else

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

+ }

+

+ template <class ST, class SA>

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

+ {

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

+ }

+

+ template <class string_traits, class A>

+ basic_regex& BOOST_REGEX_CALL assign(

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

+ flag_type f = regex_constants::normal)

+ {

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

+ }

+

+ template <class InputIterator>

+ basic_regex& BOOST_REGEX_CALL assign(InputIterator arg_first,

+ InputIterator arg_last,

+ flag_type f = regex_constants::normal)

+ {

+ typedef typename traits::string_type seq_type;

+ seq_type a(arg_first, arg_last);

+ if(a.size())

+ {

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

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

+ return assign(p1, p2, f);

+ }

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

+ }

+#else

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

+ {

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

+ }

+

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

+ {

+ assign(p, f);

+ }

+

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

+ {

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

+ }

+

+ basic_regex& BOOST_REGEX_CALL assign(

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

+ flag_type f = regex_constants::normal)

+ {

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

+ }

+

+#endif

+

+ //

+ // locale:

+ locale_type BOOST_REGEX_CALL imbue(locale_type l);

+ locale_type BOOST_REGEX_CALL getloc()const

+ {

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

+ }

+ //

+ // getflags:

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

+ // is now the preferred name:

+ flag_type BOOST_REGEX_CALL getflags()const

+ {

+ return flags();

+ }

+ flag_type BOOST_REGEX_CALL flags()const

+ {

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

+ }

+ //

+ // str:

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

+ {

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

+ }

+ //

+ // begin, end, subexpression:

+ std::pair<const_iterator, const_iterator> BOOST_REGEX_CALL subexpression(std::size_t n)const

+ {

+ if(!m_pimpl.get())

+ throw std::logic_error("Can't access subexpressions in an invalid regex.");

+ return m_pimpl->subexpression(n);

+ }

+ const_iterator BOOST_REGEX_CALL begin()const

+ {

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

+ }

+ const_iterator BOOST_REGEX_CALL end()const

+ {

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

+ }

+ //

+ // swap:

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

+ {

+ m_pimpl.swap(that.m_pimpl);

+ }

+ //

+ // size:

+ size_type BOOST_REGEX_CALL size()const

+ {

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

+ }

+ //

+ // max_size:

+ size_type BOOST_REGEX_CALL max_size()const

+ {

+ return UINT_MAX;

+ }

+ //

+ // empty:

+ bool BOOST_REGEX_CALL empty()const

+ {

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

+ }

+

+ size_type BOOST_REGEX_CALL mark_count()const

+ {

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

+ }

+

+ int status()const

+ {

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

+ }

+

+ int BOOST_REGEX_CALL compare(const basic_regex& that) const

+ {

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

+ return 0;

+ if(!m_pimpl.get())

+ return -1;

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

+ return 1;

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

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

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

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

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

+ }

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

+ {

+ return compare(e) == 0;

+ }

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

+ {

+ return compare(e) != 0;

+ }

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

+ {

+ return compare(e) < 0;

+ }

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

+ {

+ return compare(e) > 0;

+ }

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

+ {

+ return compare(e) <= 0;

+ }

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

+ {

+ return compare(e) >= 0;

+ }

+

+ //

+ // The following are deprecated as public interfaces

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

+ const charT* BOOST_REGEX_CALL expression()const

+ {

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

+ }

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

+ {

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

+ return status();

+ }

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

+ {

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

+ return status();

+ }

+ unsigned int BOOST_REGEX_CALL error_code()const

+ {

+ return status();

+ }

+ //

+ // private access methods:

+ //

+ const re_detail::re_syntax_base* get_first_state()const

+ {

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

+ return m_pimpl->get_first_state();

+ }

+ unsigned get_restart_type()const

+ {

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

+ return m_pimpl->get_restart_type();

+ }

+ const unsigned char* get_map()const

+ {

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

+ return m_pimpl->get_map();

+ }

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

+ {

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

+ return m_pimpl->get_traits();

+ }

+ bool can_be_null()const

+ {

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

+ return m_pimpl->can_be_null();

+ }

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

+ {

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

+ return m_pimpl->get_data();

+ }

+

+private:

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

+};

+

+//

+// out of line members;

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

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

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

+//

+template <class charT, class traits>

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

+ const charT* p2,

+ flag_type f)

+{

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

+ if(!m_pimpl.get())

+ {

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

+ }

+ else

+ {

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

+ }

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

+ temp.swap(m_pimpl);

+ return *this;

+}

+

+template <class charT, class traits>

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

+{

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

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

+ temp.swap(m_pimpl);

+ return result;

+}

+

+//

+// non-members:

+//

+template <class charT, class traits>

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

+{

+ e1.swap(e2);

+}

+

+#ifndef BOOST_NO_STD_LOCALE

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

+std::basic_ostream<charT, traits>&

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

+ const basic_regex<charT, traits2>& e)

+{

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

+}

+#else

+template <class traits>

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

+{

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

+}

+#endif

+

+//

+// class reg_expression:

+// this is provided for backwards compatibility only,

+// it is deprecated, no not use!

+//

+#ifdef BOOST_REGEX_NO_FWD

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

+#else

+template <class charT, class traits >

+#endif

+class reg_expression : public basic_regex<charT, traits>

+{

+public:

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

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

+ explicit reg_expression(){}

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

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

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

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

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

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

+ reg_expression(const reg_expression& that)

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

+ ~reg_expression(){}

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

+ {

+ return this->assign(that);

+ }

+

+#if !defined(BOOST_NO_MEMBER_TEMPLATES)

+ template <class ST, class SA>

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

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

+ {

+ }

+

+ template <class InputIterator>

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

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

+ {

+ }

+

+ template <class ST, class SA>

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

+ {

+ this->assign(p);

+ return *this;

+ }

+#else

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

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

+ {

+ }

+

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

+ {

+ this->assign(p);

+ return *this;

+ }

+#endif

+

+};

+

+#ifdef BOOST_MSVC

+#pragma warning (pop)

+#endif

+

+} // namespace boost

+

+#ifdef BOOST_MSVC

+#pragma warning(push)

+#pragma warning(disable: 4103)

+#endif

+#ifdef BOOST_HAS_ABI_HEADERS

+# include BOOST_ABI_SUFFIX

+#endif

+#ifdef BOOST_MSVC

+#pragma warning(pop)

+#endif

+

+#endif

+

+/*

+ *

+ * Copyright (c) 2004

+ * John Maddock

+ *

+ * Use, modification and distribution are subject to the

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

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

+ *

+ */

+

+ /*

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

+ * FILE basic_regex_creator.cpp

+ * VERSION see <boost/version.hpp>

+ * DESCRIPTION: Declares template class basic_regex_creator which fills in

+ * the data members of a regex_data object.

+ */

+

+#ifndef BOOST_REGEX_V4_BASIC_REGEX_CREATOR_HPP

+#define BOOST_REGEX_V4_BASIC_REGEX_CREATOR_HPP

+

+#ifdef BOOST_MSVC

+#pragma warning(push)

+#pragma warning(disable: 4103)

+#endif

+#ifdef BOOST_HAS_ABI_HEADERS

+# include BOOST_ABI_PREFIX

+#endif

+#ifdef BOOST_MSVC

+#pragma warning(pop)

+#endif

+

+#ifdef BOOST_MSVC

+# pragma warning(push)

+# pragma warning(disable: 4800)

+#endif

+

+namespace boost{

+

+namespace re_detail{

+

+template <class charT>

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

+{

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

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

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

+ {}

+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)

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

+#endif

+ template <class Seq>

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

+ {

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

+ BOOST_ASSERT(s.size());

+ this->first = s[0];

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

+ }

+};

+

+template <class charT, class traits>

+class basic_char_set

+{

+public:

+ typedef digraph<charT> digraph_type;

+ typedef typename traits::string_type string_type;

+ typedef typename traits::char_class_type mask_type;

+

+ basic_char_set()

+ {

+ m_negate = false;

+ m_has_digraphs = false;

+ m_classes = 0;

+ m_negated_classes = 0;

+ m_empty = true;

+ }

+

+ void add_single(const digraph_type& s)

+ {

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

+ if(s.second)

+ m_has_digraphs = true;

+ m_empty = false;

+ }

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

+ {

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

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

+ if(first.second)

+ {

+ m_has_digraphs = true;

+ add_single(first);

+ }

+ if(end.second)

+ {

+ m_has_digraphs = true;

+ add_single(end);

+ }

+ m_empty = false;

+ }

+ void add_class(mask_type m)

+ {

+ m_classes |= m;

+ m_empty = false;

+ }

+ void add_negated_class(mask_type m)

+ {

+ m_negated_classes |= m;

+ m_empty = false;

+ }

+ void add_equivalent(const digraph_type& s)

+ {

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

+ if(s.second)

+ {

+ m_has_digraphs = true;

+ add_single(s);

+ }

+ m_empty = false;

+ }

+ void negate()

+ {

+ m_negate = true;

+ //m_empty = false;

+ }

+

+ //

+ // accessor functions:

+ //

+ bool has_digraphs()const

+ {

+ return m_has_digraphs;

+ }

+ bool is_negated()const

+ {

+ return m_negate;

+ }

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

+ list_iterator singles_begin()const

+ {

+ return m_singles.begin();

+ }

+ list_iterator singles_end()const

+ {

+ return m_singles.end();

+ }

+ list_iterator ranges_begin()const

+ {

+ return m_ranges.begin();

+ }

+ list_iterator ranges_end()const

+ {

+ return m_ranges.end();

+ }

+ list_iterator equivalents_begin()const

+ {

+ return m_equivalents.begin();

+ }

+ list_iterator equivalents_end()const

+ {

+ return m_equivalents.end();

+ }

+ mask_type classes()const

+ {

+ return m_classes;

+ }

+ mask_type negated_classes()const

+ {

+ return m_negated_classes;

+ }

+ bool empty()const

+ {

+ return m_empty;

+ }

+private:

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

+ std::vector<digraph_type> m_ranges; // a list of end points of our ranges

+ bool m_negate; // true if the set is to be negated

+ bool m_has_digraphs; // true if we have digraphs present

+ mask_type m_classes; // character classes to match

+ mask_type m_negated_classes; // negated character classes to match

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

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

+};

+

+template <class charT, class traits>

+class basic_regex_creator

+{

+public:

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

+ std::ptrdiff_t getoffset(void* addr)

+ {

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

+ }

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

+ {

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

+ }

+ re_syntax_base* getaddress(std::ptrdiff_t off)

+ {

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

+ }

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

+ {

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

+ }

+ void init(unsigned l_flags)

+ {

+ m_pdata->m_flags = l_flags;

+ m_icase = l_flags & regex_constants::icase;

+ }

+ regbase::flag_type flags()

+ {

+ return m_pdata->m_flags;

+ }

+ void flags(regbase::flag_type f)

+ {

+ m_pdata->m_flags = f;

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

+ {

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

+ }

+ }

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

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

+ re_literal* append_literal(charT c);

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

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

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

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

+protected:

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

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

+ m_traits; // convenience reference to traits class

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

+ bool m_icase; // true for case insensitive matches

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

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

+ unsigned m_backrefs; // bitmask of permitted backrefs

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

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

+ typename traits::char_class_type m_mask_space; // mask used to determine if a character is a word character

+ typename traits::char_class_type m_lower_mask; // mask used to determine if a character is a lowercase character

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

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

+private:

+ basic_regex_creator& operator=(const basic_regex_creator&);

+ basic_regex_creator(const basic_regex_creator&);

+

+ void fixup_pointers(re_syntax_base* state);

+ void create_startmaps(re_syntax_base* state);

+ int calculate_backstep(re_syntax_base* state);

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

+ unsigned get_restart_type(re_syntax_base* state);

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

+ bool is_bad_repeat(re_syntax_base* pt);

+ void set_bad_repeat(re_syntax_base* pt);

+ syntax_element_type get_repeat_type(re_syntax_base* state);

+ void probe_leading_repeat(re_syntax_base* state);

+};

+

+template <class charT, class traits>

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

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

+{

+ m_pdata->m_data.clear();

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

+ static const charT w = 'w';

+ static const charT s = 's';

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

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

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

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

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

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

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

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

+ m_pdata->m_word_mask = m_word_mask;

+ BOOST_ASSERT(m_word_mask != 0);

+ BOOST_ASSERT(m_mask_space != 0);

+ BOOST_ASSERT(m_lower_mask != 0);

+ BOOST_ASSERT(m_upper_mask != 0);

+ BOOST_ASSERT(m_alpha_mask != 0);

+}

+

+template <class charT, class traits>

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

+{

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

+ if(t == syntax_element_backref)

+ this->m_has_backrefs = true;

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

+ m_pdata->m_data.align();

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

+ if(m_last_state)

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

+ // now actually extent our data:

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

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

+ m_last_state->next.i = 0;

+ m_last_state->type = t;

+ return m_last_state;

+}

+

+template <class charT, class traits>

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

+{

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

+ m_pdata->m_data.align();

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

+ if(m_last_state)

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

+ // remember the last state position:

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

+ // now actually insert our data:

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

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

+ new_state->next.i = s;

+ new_state->type = t;

+ m_last_state = getaddress(off);

+ return new_state;

+}

+

+template <class charT, class traits>

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

+{

+ re_literal* result;

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

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

+ {

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

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

+ result->length = 1;

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

+ }

+ else

+ {

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

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

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

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

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

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

+ ++(result->length);

+ }

+ return result;

+}

+

+template <class charT, class traits>

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

+ const basic_char_set<charT, traits>& char_set)

+{

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

+ return char_set.has_digraphs()

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

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

+}

+

+template <class charT, class traits>

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

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

+{

+ typedef typename traits::string_type string_type;

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

+ typedef typename traits::char_class_type mask_type;

+

+ re_set_long<mask_type>* result = static_cast<re_set_long<mask_type>*>(append_state(syntax_element_long_set, sizeof(re_set_long<mask_type>)));

+ //

+ // fill in the basics:

+ //

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

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

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

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

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

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

+ {

+ // adjust classes as needed:

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

+ result->cclasses |= m_alpha_mask;

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

+ result->cnclasses |= m_alpha_mask;

+ }

+

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

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

+ //

+ // remember where the state is for later:

+ //

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

+ //

+ // now extend with all the singles:

+ //

+ item_iterator first, last;

+ first = char_set.singles_begin();

+ last = char_set.singles_end();

+ while(first != last)

+ {

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

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

+ if(first->second)

+ {

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

+ p[2] = 0;

+ }

+ else

+ p[1] = 0;

+ ++first;

+ }

+ //

+ // now extend with all the ranges:

+ //

+ first = char_set.ranges_begin();

+ last = char_set.ranges_end();

+ while(first != last)

+ {

+ // first grab the endpoints of the range:

+ digraph<charT> c1 = *first;

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

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

+ ++first;

+ digraph<charT> c2 = *first;

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

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

+ ++first;

+ string_type s1, s2;

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

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

+ {

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

+#if BOOST_WORKAROUND(__GNUC__, < 3)

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

+ in[0] = c1.first;

+ in[1] = c1.second;

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

+ in[0] = c2.first;

+ in[1] = c2.second;

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

+#else

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

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

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

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

+#endif

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

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

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

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

+ }

+ else

+ {

+ if(c1.second)

+ {

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

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

+ }

+ else

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

+ if(c2.second)

+ {

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

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

+ }

+ else

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

+ }

+ if(s1 > s2)

+ {

+ // Oops error:

+ return 0;

+ }

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

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

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

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

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

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

+ }

+ //

+ // now process the equivalence classes:

+ //

+ first = char_set.equivalents_begin();

+ last = char_set.equivalents_end();

+ while(first != last)

+ {

+ string_type s;

+ if(first->second)

+ {

+#if BOOST_WORKAROUND(__GNUC__, < 3)

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

+ in[0] = first->first;

+ in[1] = first->second;

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

+#else

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

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

+#endif

+ }

+ else

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

+ if(s.empty())

+ return 0; // invalid or unsupported equivalence class

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

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

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

+ ++first;

+ }

+ //

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

+ //

+ m_last_state = result = static_cast<re_set_long<mask_type>*>(getaddress(offset));

+ return result;

+}

+

+namespace{

+

+template<class T>

+inline bool char_less(T t1, T t2)

+{

+ return t1 < t2;

+}

+template<>

+inline bool char_less<char>(char t1, char t2)

+{

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

+}

+template<>

+inline bool char_less<signed char>(signed char t1, signed char t2)

+{

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

+}

+}

+

+template <class charT, class traits>

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

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

+{

+ typedef typename traits::string_type string_type;

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

+

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

+ bool negate = char_set.is_negated();

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

+ //

+ // handle singles first:

+ //

+ item_iterator first, last;

+ first = char_set.singles_begin();

+ last = char_set.singles_end();

+ while(first != last)

+ {

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

+ {

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

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

+ result->_map[i] = true;

+ }

+ ++first;

+ }

+ //

+ // OK now handle ranges:

+ //

+ first = char_set.ranges_begin();

+ last = char_set.ranges_end();

+ while(first != last)

+ {

+ // first grab the endpoints of the range:

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

+ ++first;

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

+ ++first;

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

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

+ {

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

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

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

+ c3[0] = c2;

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

+ if(s1 > s2)

+ {

+ // Oops error:

+ return 0;

+ }

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

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

+ {

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

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

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

+ result->_map[i] = true;

+ }

+ }

+ else

+ {

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

+ {

+ // Oops error:

+ return 0;

+ }

+ // everything in range matches:

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

+ }

+ }

+ //

+ // and now the classes:

+ //

+ typedef typename traits::char_class_type mask_type;

+ mask_type m = char_set.classes();

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

+ {

+ // adjust m as needed:

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

+ m |= m_alpha_mask;

+ }

+ if(m != 0)

+ {

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

+ {

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

+ result->_map[i] = true;

+ }

+ }

+ //

+ // and now the negated classes:

+ //

+ m = char_set.negated_classes();

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

+ {

+ // adjust m as needed:

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

+ m |= m_alpha_mask;

+ }

+ if(m != 0)

+ {

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

+ {

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

+ result->_map[i] = true;

+ }

+ }

+ //

+ // now process the equivalence classes:

+ //

+ first = char_set.equivalents_begin();

+ last = char_set.equivalents_end();

+ while(first != last)

+ {

+ string_type s;

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

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

+ if(s.empty())

+ return 0; // invalid or unsupported equivalence class

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

+ {

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

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

+ if(s == s2)

+ result->_map[i] = true;

+ }

+ ++first;

+ }

+ if(negate)

+ {

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

+ {

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

+ }

+ }

+ return result;

+}

+

+template <class charT, class traits>

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

+{

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

+ // start by adding a terminating state:

+ append_state(syntax_element_match);

+ // extend storage to store original expression:

+ std::ptrdiff_t len = p2 - p1;

+ m_pdata->m_expression_len = len;

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

+ m_pdata->m_expression = ps;

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

+ ps[p2 - p1] = 0;

+ // fill in our other data...

+ // successful parsing implies a zero status:

+ m_pdata->m_status = 0;

+ // get the first state of the machine:

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

+ // fixup pointers in the machine:

+ fixup_pointers(m_pdata->m_first_state);

+ // create nested startmaps:

+ create_startmaps(m_pdata->m_first_state);

+ // create main startmap:

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

+ m_pdata->m_can_be_null = 0;

+

+ m_bad_repeats = 0;

+ create_startmap(m_pdata->m_first_state, m_pdata->m_startmap, &(m_pdata->m_can_be_null), mask_all);

+ // get the restart type:

+ m_pdata->m_restart_type = get_restart_type(m_pdata->m_first_state);

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

+ probe_leading_repeat(m_pdata->m_first_state);

+}

+

+template <class charT, class traits>

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

+{

+ while(state)

+ {

+ switch(state->type)

+ {

+ case syntax_element_rep:

+ case syntax_element_dot_rep:

+ case syntax_element_char_rep:

+ case syntax_element_short_set_rep:

+ case syntax_element_long_set_rep:

+ // set the state_id of this repeat:

+ static_cast<re_repeat*>(state)->state_id = m_repeater_id++;

+ // fall through:

+ case syntax_element_alt:

+ std::memset(static_cast<re_alt*>(state)->_map, 0, sizeof(static_cast<re_alt*>(state)->_map));

+ static_cast<re_alt*>(state)->can_be_null = 0;

+ // fall through:

+ case syntax_element_jump:

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

+ // fall through again:

+ default:

+ if(state->next.i)

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

+ else

+ state->next.p = 0;

+ }

+ state = state->next.p;

+ }

+}

+

+template <class charT, class traits>

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

+{

+ // non-recursive implementation:

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

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

+ //

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

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

+

+ // start by saving the case setting:

+ bool l_icase = m_icase;

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

+

+ while(state)

+ {

+ switch(state->type)

+ {

+ case syntax_element_toggle_case:

+ // we need to track case changes here:

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

+ state = state->next.p;

+ continue;

+ case syntax_element_alt:

+ case syntax_element_rep:

+ case syntax_element_dot_rep:

+ case syntax_element_char_rep:

+ case syntax_element_short_set_rep:

+ case syntax_element_long_set_rep:

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

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

+ state = state->next.p;

+ break;

+ case syntax_element_backstep:

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

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

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

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

+ {

+ // Oops error:

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

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

+ //

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

+ //

+ this->m_pdata->m_expression = 0;

+ this->m_pdata->m_expression_len = 0;

+ //

+ // and throw if required:

+ //

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

+ {

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

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

+ e.raise();

+ }

+ }

+ // fall through:

+ default:

+ state = state->next.p;

+ }

+ }

+ // now work through our list, building all the maps as we go:

+ while(v.size())

+ {

+ const std::pair<bool, re_syntax_base*>& p = v.back();

+ m_icase = p.first;

+ state = p.second;

+ v.pop_back();

+

+ // Build maps:

+ m_bad_repeats = 0;

+ create_startmap(state->next.p, static_cast<re_alt*>(state)->_map, &static_cast<re_alt*>(state)->can_be_null, mask_take);

+ m_bad_repeats = 0;

+ create_startmap(static_cast<re_alt*>(state)->alt.p, static_cast<re_alt*>(state)->_map, &static_cast<re_alt*>(state)->can_be_null, mask_skip);

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

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

+ }

+ // restore case sensitivity:

+ m_icase = l_icase;

+}

+

+template <class charT, class traits>

+int basic_regex_creator<charT, traits>::calculate_backstep(re_syntax_base* state)

+{

+ typedef typename traits::char_class_type mask_type;

+ int result = 0;

+ while(state)

+ {

+ switch(state->type)

+ {

+ case syntax_element_startmark:

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

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

+ {

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

+ continue;

+ }

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

+ {

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

+ continue;

+ }

+ break;

+ case syntax_element_endmark:

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

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

+ return result;

+ break;

+ case syntax_element_literal:

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

+ break;

+ case syntax_element_wild:

+ case syntax_element_set:

+ result += 1;

+ break;

+ case syntax_element_dot_rep:

+ case syntax_element_char_rep:

+ case syntax_element_short_set_rep:

+ case syntax_element_backref:

+ case syntax_element_rep:

+ case syntax_element_combining:

+ case syntax_element_long_set_rep:

+ case syntax_element_backstep:

+ {

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

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

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

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

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

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

+ {

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

+ return -1;

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

+ state = rep->alt.p;

+ continue;

+ }

+ else if((state->type == syntax_element_long_set_rep))

+ {

+ BOOST_ASSERT(rep->next.p->type == syntax_element_long_set);

+ if(static_cast<re_set_long<mask_type>*>(rep->next.p)->singleton == 0)

+ return -1;

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

+ return -1;

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

+ state = rep->alt.p;

+ continue;

+ }

+ }

+ return -1;

+ case syntax_element_long_set:

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

+ return -1;

+ result += 1;

+ break;

+ case syntax_element_jump:

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

+ continue;

+ default:

+ break;

+ }

+ state = state->next.p;

+ }

+ return -1;

+}

+

+template <class charT, class traits>

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

+{

+ int not_last_jump = 1;

+

+ // track case sensitivity:

+ bool l_icase = m_icase;

+

+ while(state)

+ {

+ switch(state->type)

+ {

+ case syntax_element_toggle_case:

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

+ state = state->next.p;

+ break;

+ case syntax_element_literal:

+ {

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

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

+ if(l_map)

+ {

+ l_map[0] |= mask_init;

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

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

+ {

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

+ l_map[i] |= mask;

+ }

+ }

+ return;

+ }

+ case syntax_element_end_line:

+ {

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

+ if(l_map)

+ {

+ l_map[0] |= mask_init;

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

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

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

+ l_map[0x85] |= mask;

+ }

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

+ if(pnull)

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

+ return;

+ }

+ case syntax_element_backref:

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

+ if(pnull)

+ *pnull |= mask;

+ // fall through:

+ case syntax_element_wild:

+ {

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

+ set_all_masks(l_map, mask);

+ return;

+ }

+ case syntax_element_match:

+ {

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

+ set_all_masks(l_map, mask);

+ if(pnull)

+ *pnull |= mask;

+ return;

+ }

+ case syntax_element_word_start:

+ {

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

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

+ if(l_map)

+ {

+ l_map[0] |= mask_init;

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

+ {

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

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

+ }

+ }

+ return;

+ }

+ case syntax_element_word_end:

+ {

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

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

+ if(l_map)

+ {

+ l_map[0] |= mask_init;

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

+ {

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

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

+ }

+ }

+ return;

+ }

+ case syntax_element_buffer_end:

+ {

+ // we *must be null* :

+ if(pnull)

+ *pnull |= mask;

+ return;

+ }

+ case syntax_element_long_set:

+ if(l_map)

+ {

+ typedef typename traits::char_class_type mask_type;

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

+ {

+ l_map[0] |= mask_init;

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

+ {

+ charT c = static_cast<charT>(i);

+ if(&c != re_is_set_member(&c, &c + 1, static_cast<re_set_long<mask_type>*>(state), *m_pdata, m_icase))

+ l_map[i] |= mask;

+ }

+ }

+ else

+ set_all_masks(l_map, mask);

+ }

+ return;

+ case syntax_element_set:

+ if(l_map)

+ {

+ l_map[0] |= mask_init;

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

+ {

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

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

+ l_map[i] |= mask;

+ }

+ }

+ return;

+ case syntax_element_jump:

+ // take the jump:

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

+ not_last_jump = -1;

+ break;

+ case syntax_element_alt:

+ case syntax_element_rep:

+ case syntax_element_dot_rep:

+ case syntax_element_char_rep:

+ case syntax_element_short_set_rep:

+ case syntax_element_long_set_rep:

+ {

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

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

+ {

+ if(l_map)

+ {

+ // copy previous results:

+ l_map[0] |= mask_init;

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

+ {

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

+ l_map[i] |= mask;

+ }

+ }

+ if(pnull)

+ {

+ if(rep->can_be_null & mask_any)

+ *pnull |= mask;

+ }

+ }

+ else

+ {

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

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

+ if(is_bad_repeat(state))

+ {

+ set_all_masks(l_map, mask);

+ if(pnull)

+ *pnull |= mask;

+ return;

+ }

+ set_bad_repeat(state);

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

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

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

+ || (not_last_jump == 0))

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

+ }

+ }

+ return;

+ case syntax_element_soft_buffer_end:

+ // match newline or null:

+ if(l_map)

+ {

+ l_map[0] |= mask_init;

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

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

+ }

+ if(pnull)

+ *pnull |= mask;

+ return;

+ case syntax_element_endmark:

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

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

+ {

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

+ set_all_masks(l_map, mask);

+ if(pnull)

+ *pnull |= mask;

+ return;

+ }

+ else

+ {

+ state = state->next.p;

+ break;

+ }

+

+ case syntax_element_startmark:

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

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

+ {

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

+ break;

+ }

+ // otherwise fall through:

+ default:

+ state = state->next.p;

+ }

+ ++not_last_jump;

+ }

+}

+

+template <class charT, class traits>

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

+{

+ //

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

+ //

+ while(state)

+ {

+ switch(state->type)

+ {

+ case syntax_element_startmark:

+ case syntax_element_endmark:

+ state = state->next.p;

+ continue;

+ case syntax_element_start_line:

+ return regbase::restart_line;

+ case syntax_element_word_start:

+ return regbase::restart_word;

+ case syntax_element_buffer_start:

+ return regbase::restart_buf;

+ case syntax_element_restart_continue:

+ return regbase::restart_continue;

+ default:

+ state = 0;

+ continue;

+ }

+ }

+ return regbase::restart_any;

+}

+

+template <class charT, class traits>

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

+{

+ //

+ // set mask in all of bits elements,

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

+ // optimise this to a call to memset:

+ //

+ if(bits)

+ {

+ if(bits[0] == 0)

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

+ else

+ {

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

+ bits[i] |= mask;

+ }

+ bits[0] |= mask_init;

+ }

+}

+

+template <class charT, class traits>

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

+{

+ switch(pt->type)

+ {

+ case syntax_element_rep:

+ case syntax_element_dot_rep:

+ case syntax_element_char_rep:

+ case syntax_element_short_set_rep:

+ case syntax_element_long_set_rep:

+ {

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

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

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

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

+ return m_bad_repeats & (one << state_id);

+ }

+ default:

+ return false;

+ }

+}

+

+template <class charT, class traits>

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

+{

+ switch(pt->type)

+ {

+ case syntax_element_rep:

+ case syntax_element_dot_rep:

+ case syntax_element_char_rep:

+ case syntax_element_short_set_rep:

+ case syntax_element_long_set_rep:

+ {

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

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

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

+ m_bad_repeats |= (one << state_id);

+ }

+ default:

+ break;

+ }

+}

+

+template <class charT, class traits>

+syntax_element_type basic_regex_creator<charT, traits>::get_repeat_type(re_syntax_base* state)

+{

+ typedef typename traits::char_class_type mask_type;

+ if(state->type == syntax_element_rep)

+ {

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

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

+ {

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

+ {

+ case re_detail::syntax_element_wild:

+ return re_detail::syntax_element_dot_rep;

+ case re_detail::syntax_element_literal:

+ return re_detail::syntax_element_char_rep;

+ case re_detail::syntax_element_set:

+ return re_detail::syntax_element_short_set_rep;

+ case re_detail::syntax_element_long_set:

+ if(static_cast<re_detail::re_set_long<mask_type>*>(state->next.p)->singleton)

+ return re_detail::syntax_element_long_set_rep;

+ break;

+ default:

+ break;

+ }

+ }

+ }

+ return state->type;

+}

+

+template <class charT, class traits>

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

+{

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

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

+ do

+ {

+ switch(state->type)

+ {

+ case syntax_element_startmark:

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

+ {

+ state = state->next.p;

+ continue;

+ }

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

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

+ {

+ // skip past the zero width assertion:

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

+ continue;

+ }

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

+ {

+ // Have to skip the leading jump state:

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

+ continue;

+ }

+ return;

+ case syntax_element_endmark:

+ case syntax_element_start_line:

+ case syntax_element_end_line:

+ case syntax_element_word_boundary:

+ case syntax_element_within_word:

+ case syntax_element_word_start:

+ case syntax_element_word_end:

+ case syntax_element_buffer_start:

+ case syntax_element_buffer_end:

+ case syntax_element_restart_continue:

+ state = state->next.p;

+ break;

+ case syntax_element_dot_rep:

+ case syntax_element_char_rep:

+ case syntax_element_short_set_rep:

+ case syntax_element_long_set_rep:

+ if(this->m_has_backrefs == 0)

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

+ // fall through:

+ default:

+ return;

+ }

+ }while(state);

+}

+

+

+} // namespace re_detail

+

+} // namespace boost

+

+#ifdef BOOST_MSVC

+# pragma warning(pop)

+#endif

+

+#ifdef BOOST_MSVC

+#pragma warning(push)

+#pragma warning(disable: 4103)

+#endif

+#ifdef BOOST_HAS_ABI_HEADERS

+# include BOOST_ABI_SUFFIX

+#endif

+#ifdef BOOST_MSVC

+#pragma warning(pop)

+#endif

+

+#endif

+/*

+ *

+ * Copyright (c) 2004

+ * John Maddock

+ *

+ * Use, modification and distribution are subject to the

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

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

+ *

+ */

+

+ /*

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

+ * FILE basic_regex_parser.cpp

+ * VERSION see <boost/version.hpp>

+ * DESCRIPTION: Declares template class basic_regex_parser.

+ */

+

+#ifndef BOOST_REGEX_V4_BASIC_REGEX_PARSER_HPP

+#define BOOST_REGEX_V4_BASIC_REGEX_PARSER_HPP

+

+#ifdef BOOST_MSVC

+#pragma warning(push)

+#pragma warning(disable: 4103)

+#endif

+#ifdef BOOST_HAS_ABI_HEADERS

+# include BOOST_ABI_PREFIX

+#endif

+#ifdef BOOST_MSVC

+#pragma warning(pop)

+#endif

+

+namespace boost{

+namespace re_detail{

+

+#ifdef BOOST_MSVC

+#pragma warning(push)

+#pragma warning(disable:4244 4800)

+#endif

+

+template <class charT, class traits>

+class basic_regex_parser : public basic_regex_creator<charT, traits>

+{

+public:

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

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

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

+

+ bool parse_all();

+ bool parse_basic();

+ bool parse_extended();

+ bool parse_literal();

+ bool parse_open_paren();

+ bool parse_basic_escape();

+ bool parse_extended_escape();

+ bool parse_match_any();

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

+ bool parse_repeat_range(bool isbasic);

+ bool parse_alt();

+ bool parse_set();

+ bool parse_backref();

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

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

+ bool parse_QE();

+ bool parse_perl_extension();

+ bool add_emacs_code(bool negate);

+ bool unwind_alts(std::ptrdiff_t last_paren_start);

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

+ charT unescape_character();

+ regex_constants::syntax_option_type parse_options();

+

+private:

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

+ typedef typename traits::string_type string_type;

+ typedef typename traits::char_class_type char_class_type;

+ parser_proc_type m_parser_proc; // the main parser to use

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

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

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

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

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

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

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

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

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

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

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

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

+#else

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

+#endif

+

+ basic_regex_parser& operator=(const basic_regex_parser&);

+ basic_regex_parser(const basic_regex_parser&);

+};

+

+template <class charT, class traits>

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

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

+{

+}

+

+template <class charT, class traits>

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

+{

+ // pass l_flags on to base class:

+ this->init(l_flags);

+ // set up pointers:

+ m_position = m_base = p1;

+ m_end = p2;

+ // empty strings are errors:

+ if((p1 == p2) &&

+ (

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

+ || (l_flags & regbase::no_empty_expressions)

+ )

+ )

+ {

+ fail(regex_constants::error_empty, 0);

+ return;

+ }

+ // select which parser to use:

+ switch(l_flags & regbase::main_option_type)

+ {

+ case regbase::perl_syntax_group:

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

+ break;

+ case regbase::basic_syntax_group:

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

+ break;

+ case regbase::literal:

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

+ break;

+ }

+

+ // parse all our characters:

+ bool result = parse_all();

+ //

+ // Unwind our alternatives:

+ //

+ unwind_alts(-1);

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

+ this->flags(l_flags);

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

+ // have had an unexpected ')' :

+ if(!result)

+ {

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

+ return;

+ }

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

+ if(this->m_pdata->m_status)

+ return;

+ // fill in our sub-expression count:

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

+ this->finalize(p1, p2);

+}

+

+template <class charT, class traits>

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

+{

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

+ this->m_pdata->m_status = error_code;

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

+ // get the error message:

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

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

+#ifndef BOOST_NO_EXCEPTIONS

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

+ {

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

+ e.raise();

+ }

+#else

+ (void)position; // suppress warnings.

+#endif

+}

+

+template <class charT, class traits>

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

+{

+ bool result = true;

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

+ {

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

+ }

+ return result;

+}

+

+#ifdef BOOST_MSVC

+#pragma warning(push)

+#pragma warning(disable:4702)

+#endif

+template <class charT, class traits>

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

+{

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

+ {

+ case regex_constants::syntax_escape:

+ return parse_basic_escape();

+ case regex_constants::syntax_dot:

+ return parse_match_any();

+ case regex_constants::syntax_caret:

+ ++m_position;

+ this->append_state(syntax_element_start_line);

+ break;

+ case regex_constants::syntax_dollar:

+ ++m_position;

+ this->append_state(syntax_element_end_line);

+ break;

+ case regex_constants::syntax_star:

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

+ return parse_literal();

+ else

+ {

+ ++m_position;

+ return parse_repeat();

+ }

+ case regex_constants::syntax_plus:

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

+ return parse_literal();

+ else

+ {

+ ++m_position;

+ return parse_repeat(1);

+ }

+ case regex_constants::syntax_question:

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

+ return parse_literal();

+ else

+ {

+ ++m_position;

+ return parse_repeat(0, 1);

+ }

+ case regex_constants::syntax_open_set:

+ return parse_set();

+ case regex_constants::syntax_newline:

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

+ return parse_alt();

+ else

+ return parse_literal();

+ default:

+ return parse_literal();

+ }

+ return true;

+}

+

+template <class charT, class traits>

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

+{

+ bool result = true;

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

+ {

+ case regex_constants::syntax_open_mark:

+ return parse_open_paren();

+ case regex_constants::syntax_close_mark:

+ return false;

+ case regex_constants::syntax_escape:

+ return parse_extended_escape();

+ case regex_constants::syntax_dot:

+ return parse_match_any();

+ case regex_constants::syntax_caret:

+ ++m_position;

+ this->append_state(

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

+ break;

+ case regex_constants::syntax_dollar:

+ ++m_position;

+ this->append_state(

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

+ break;

+ case regex_constants::syntax_star:

+ if(m_position == this->m_base)

+ {

+ fail(regex_constants::error_badrepeat, 0);

+ return false;

+ }

+ ++m_position;

+ return parse_repeat();

+ case regex_constants::syntax_question:

+ if(m_position == this->m_base)

+ {

+ fail(regex_constants::error_badrepeat, 0);

+ return false;

+ }

+ ++m_position;

+ return parse_repeat(0,1);

+ case regex_constants::syntax_plus:

+ if(m_position == this->m_base)

+ {

+ fail(regex_constants::error_badrepeat, 0);

+ return false;

+ }

+ ++m_position;

+ return parse_repeat(1);

+ case regex_constants::syntax_open_brace:

+ ++m_position;

+ return parse_repeat_range(false);

+ case regex_constants::syntax_close_brace:

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

+ return false;

+ case regex_constants::syntax_or:

+ return parse_alt();

+ case regex_constants::syntax_open_set:

+ return parse_set();

+ case regex_constants::syntax_newline:

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

+ return parse_alt();

+ else

+ return parse_literal();

+ case regex_constants::syntax_hash:

+ //

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

+ // we get to a newline character:

+ //

+ if((this->flags()

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

+ == regbase::mod_x)

+ {

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

+ return true;

+ }

+ // Otherwise fall through:

+ default:

+ result = parse_literal();

+ break;

+ }

+ return result;

+}

+#ifdef BOOST_MSVC

+#pragma warning(pop)

+#endif

+

+template <class charT, class traits>

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

+{

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

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

+ if(

+ ((this->flags()

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

+ != regbase::mod_x)

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

+ this->append_literal(*m_position);

+ ++m_position;

+ return true;

+}

+

+template <class charT, class traits>

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

+{

+ //

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

+ //

+ if(++m_position == m_end)

+ {

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

+ return false;

+ }

+ //

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

+ //

+ if(

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

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

+ )

+ {

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

+ return parse_perl_extension();

+ }

+ //

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

+ //

+ unsigned markid = 0;

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

+ {

+ markid = ++m_mark_count;

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

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

+ }

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

+ pb->index = markid;

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

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

+ std::ptrdiff_t last_alt_point = m_alt_insert_point;

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

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

+ //

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

+ //

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

+ bool old_case_change = m_has_case_change;

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

+ //

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

+ // matching ')' :

+ //

+ parse_all();

+ //

+ // Unwind pushed alternatives:

+ //

+ if(0 == unwind_alts(last_paren_start))

+ return false;

+ //

+ // restore flags:

+ //

+ if(m_has_case_change)

+ {

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

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

+ // to reset the case sensitivity:

+ static_cast<re_case*>(

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

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

+ }

+ this->flags(opts);

+ m_has_case_change = old_case_change;

+ //

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

+ //

+ if(m_position == m_end)

+ {

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

+ return false;

+ }

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

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

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

+ ++m_position;

+ //

+ // append closing parenthesis state:

+ //

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

+ pb->index = markid;

+ this->m_paren_start = last_paren_start;

+ //

+ // restore the alternate insertion point:

+ //

+ this->m_alt_insert_point = last_alt_point;

+ //

+ // allow backrefs to this mark:

+ //

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

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

+

+ return true;

+}

+

+template <class charT, class traits>

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

+{

+ ++m_position;

+ bool result = true;

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

+ {

+ case regex_constants::syntax_open_mark:

+ return parse_open_paren();

+ case regex_constants::syntax_close_mark:

+ return false;

+ case regex_constants::syntax_plus:

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

+ {

+ ++m_position;

+ return parse_repeat(1);

+ }

+ else

+ return parse_literal();

+ case regex_constants::syntax_question:

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

+ {

+ ++m_position;

+ return parse_repeat(0, 1);

+ }

+ else

+ return parse_literal();

+ case regex_constants::syntax_open_brace:

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

+ return parse_literal();

+ ++m_position;

+ return parse_repeat_range(true);

+ case regex_constants::syntax_close_brace:

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

+ return parse_literal();

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

+ return false;

+ case regex_constants::syntax_or:

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

+ return parse_alt();

+ else

+ result = parse_literal();

+ break;

+ case regex_constants::syntax_digit:

+ return parse_backref();

+ case regex_constants::escape_type_start_buffer:

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

+ {

+ ++m_position;

+ this->append_state(syntax_element_buffer_start);

+ }

+ else

+ result = parse_literal();

+ break;

+ case regex_constants::escape_type_end_buffer:

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

+ {

+ ++m_position;

+ this->append_state(syntax_element_buffer_end);

+ }

+ else

+ result = parse_literal();

+ break;

+ case regex_constants::escape_type_word_assert:

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

+ {

+ ++m_position;

+ this->append_state(syntax_element_word_boundary);

+ }

+ else

+ result = parse_literal();

+ break;

+ case regex_constants::escape_type_not_word_assert:

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

+ {

+ ++m_position;

+ this->append_state(syntax_element_within_word);

+ }

+ else

+ result = parse_literal();

+ break;

+ case regex_constants::escape_type_left_word:

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

+ {

+ ++m_position;

+ this->append_state(syntax_element_word_start);

+ }

+ else

+ result = parse_literal();

+ break;

+ case regex_constants::escape_type_right_word:

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

+ {

+ ++m_position;

+ this->append_state(syntax_element_word_end);

+ }

+ else

+ result = parse_literal();

+ break;

+ default:

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

+ {

+ bool negate = true;

+ switch(*m_position)

+ {

+ case 'w':

+ negate = false;

+ // fall through:

+ case 'W':

+ {

+ basic_char_set<charT, traits> char_set;

+ if(negate)

+ char_set.negate();

+ char_set.add_class(this->m_word_mask);

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

+ {

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

+ return false;

+ }

+ ++m_position;

+ return true;

+ }

+ case 's':

+ negate = false;

+ // fall through:

+ case 'S':

+ return add_emacs_code(negate);

+ case 'c':

+ case 'C':

+ // not supported yet:

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

+ return false;

+ default:

+ break;

+ }

+ }

+ result = parse_literal();

+ break;

+ }

+ return result;

+}

+

+template <class charT, class traits>

+bool basic_regex_parser<charT, traits>::parse_extended_escape()

+{

+ ++m_position;

+ bool negate = false; // in case this is a character class escape: \w \d etc

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

+ {

+ case regex_constants::escape_type_not_class:

+ negate = true;

+ // fall through:

+ case regex_constants::escape_type_class:

+ {

+ typedef typename traits::char_class_type mask_type;

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

+ if(m != 0)

+ {

+ basic_char_set<charT, traits> char_set;

+ if(negate)

+ char_set.negate();

+ char_set.add_class(m);

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

+ {

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

+ return false;

+ }

+ ++m_position;

+ return true;

+ }

+ //

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

+ //

+ this->append_literal(unescape_character());

+ break;

+ }

+ case regex_constants::syntax_digit:

+ return parse_backref();

+ case regex_constants::escape_type_left_word:

+ ++m_position;

+ this->append_state(syntax_element_word_start);

+ break;

+ case regex_constants::escape_type_right_word:

+ ++m_position;

+ this->append_state(syntax_element_word_end);

+ break;

+ case regex_constants::escape_type_start_buffer:

+ ++m_position;

+ this->append_state(syntax_element_buffer_start);

+ break;

+ case regex_constants::escape_type_end_buffer:

+ ++m_position;

+ this->append_state(syntax_element_buffer_end);

+ break;

+ case regex_constants::escape_type_word_assert:

+ ++m_position;

+ this->append_state(syntax_element_word_boundary);

+ break;

+ case regex_constants::escape_type_not_word_assert:

+ ++m_position;

+ this->append_state(syntax_element_within_word);

+ break;

+ case regex_constants::escape_type_Z:

+ ++m_position;

+ this->append_state(syntax_element_soft_buffer_end);

+ break;

+ case regex_constants::escape_type_Q:

+ return parse_QE();

+ case regex_constants::escape_type_C:

+ return parse_match_any();

+ case regex_constants::escape_type_X:

+ ++m_position;

+ this->append_state(syntax_element_combining);

+ break;

+ case regex_constants::escape_type_G:

+ ++m_position;

+ this->append_state(syntax_element_restart_continue);

+ break;

+ case regex_constants::escape_type_not_property:

+ negate = true;

+ // fall through:

+ case regex_constants::escape_type_property:

+ {

+ ++m_position;

+ char_class_type m;

+ if(m_position == m_end)

+ {

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

+ return false;

+ }

+ // maybe have \p{ddd}

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

+ {

+ const charT* base = m_position;

+ // skip forward until we find enclosing brace:

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

+ ++m_position;

+ if(m_position == m_end)

+ {

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

+ return false;

+ }

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

+ }

+ else

+ {

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

+ ++m_position;

+ }

+ if(m != 0)

+ {

+ basic_char_set<charT, traits> char_set;

+ if(negate)

+ char_set.negate();

+ char_set.add_class(m);

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

+ {

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

+ return false;

+ }

+ return true;

+ }

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

+ }

+ default:

+ this->append_literal(unescape_character());

+ break;

+ }

+ return true;

+}

+

+template <class charT, class traits>

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

+{

+ //

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

+ //

+ ++m_position;

+ static_cast<re_dot*>(

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

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

+ ? re_detail::force_not_newline

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

+ re_detail::force_newline : re_detail::dont_care);

+ return true;

+}

+

+template <class charT, class traits>

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

+{

+ bool greedy = true;

+ std::size_t insert_point;

+ //

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

+ //

+ if((m_position != m_end)

+ && (

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

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

+ )

+ )

+ {

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

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

+ {

+ greedy = false;

+ ++m_position;

+ }

+ }

+ if(0 == this->m_last_state)

+ {

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

+ return false;

+ }

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

+ {

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

+ insert_point = this->m_paren_start;

+ }

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

+ {

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

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

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

+ --(lit->length);

+ // now append new state:

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

+ lit->length = 1;

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

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

+ }

+ else

+ {

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

+ switch(this->m_last_state->type)

+ {

+ case syntax_element_start_line:

+ case syntax_element_end_line:

+ case syntax_element_word_boundary:

+ case syntax_element_within_word:

+ case syntax_element_word_start:

+ case syntax_element_word_end:

+ case syntax_element_buffer_start:

+ case syntax_element_buffer_end:

+ case syntax_element_alt:

+ case syntax_element_soft_buffer_end:

+ case syntax_element_restart_continue:

+ case syntax_element_jump:

+ case syntax_element_startmark:

+ case syntax_element_backstep:

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

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

+ return false;

+ default:

+ // do nothing...

+ break;

+ }

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

+ }

+ //

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

+ //

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

+ rep->min = low;

+ rep->max = high;

+ rep->greedy = greedy;

+ rep->leading = false;

+ // store our repeater position for later:

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

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

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

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

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

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

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

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

+ return true;

+}

+

+template <class charT, class traits>

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

+{

+ //

+ // parse a repeat-range:

+ //

+ std::size_t min, max;

+ int v;

+ // skip whitespace:

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

+ ++m_position;

+ // fail if at end:

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

+ {

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

+ return false;

+ }

+ // get min:

+ v = this->m_traits.toi(m_position, m_end, 10);

+ // skip whitespace:

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

+ ++m_position;

+ if(v < 0)

+ {

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

+ return false;

+ }

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

+ {

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

+ return false;

+ }

+ min = v;

+ // see if we have a comma:

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

+ {

+ // move on and error check:

+ ++m_position;

+ // skip whitespace:

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

+ ++m_position;

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

+ {

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

+ return false;

+ }

+ // get the value if any:

+ v = this->m_traits.toi(m_position, m_end, 10);

+ max = (v >= 0) ? v : (std::numeric_limits<std::size_t>::max)();

+ }

+ else

+ {

+ // no comma, max = min:

+ max = min;

+ }

+ // skip whitespace:

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

+ ++m_position;

+ // OK now check trailing }:

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

+ {

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

+ return false;

+ }

+ if(isbasic)

+ {

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

+ {

+ ++m_position;

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

+ {

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

+ return false;

+ }

+ }

+ else

+ {

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

+ return false;

+ }

+ }

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

+ ++m_position;

+ else

+ {

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

+ return false;

+ }

+ //

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

+ //

+ if(min > max)

+ {

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

+ return false;

+ }

+ return parse_repeat(min, max);

+}

+

+template <class charT, class traits>

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

+{

+ //

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

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

+ //

+ if(

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

+ &&

+ !(

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

+ &&

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

+ )

+ )

+ {

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

+ return false;

+ }

+ ++m_position;

+ //

+ // we need to append a trailing jump:

+ //

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

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

+ //

+ // now insert the alternative:

+ //

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

+ jump_offset += re_alt_size;

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

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

+ //

+ // update m_alt_insert_point so that the next alternate gets

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

+ //

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

+ //

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

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

+ //

+ if(m_has_case_change)

+ {

+ static_cast<re_case*>(

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

+ )->icase = this->m_icase;

+ }

+ //

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

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

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

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

+ //

+ m_alt_jumps.push_back(jump_offset);

+ return true;

+}

+

+template <class charT, class traits>

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

+{

+ ++m_position;

+ if(m_position == m_end)

+ {

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

+ return false;

+ }

+ basic_char_set<charT, traits> char_set;

+

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

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

+

+ while(m_position != m_end)

+ {

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

+ {

+ case regex_constants::syntax_caret:

+ if(m_position == base)

+ {

+ char_set.negate();

+ ++m_position;

+ item_base = m_position;

+ }

+ else

+ parse_set_literal(char_set);

+ break;

+ case regex_constants::syntax_close_set:

+ if(m_position == item_base)

+ {

+ parse_set_literal(char_set);

+ break;

+ }

+ else

+ {

+ ++m_position;

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

+ {

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

+ return false;

+ }

+ }

+ return true;

+ case regex_constants::syntax_open_set:

+ if(parse_inner_set(char_set))

+ break;

+ return true;

+ case regex_constants::syntax_escape:

+ {

+ //

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

+ // \d \w \s etc...

+ //

+ ++m_position;

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

+ == regex_constants::escape_type_class)

+ {

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

+ if(m != 0)

+ {

+ char_set.add_class(m);

+ ++m_position;

+ break;

+ }

+ }

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

+ == regex_constants::escape_type_not_class)

+ {

+ // negated character class:

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

+ if(m != 0)

+ {

+ char_set.add_negated_class(m);

+ ++m_position;

+ break;

+ }

+ }

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

+ --m_position;

+ parse_set_literal(char_set);

+ break;

+ }

+ default:

+ parse_set_literal(char_set);

+ break;

+ }

+ }

+ return m_position != m_end;

+}

+

+template <class charT, class traits>

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

+{

+ //

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

+ // a collating element [.name.]

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

+ //

+ if(m_end == ++m_position)

+ {

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

+ return false;

+ }

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

+ {

+ case regex_constants::syntax_dot:

+ //

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

+ //

+ --m_position;

+ parse_set_literal(char_set);

+ return true;

+ case regex_constants::syntax_colon:

+ {

+ // check that character classes are actually enabled:

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

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

+ {

+ --m_position;

+ parse_set_literal(char_set);

+ return true;

+ }

+ // skip the ':'

+ if(m_end == ++m_position)

+ {

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

+ return false;

+ }

+ const charT* name_first = m_position;

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

+ if(m_end == ++m_position)

+ {

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

+ return false;

+ }

+ while((m_position != m_end)

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

+ ++m_position;

+ const charT* name_last = m_position;

+ if(m_end == m_position)

+ {

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

+ return false;

+ }

+ if((m_end == ++m_position)

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

+ {

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

+ return false;

+ }

+ //

+ // check for negated class:

+ //

+ bool negated = false;

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

+ {

+ ++name_first;

+ negated = true;

+ }

+ typedef typename traits::char_class_type mask_type;

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

+ if(m == 0)

+ {

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

+ {

+ // maybe a special case:

+ ++m_position;

+ if( (m_position != m_end)

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

+ == regex_constants::syntax_close_set))

+ {

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

+ == regex_constants::escape_type_left_word)

+ {

+ ++m_position;

+ this->append_state(syntax_element_word_start);

+ return false;

+ }

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

+ == regex_constants::escape_type_right_word)

+ {

+ ++m_position;

+ this->append_state(syntax_element_word_end);

+ return false;

+ }

+ }

+ }

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

+ return false;

+ }

+ if(negated == false)

+ char_set.add_class(m);

+ else

+ char_set.add_negated_class(m);

+ ++m_position;

+ break;

+ }

+ case regex_constants::syntax_equal:

+ {

+ // skip the '='

+ if(m_end == ++m_position)

+ {

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

+ return false;

+ }

+ const charT* name_first = m_position;

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

+ if(m_end == ++m_position)

+ {

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

+ return false;

+ }

+ while((m_position != m_end)

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

+ ++m_position;

+ const charT* name_last = m_position;

+ if(m_end == m_position)

+ {

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

+ return false;

+ }

+ if((m_end == ++m_position)

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

+ {

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

+ return false;

+ }

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

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

+ {

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

+ return false;

+ }

+ digraph<charT> d;

+ d.first = m[0];

+ if(m.size() > 1)

+ d.second = m[1];

+ else

+ d.second = 0;

+ char_set.add_equivalent(d);

+ ++m_position;

+ break;

+ }

+ default:

+ --m_position;

+ parse_set_literal(char_set);

+ break;

+ }

+ return true;

+}

+

+template <class charT, class traits>

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

+{

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

+ if(m_end == m_position)

+ {

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

+ return;

+ }

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

+ {

+ // we have a range:

+ if(m_end == ++m_position)

+ {

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

+ return;

+ }

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

+ {

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

+ char_set.add_range(start_range, end_range);

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

+ {

+ if(m_end == ++m_position)

+ {

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

+ return;

+ }

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

+ {

+ // trailing - :

+ --m_position;

+ return;

+ }

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

+ return;

+ }

+ return;

+ }

+ --m_position;

+ }

+ char_set.add_single(start_range);

+}

+

+template <class charT, class traits>

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

+{

+ digraph<charT> result;

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

+ {

+ case regex_constants::syntax_dash:

+ if(!char_set.empty())

+ {

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

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

+ {

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

+ return result;

+ }

+ --m_position;

+ }

+ result.first = *m_position++;

+ return result;

+ case regex_constants::syntax_escape:

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

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

+ {

+ result = *m_position++;

+ break;

+ }

+ ++m_position;

+ result = unescape_character();

+ break;

+ case regex_constants::syntax_open_set:

+ {

+ if(m_end == ++m_position)

+ {

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

+ return result;

+ }

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

+ {

+ --m_position;

+ result.first = *m_position;

+ ++m_position;

+ return result;

+ }

+ if(m_end == ++m_position)

+ {

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

+ return result;

+ }

+ const charT* name_first = m_position;

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

+ if(m_end == ++m_position)

+ {

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

+ return result;

+ }

+ while((m_position != m_end)

+ && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_dot))

+ ++m_position;

+ const charT* name_last = m_position;

+ if(m_end == m_position)

+ {

+ fail(regex_constants::error_collate, name_first - m_base);

+ return result;

+ }

+ if((m_end == ++m_position)

+ || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_set))

+ {

+ fail(regex_constants::error_collate, name_first - m_base);

+ return result;

+ }

+ ++m_position;

+ string_type s = this->m_traits.lookup_collatename(name_first, name_last);

+ if(s.empty() || (s.size() > 2))

+ {

+ fail(regex_constants::error_collate, name_first - m_base);

+ return result;

+ }

+ result.first = s[0];

+ if(s.size() > 1)

+ result.second = s[1];

+ else

+ result.second = 0;

+ return result;

+ }

+ default:

+ result = *m_position++;

+ }

+ return result;

+}

+

+//

+// does a value fit in the specified charT type?

+//

+template <class charT>

+bool valid_value(charT, int v, const mpl::true_&)

+{

+ return (v >> (sizeof(charT) * CHAR_BIT)) == 0;

+}

+template <class charT>

+bool valid_value(charT, int, const mpl::false_&)

+{

+ return true; // v will alsways fit in a charT

+}

+template <class charT>

+bool valid_value(charT c, int v)

+{

+ return valid_value(c, v, mpl::bool_<(sizeof(charT) < sizeof(int))>());

+}

+

+template <class charT, class traits>

+charT basic_regex_parser<charT, traits>::unescape_character()

+{

+#ifdef BOOST_MSVC

+#pragma warning(push)

+#pragma warning(disable:4127)

+#endif

+ charT result(0);

+ if(m_position == m_end)

+ {

+ fail(regex_constants::error_escape, m_position - m_base);

+ return false;

+ }

+ switch(this->m_traits.escape_syntax_type(*m_position))

+ {

+ case regex_constants::escape_type_control_a:

+ result = charT('\a');

+ break;

+ case regex_constants::escape_type_e:

+ result = charT(27);

+ break;

+ case regex_constants::escape_type_control_f:

+ result = charT('\f');

+ break;

+ case regex_constants::escape_type_control_n:

+ result = charT('\n');

+ break;

+ case regex_constants::escape_type_control_r:

+ result = charT('\r');

+ break;

+ case regex_constants::escape_type_control_t:

+ result = charT('\t');

+ break;

+ case regex_constants::escape_type_control_v:

+ result = charT('\v');

+ break;

+ case regex_constants::escape_type_word_assert:

+ result = charT('\b');

+ break;

+ case regex_constants::escape_type_ascii_control:

+ ++m_position;

+ if(m_position == m_end)

+ {

+ fail(regex_constants::error_escape, m_position - m_base);

+ return result;

+ }

+ /*

+ if((*m_position < charT('@'))

+ || (*m_position > charT(125)) )

+ {

+ fail(regex_constants::error_escape, m_position - m_base);

+ return result;

+ }

+ */

+ result = static_cast<charT>(*m_position % 32);

+ break;

+ case regex_constants::escape_type_hex:

+ ++m_position;

+ if(m_position == m_end)

+ {

+ fail(regex_constants::error_escape, m_position - m_base);

+ return result;

+ }

+ // maybe have \x{ddd}

+ if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_open_brace)

+ {

+ ++m_position;

+ if(m_position == m_end)

+ {

+ fail(regex_constants::error_escape, m_position - m_base);

+ return result;

+ }

+ int i = this->m_traits.toi(m_position, m_end, 16);

+ if((m_position == m_end)

+ || (i < 0)

+ || ((std::numeric_limits<charT>::is_specialized) && (charT(i) > (std::numeric_limits<charT>::max)()))

+ || (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_brace))

+ {

+ fail(regex_constants::error_badbrace, m_position - m_base);

+ return result;

+ }

+ ++m_position;

+ result = charT(i);

+ }

+ else

+ {

+ std::ptrdiff_t len = (std::min)(static_cast<std::ptrdiff_t>(2), m_end - m_position);

+ int i = this->m_traits.toi(m_position, m_position + len, 16);

+ if((i < 0)

+ || !valid_value(charT(0), i))

+ {

+ fail(regex_constants::error_escape, m_position - m_base);

+ return result;

+ }

+ result = charT(i);

+ }

+ return result;

+ case regex_constants::syntax_digit:

+ {

+ // an octal escape sequence, the first character must be a zero

+ // followed by up to 3 octal digits:

+ std::ptrdiff_t len = (std::min)(::boost::re_detail::distance(m_position, m_end), static_cast<std::ptrdiff_t>(4));

+ const charT* bp = m_position;

+ int val = this->m_traits.toi(bp, bp + 1, 8);

+ if(val != 0)

+ {

+ // Oops not an octal escape after all:

+ fail(regex_constants::error_escape, m_position - m_base);

+ return result;

+ }

+ val = this->m_traits.toi(m_position, m_position + len, 8);

+ if(val < 0)

+ {

+ fail(regex_constants::error_escape, m_position - m_base);

+ return result;

+ }

+ return static_cast<charT>(val);

+ }

+ case regex_constants::escape_type_named_char:

+ {

+ ++m_position;

+ if(m_position == m_end)

+ {

+ fail(regex_constants::error_escape, m_position - m_base);

+ return false;

+ }

+ // maybe have \N{name}

+ if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_open_brace)

+ {

+ const charT* base = m_position;

+ // skip forward until we find enclosing brace:

+ while((m_position != m_end) && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_brace))

+ ++m_position;

+ if(m_position == m_end)

+ {

+ fail(regex_constants::error_escape, m_position - m_base);

+ return false;

+ }

+ string_type s = this->m_traits.lookup_collatename(++base, m_position++);

+ if(s.empty())

+ {

+ fail(regex_constants::error_collate, m_position - m_base);

+ return false;

+ }

+ if(s.size() == 1)

+ {

+ return s[0];

+ }

+ }

+ // fall through is a failure:

+ fail(regex_constants::error_escape, m_position - m_base);

+ return false;

+ }

+ default:

+ result = *m_position;

+ break;

+ }

+ ++m_position;

+ return result;

+#ifdef BOOST_MSVC

+#pragma warning(pop)

+#endif

+}

+

+template <class charT, class traits>

+bool basic_regex_parser<charT, traits>::parse_backref()

+{

+ BOOST_ASSERT(m_position != m_end);

+ const charT* pc = m_position;

+ int i = this->m_traits.toi(pc, pc + 1, 10);

+ if((i == 0) || (((this->flags() & regbase::main_option_type) == regbase::perl_syntax_group) && (this->flags() & regbase::no_bk_refs)))

+ {

+ // not a backref at all but an octal escape sequence:

+ charT c = unescape_character();

+ this->append_literal(c);

+ }

+ else if((i > 0) && (this->m_backrefs & (1u << (i-1))))

+ {

+ m_position = pc;

+ re_brace* pb = static_cast<re_brace*>(this->append_state(syntax_element_backref, sizeof(re_brace)));

+ pb->index = i;

+ }

+ else

+ {

+ fail(regex_constants::error_backref, m_position - m_end);

+ return false;

+ }

+ return true;

+}

+

+template <class charT, class traits>

+bool basic_regex_parser<charT, traits>::parse_QE()

+{

+#ifdef BOOST_MSVC

+#pragma warning(push)

+#pragma warning(disable:4127)

+#endif

+ //

+ // parse a \Q...\E sequence:

+ //

+ ++m_position; // skip the Q

+ const charT* start = m_position;

+ const charT* end;

+ do

+ {

+ while((m_position != m_end)

+ && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_escape))

+ ++m_position;

+ if(m_position == m_end)

+ {

+ // a \Q...\E sequence may terminate with the end of the expression:

+ end = m_position;

+ break;

+ }

+ if(++m_position == m_end) // skip the escape

+ {

+ fail(regex_constants::error_escape, m_position - m_base);

+ return false;

+ }

+ // check to see if it's a \E:

+ if(this->m_traits.escape_syntax_type(*m_position) == regex_constants::escape_type_E)

+ {

+ ++m_position;

+ end = m_position - 2;

+ break;

+ }

+ // otherwise go round again:

+ }while(true);

+ //

+ // now add all the character between the two escapes as literals:

+ //

+ while(start != end)

+ {

+ this->append_literal(*start);

+ ++start;

+ }

+ return true;

+#ifdef BOOST_MSVC

+#pragma warning(pop)

+#endif

+}

+

+template <class charT, class traits>

+bool basic_regex_parser<charT, traits>::parse_perl_extension()

+{

+ if(++m_position == m_end)

+ {

+ fail(regex_constants::error_badrepeat, m_position - m_base);

+ return false;

+ }

+ //

+ // treat comments as a special case, as these

+ // are the only ones that don't start with a leading

+ // startmark state:

+ //

+ if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_hash)

+ {

+ while((m_position != m_end)

+ && (this->m_traits.syntax_type(*m_position++) != regex_constants::syntax_close_mark))

+ {}

+ return true;

+ }

+ //

+ // backup some state, and prepare the way:

+ //

+ int markid = 0;

+ std::ptrdiff_t jump_offset = 0;

+ re_brace* pb = static_cast<re_brace*>(this->append_state(syntax_element_startmark, sizeof(re_brace)));

+ std::ptrdiff_t last_paren_start = this->getoffset(pb);

+ // back up insertion point for alternations, and set new point:

+ std::ptrdiff_t last_alt_point = m_alt_insert_point;

+ this->m_pdata->m_data.align();

+ m_alt_insert_point = this->m_pdata->m_data.size();

+ std::ptrdiff_t expected_alt_point = m_alt_insert_point;

+ bool restore_flags = true;

+ regex_constants::syntax_option_type old_flags = this->flags();

+ bool old_case_change = m_has_case_change;

+ m_has_case_change = false;

+ //

+ // select the actual extension used:

+ //

+ switch(this->m_traits.syntax_type(*m_position))

+ {

+ case regex_constants::syntax_colon:

+ //

+ // a non-capturing mark:

+ //

+ pb->index = markid = 0;

+ ++m_position;

+ break;

+ case regex_constants::syntax_equal:

+ pb->index = markid = -1;

+ ++m_position;

+ jump_offset = this->getoffset(this->append_state(syntax_element_jump, sizeof(re_jump)));

+ this->m_pdata->m_data.align();

+ m_alt_insert_point = this->m_pdata->m_data.size();

+ break;

+ case regex_constants::syntax_not:

+ pb->index = markid = -2;

+ ++m_position;

+ jump_offset = this->getoffset(this->append_state(syntax_element_jump, sizeof(re_jump)));

+ this->m_pdata->m_data.align();

+ m_alt_insert_point = this->m_pdata->m_data.size();

+ break;

+ case regex_constants::escape_type_left_word:

+ {

+ // a lookbehind assertion:

+ if(++m_position == m_end)

+ {

+ fail(regex_constants::error_badrepeat, m_position - m_base);

+ return false;

+ }

+ regex_constants::syntax_type t = this->m_traits.syntax_type(*m_position);

+ if(t == regex_constants::syntax_not)

+ pb->index = markid = -2;

+ else if(t == regex_constants::syntax_equal)

+ pb->index = markid = -1;

+ else

+ {

+ fail(regex_constants::error_badrepeat, m_position - m_base);

+ return false;

+ }

+ ++m_position;

+ jump_offset = this->getoffset(this->append_state(syntax_element_jump, sizeof(re_jump)));

+ this->append_state(syntax_element_backstep, sizeof(re_brace));

+ this->m_pdata->m_data.align();

+ m_alt_insert_point = this->m_pdata->m_data.size();

+ break;

+ }

+ case regex_constants::escape_type_right_word:

+ //

+ // an independent sub-expression:

+ //

+ pb->index = markid = -3;

+ ++m_position;

+ jump_offset = this->getoffset(this->append_state(syntax_element_jump, sizeof(re_jump)));

+ this->m_pdata->m_data.align();

+ m_alt_insert_point = this->m_pdata->m_data.size();

+ break;

+ case regex_constants::syntax_open_mark:

+ {

+ // a conditional expression:

+ pb->index = markid = -4;

+ if(++m_position == m_end)

+ {

+ fail(regex_constants::error_badrepeat, m_position - m_base);

+ return false;

+ }

+ int v = this->m_traits.toi(m_position, m_end, 10);

+ if(v > 0)

+ {

+ re_brace* br = static_cast<re_brace*>(this->append_state(syntax_element_assert_backref, sizeof(re_brace)));

+ br->index = v;

+ if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_close_mark)

+ {

+ fail(regex_constants::error_badrepeat, m_position - m_base);

+ return false;

+ }

+ if(++m_position == m_end)

+ {

+ fail(regex_constants::error_badrepeat, m_position - m_base);

+ return false;

+ }

+ }

+ else

+ {

+ // verify that we have a lookahead or lookbehind assert:

+ if(this->m_traits.syntax_type(*m_position) != regex_constants::syntax_question)

+ {

+ fail(regex_constants::error_badrepeat, m_position - m_base);

+ return false;

+ }

+ if(++m_position == m_end)

+ {

+ fail(regex_constants::error_badrepeat, m_position - m_base);

+ return false;

+ }

+ if(this->m_traits.syntax_type(*m_position) == regex_constants::escape_type_left_word)

+ {

+ if(++m_position == m_end)

+ {

+ fail(regex_constants::error_badrepeat, m_position - m_base);

+ return false;

+ }

+ if((this->m_traits.syntax_type(*m_position) != regex_constants::syntax_equal)

+ && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_not))

+ {

+ fail(regex_constants::error_badrepeat, m_position - m_base);

+ return false;

+ }

+ m_position -= 3;

+ }

+ else

+ {

+ if((this->m_traits.syntax_type(*m_position) != regex_constants::syntax_equal)

+ && (this->m_traits.syntax_type(*m_position) != regex_constants::syntax_not))

+ {

+ fail(regex_constants::error_badrepeat, m_position - m_base);

+ return false;

+ }

+ m_position -= 2;

+ }

+ }

+ break;

+ }

+ case regex_constants::syntax_close_mark:

+ fail(regex_constants::error_badrepeat, m_position - m_base);

+ return false;

+ default:

+ //

+ // lets assume that we have a (?imsx) group and try and parse it:

+ //

+ regex_constants::syntax_option_type opts = parse_options();

+ if(m_position == m_end)

+ return false;

+ // make a note of whether we have a case change:

+ m_has_case_change = ((opts & regbase::icase) != (this->flags() & regbase::icase));

+ pb->index = markid = 0;

+ if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark)

+ {

+ // update flags and carry on as normal:

+ this->flags(opts);

+ restore_flags = false;

+ old_case_change |= m_has_case_change; // defer end of scope by one ')'

+ }

+ else if(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_colon)

+ {

+ // update flags and carry on until the matching ')' is found:

+ this->flags(opts);

+ ++m_position;

+ }

+ else

+ {

+ fail(regex_constants::error_badrepeat, m_position - m_base);

+ return false;

+ }

+

+ // finally append a case change state if we need it:

+ if(m_has_case_change)

+ {

+ static_cast<re_case*>(

+ this->append_state(syntax_element_toggle_case, sizeof(re_case))

+ )->icase = opts & regbase::icase;

+ }

+

+ }

+ //

+ // now recursively add more states, this will terminate when we get to a

+ // matching ')' :

+ //

+ parse_all();

+ //

+ // Unwind alternatives:

+ //

+ if(0 == unwind_alts(last_paren_start))

+ return false;

+ //

+ // we either have a ')' or we have run out of characters prematurely:

+ //

+ if(m_position == m_end)

+ {

+ this->fail(regex_constants::error_paren, ::boost::re_detail::distance(m_base, m_end));

+ return false;

+ }

+ BOOST_ASSERT(this->m_traits.syntax_type(*m_position) == regex_constants::syntax_close_mark);

+ ++m_position;

+ //

+ // restore the flags:

+ //

+ if(restore_flags)

+ {

+ // append a case change state if we need it:

+ if(m_has_case_change)

+ {

+ static_cast<re_case*>(

+ this->append_state(syntax_element_toggle_case, sizeof(re_case))

+ )->icase = old_flags & regbase::icase;

+ }

+ this->flags(old_flags);

+ }

+ //

+ // set up the jump pointer if we have one:

+ //

+ if(jump_offset)

+ {

+ this->m_pdata->m_data.align();

+ re_jump* jmp = static_cast<re_jump*>(this->getaddress(jump_offset));

+ jmp->alt.i = this->m_pdata->m_data.size() - this->getoffset(jmp);

+ if(this->m_last_state == jmp)

+ {

+ // Oops... we didn't have anything inside the assertion:

+ fail(regex_constants::error_empty, m_position - m_base);

+ return false;

+ }

+ }

+ //

+ // verify that if this is conditional expression, that we do have

+ // an alternative, if not add one:

+ //

+ if(markid == -4)

+ {

+ re_syntax_base* b = this->getaddress(expected_alt_point);

+ // Make sure we have exactly one alternative following this state:

+ if(b->type != syntax_element_alt)

+ {

+ re_alt* alt = static_cast<re_alt*>(this->insert_state(expected_alt_point, syntax_element_alt, sizeof(re_alt)));

+ alt->alt.i = this->m_pdata->m_data.size() - this->getoffset(alt);

+ }

+ else if(this->getaddress(static_cast<re_alt*>(b)->alt.i, b)->type == syntax_element_alt)

+ {

+ fail(regex_constants::error_bad_pattern, m_position - m_base);

+ return false;

+ }

+ // check for invalid repetition of next state:

+ b = this->getaddress(expected_alt_point);

+ b = this->getaddress(static_cast<re_alt*>(b)->next.i, b);

+ if((b->type != syntax_element_assert_backref)

+ && (b->type != syntax_element_startmark))

+ {

+ fail(regex_constants::error_badrepeat, m_position - m_base);

+ return false;

+ }

+ }

+ //

+ // append closing parenthesis state:

+ //

+ pb = static_cast<re_brace*>(this->append_state(syntax_element_endmark, sizeof(re_brace)));

+ pb->index = markid;

+ this->m_paren_start = last_paren_start;

+ //

+ // restore the alternate insertion point:

+ //

+ this->m_alt_insert_point = last_alt_point;

+ //

+ // and the case change data:

+ //

+ m_has_case_change = old_case_change;

+ return true;

+}

+

+template <class charT, class traits>

+bool basic_regex_parser<charT, traits>::add_emacs_code(bool negate)

+{

+ //

+ // parses an emacs style \sx or \Sx construct.

+ //

+ if(++m_position == m_end)

+ {

+ fail(regex_constants::error_escape, m_position - m_base);

+ return false;

+ }

+ basic_char_set<charT, traits> char_set;

+ if(negate)

+ char_set.negate();

+

+ static const charT s_punct[5] = { 'p', 'u', 'n', 'c', 't', };

+

+ switch(*m_position)

+ {

+ case 's':

+ case ' ':

+ char_set.add_class(this->m_mask_space);

+ break;

+ case 'w':

+ char_set.add_class(this->m_word_mask);

+ break;

+ case '_':

+ char_set.add_single(digraph<charT>(charT('$')));

+ char_set.add_single(digraph<charT>(charT('&')));

+ char_set.add_single(digraph<charT>(charT('*')));

+ char_set.add_single(digraph<charT>(charT('+')));

+ char_set.add_single(digraph<charT>(charT('-')));

+ char_set.add_single(digraph<charT>(charT('_')));

+ char_set.add_single(digraph<charT>(charT('<')));

+ char_set.add_single(digraph<charT>(charT('>')));

+ break;

+ case '.':

+ char_set.add_class(this->m_traits.lookup_classname(s_punct, s_punct+5));

+ break;

+ case '(':

+ char_set.add_single(digraph<charT>(charT('(')));

+ char_set.add_single(digraph<charT>(charT('[')));

+ char_set.add_single(digraph<charT>(charT('{')));

+ break;

+ case ')':

+ char_set.add_single(digraph<charT>(charT(')')));

+ char_set.add_single(digraph<charT>(charT(']')));

+ char_set.add_single(digraph<charT>(charT('}')));

+ break;

+ case '"':

+ char_set.add_single(digraph<charT>(charT('"')));

+ char_set.add_single(digraph<charT>(charT('\'')));

+ char_set.add_single(digraph<charT>(charT('`')));

+ break;

+ case '\'':

+ char_set.add_single(digraph<charT>(charT('\'')));

+ char_set.add_single(digraph<charT>(charT(',')));

+ char_set.add_single(digraph<charT>(charT('#')));

+ break;

+ case '<':

+ char_set.add_single(digraph<charT>(charT(';')));

+ break;

+ case '>':

+ char_set.add_single(digraph<charT>(charT('\n')));

+ char_set.add_single(digraph<charT>(charT('\f')));

+ break;

+ default:

+ fail(regex_constants::error_ctype, m_position - m_base);

+ return false;

+ }

+ if(0 == this->append_set(char_set))

+ {

+ fail(regex_constants::error_ctype, m_position - m_base);

+ return false;

+ }

+ ++m_position;

+ return true;

+}

+

+template <class charT, class traits>

+regex_constants::syntax_option_type basic_regex_parser<charT, traits>::parse_options()

+{

+ // we have a (?imsx-imsx) group, convert it into a set of flags:

+ regex_constants::syntax_option_type f = this->flags();

+ bool breakout = false;

+ do

+ {

+ switch(*m_position)

+ {

+ case 's':

+ f |= regex_constants::mod_s;

+ f &= ~regex_constants::no_mod_s;

+ break;

+ case 'm':

+ f &= ~regex_constants::no_mod_m;

+ break;

+ case 'i':

+ f |= regex_constants::icase;

+ break;

+ case 'x':

+ f |= regex_constants::mod_x;

+ break;

+ default:

+ breakout = true;

+ continue;

+ }

+ if(++m_position == m_end)

+ {

+ fail(regex_constants::error_paren, m_position - m_base);

+ return false;

+ }

+ }

+ while(!breakout);

+

+ if(*m_position == static_cast<charT>('-'))

+ {

+ if(++m_position == m_end)

+ {

+ fail(regex_constants::error_paren, m_position - m_base);

+ return false;

+ }

+ do

+ {

+ switch(*m_position)

+ {

+ case 's':

+ f &= ~regex_constants::mod_s;

+ f |= regex_constants::no_mod_s;

+ break;

+ case 'm':

+ f |= regex_constants::no_mod_m;

+ break;

+ case 'i':

+ f &= ~regex_constants::icase;

+ break;

+ case 'x':

+ f &= ~regex_constants::mod_x;

+ break;

+ default:

+ breakout = true;

+ continue;

+ }

+ if(++m_position == m_end)

+ {

+ fail(regex_constants::error_paren, m_position - m_base);

+ return false;

+ }

+ }

+ while(!breakout);

+ }

+ return f;

+}

+

+template <class charT, class traits>

+bool basic_regex_parser<charT, traits>::unwind_alts(std::ptrdiff_t last_paren_start)

+{

+ //

+ // If we didn't actually add any states after the last

+ // alternative then that's an error:

+ //

+ if((this->m_alt_insert_point == static_cast<std::ptrdiff_t>(this->m_pdata->m_data.size()))

+ && m_alt_jumps.size() && (m_alt_jumps.back() > last_paren_start)

+ &&

+ !(

+ ((this->flags() & regbase::main_option_type) == regbase::perl_syntax_group)

+ &&

+ ((this->flags() & regbase::no_empty_expressions) == 0)

+ )

+ )

+ {

+ fail(regex_constants::error_empty, this->m_position - this->m_base);

+ return false;

+ }

+ //

+ // Fix up our alternatives:

+ //

+ while(m_alt_jumps.size() && (m_alt_jumps.back() > last_paren_start))

+ {

+ //

+ // fix up the jump to point to the end of the states

+ // that we've just added:

+ //

+ std::ptrdiff_t jump_offset = m_alt_jumps.back();