-/*

- *

- * 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();

- m_alt_jumps.pop_back();