/*

 *

 * 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         c_regex_traits.hpp

  *   VERSION      see <boost/version.hpp>

  *   DESCRIPTION: Declares regular expression traits class that wraps the global C locale.

  */

#ifndef BOOST_C_REGEX_TRAITS_HPP_INCLUDED

#define BOOST_C_REGEX_TRAITS_HPP_INCLUDED

#ifndef BOOST_REGEX_AS_MODULE

#include <cctype>

#include <cstdint>

#include <cwctype>

#endif

#include <boost/regex/config.hpp>

#include <boost/regex/v5/regex_workaround.hpp>

#include <boost/regex/v5/primary_transform.hpp>

#include <boost/regex/v5/regex_traits_defaults.hpp>

namespace boost{

   namespace BOOST_REGEX_DETAIL_NS {

      enum

      {

         char_class_space = 1 << 0,

         char_class_print = 1 << 1,

         char_class_cntrl = 1 << 2,

         char_class_upper = 1 << 3,

         char_class_lower = 1 << 4,

         char_class_alpha = 1 << 5,

         char_class_digit = 1 << 6,

         char_class_punct = 1 << 7,

         char_class_xdigit = 1 << 8,

         char_class_alnum = char_class_alpha | char_class_digit,

         char_class_graph = char_class_alnum | char_class_punct,

         char_class_blank = 1 << 9,

         char_class_word = 1 << 10,

         char_class_unicode = 1 << 11,

         char_class_horizontal = 1 << 12,

         char_class_vertical = 1 << 13

      };

   }

BOOST_REGEX_MODULE_EXPORT template <class charT>

struct c_regex_traits;

BOOST_REGEX_MODULE_EXPORT template<>

struct c_regex_traits<char>

{

   c_regex_traits(){}

   typedef char char_type;

   typedef std::size_t size_type;

   typedef std::string string_type;

   struct locale_type{};

   typedef std::uint32_t char_class_type;

   static size_type length(const char_type* p) 

   { 

      return (std::strlen)(p); 

   }

   char translate(char c) const 

   { 

      return c; 

   }

   char translate_nocase(char c) const 

   { 

      return static_cast<char>((std::tolower)(static_cast<unsigned char>(c))); 

   }

   static string_type  transform(const char* p1, const char* p2);

   static string_type  transform_primary(const char* p1, const char* p2);

   static char_class_type  lookup_classname(const char* p1, const char* p2);

   static string_type  lookup_collatename(const char* p1, const char* p2);

   static bool  isctype(char, char_class_type);

   static int  value(char, int);

   locale_type imbue(locale_type l)

   { return l; }

   locale_type getloc()const

   { return locale_type(); }

private:

   // this type is not copyable:

   c_regex_traits(const c_regex_traits&);

   c_regex_traits& operator=(const c_regex_traits&);

};

#ifndef BOOST_NO_WREGEX

BOOST_REGEX_MODULE_EXPORT template<>

struct c_regex_traits<wchar_t>

{

   c_regex_traits(){}

   typedef wchar_t char_type;

   typedef std::size_t size_type;

   typedef std::wstring string_type;

   struct locale_type{};

   typedef std::uint32_t char_class_type;

   static size_type length(const char_type* p) 

   { 

      return (std::wcslen)(p); 

   }

   wchar_t translate(wchar_t c) const 

   { 

      return c; 

   }

   wchar_t translate_nocase(wchar_t c) const 

   { 

      return (std::towlower)(c); 

   }

   static string_type  transform(const wchar_t* p1, const wchar_t* p2);

   static string_type  transform_primary(const wchar_t* p1, const wchar_t* p2);

   static char_class_type  lookup_classname(const wchar_t* p1, const wchar_t* p2);

   static string_type  lookup_collatename(const wchar_t* p1, const wchar_t* p2);

   static bool  isctype(wchar_t, char_class_type);

   static int  value(wchar_t, int);

   locale_type imbue(locale_type l)

   { return l; }

   locale_type getloc()const

   { return locale_type(); }

private:

   // this type is not copyable:

   c_regex_traits(const c_regex_traits&);

   c_regex_traits& operator=(const c_regex_traits&);

};

#endif // BOOST_NO_WREGEX

inline c_regex_traits<char>::string_type  c_regex_traits<char>::transform(const char* p1, const char* p2)

{

   std::string result(10, ' ');

   std::size_t s = result.size();

   std::size_t r;

   std::string src(p1, p2);

   while (s < (r = std::strxfrm(&*result.begin(), src.c_str(), s)))

   {

#if defined(_CPPLIB_VER)

      //

      // A bug in VC11 and 12 causes the program to hang if we pass a null-string

      // to std::strxfrm, but only for certain locales :-(

      // Probably effects Intel and Clang or any compiler using the VC std library (Dinkumware).

      //

      if (r == INT_MAX)

      {

         result.erase();

         result.insert(result.begin(), static_cast<char>(0));

         return result;

      }

#endif

      result.append(r - s + 3, ' ');

      s = result.size();

   }

   result.erase(r);

   return result;

}

inline c_regex_traits<char>::string_type  c_regex_traits<char>::transform_primary(const char* p1, const char* p2)

{

   static char s_delim;

   static const int s_collate_type = ::boost::BOOST_REGEX_DETAIL_NS::find_sort_syntax(static_cast<c_regex_traits<char>*>(0), &s_delim);

   std::string result;

   //

   // What we do here depends upon the format of the sort key returned by

   // sort key returned by this->transform:

   //

   switch (s_collate_type)

   {

   case ::boost::BOOST_REGEX_DETAIL_NS::sort_C:

   case ::boost::BOOST_REGEX_DETAIL_NS::sort_unknown:

      // the best we can do is translate to lower case, then get a regular sort key:

   {

      result.assign(p1, p2);

      for (std::string::size_type i = 0; i < result.size(); ++i)

         result[i] = static_cast<char>((std::tolower)(static_cast<unsigned char>(result[i])));

      result = transform(&*result.begin(), &*result.begin() + result.size());

      break;

   }

   case ::boost::BOOST_REGEX_DETAIL_NS::sort_fixed:

   {

      // get a regular sort key, and then truncate it:

      result = transform(p1, p2);

      result.erase(s_delim);

      break;

   }

   case ::boost::BOOST_REGEX_DETAIL_NS::sort_delim:

      // get a regular sort key, and then truncate everything after the delim:

      result = transform(p1, p2);

      if ((!result.empty()) && (result[0] == s_delim))

         break;

      std::size_t i;

      for (i = 0; i < result.size(); ++i)

      {

         if (result[i] == s_delim)

            break;

      }

      result.erase(i);

      break;

   }

   if (result.empty())

      result = std::string(1, char(0));

   return result;

}

inline c_regex_traits<char>::char_class_type  c_regex_traits<char>::lookup_classname(const char* p1, const char* p2)

{

   using namespace BOOST_REGEX_DETAIL_NS;

   static const char_class_type masks[] =

   {

      0,

      char_class_alnum,

      char_class_alpha,

      char_class_blank,

      char_class_cntrl,

      char_class_digit,

      char_class_digit,

      char_class_graph,

      char_class_horizontal,

      char_class_lower,

      char_class_lower,

      char_class_print,

      char_class_punct,

      char_class_space,

      char_class_space,

      char_class_upper,

      char_class_unicode,

      char_class_upper,

      char_class_vertical,

      char_class_alnum | char_class_word,

      char_class_alnum | char_class_word,

      char_class_xdigit,

   };

   int idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(p1, p2);

   if (idx < 0)

   {

      std::string s(p1, p2);

      for (std::string::size_type i = 0; i < s.size(); ++i)

         s[i] = static_cast<char>((std::tolower)(static_cast<unsigned char>(s[i])));

      idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(&*s.begin(), &*s.begin() + s.size());

   }

   BOOST_REGEX_ASSERT(std::size_t(idx) + 1u < sizeof(masks) / sizeof(masks[0]));

   return masks[idx + 1];

}

Unexecuted instantiation: boost::c_regex_traits<char>::lookup_classname(char const*, char const*)

Unexecuted instantiation: boost::c_regex_traits<char>::lookup_classname(char const*, char const*)

inline bool  c_regex_traits<char>::isctype(char c, char_class_type mask)

{

   using namespace BOOST_REGEX_DETAIL_NS;

   return

      ((mask & char_class_space) && (std::isspace)(static_cast<unsigned char>(c)))

      || ((mask & char_class_print) && (std::isprint)(static_cast<unsigned char>(c)))

      || ((mask & char_class_cntrl) && (std::iscntrl)(static_cast<unsigned char>(c)))

      || ((mask & char_class_upper) && (std::isupper)(static_cast<unsigned char>(c)))

      || ((mask & char_class_lower) && (std::islower)(static_cast<unsigned char>(c)))

      || ((mask & char_class_alpha) && (std::isalpha)(static_cast<unsigned char>(c)))

      || ((mask & char_class_digit) && (std::isdigit)(static_cast<unsigned char>(c)))

      || ((mask & char_class_punct) && (std::ispunct)(static_cast<unsigned char>(c)))

      || ((mask & char_class_xdigit) && (std::isxdigit)(static_cast<unsigned char>(c)))

      || ((mask & char_class_blank) && (std::isspace)(static_cast<unsigned char>(c)) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c))

      || ((mask & char_class_word) && (c == '_'))

      || ((mask & char_class_vertical) && (::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) || (c == '\v')))

      || ((mask & char_class_horizontal) && (std::isspace)(static_cast<unsigned char>(c)) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) && (c != '\v'));

}

inline c_regex_traits<char>::string_type  c_regex_traits<char>::lookup_collatename(const char* p1, const char* p2)

{

   std::string s(p1, p2);

   s = ::boost::BOOST_REGEX_DETAIL_NS::lookup_default_collate_name(s);

   if (s.empty() && (p2 - p1 == 1))

      s.append(1, *p1);

   return s;

}

inline int  c_regex_traits<char>::value(char c, int radix)

{

   char b[2] = { c, '\0', };

   char* ep;

   int result = std::strtol(b, &ep, radix);

   if (ep == b)

      return -1;

   return result;

}

#ifndef BOOST_NO_WREGEX

inline c_regex_traits<wchar_t>::string_type  c_regex_traits<wchar_t>::transform(const wchar_t* p1, const wchar_t* p2)

{

   std::size_t r;

   std::size_t s = 10;

   std::wstring src(p1, p2);

   std::wstring result(s, L' ');

   while (s < (r = std::wcsxfrm(&*result.begin(), src.c_str(), s)))

   {

#if defined(_CPPLIB_VER)

      //

      // A bug in VC11 and 12 causes the program to hang if we pass a null-string

      // to std::strxfrm, but only for certain locales :-(

      // Probably effects Intel and Clang or any compiler using the VC std library (Dinkumware).

      //

      if (r == INT_MAX)

      {

         result.erase();

         result.insert(result.begin(), static_cast<wchar_t>(0));

         return result;

      }

#endif

      result.append(r - s + 3, L' ');

      s = result.size();

   }

   result.erase(r);

   return result;

}

inline c_regex_traits<wchar_t>::string_type  c_regex_traits<wchar_t>::transform_primary(const wchar_t* p1, const wchar_t* p2)

{

   static wchar_t s_delim;

   static const int s_collate_type = ::boost::BOOST_REGEX_DETAIL_NS::find_sort_syntax(static_cast<const c_regex_traits<wchar_t>*>(0), &s_delim);

   std::wstring result;

   //

   // What we do here depends upon the format of the sort key returned by

   // sort key returned by this->transform:

   //

   switch (s_collate_type)

   {

   case ::boost::BOOST_REGEX_DETAIL_NS::sort_C:

   case ::boost::BOOST_REGEX_DETAIL_NS::sort_unknown:

      // the best we can do is translate to lower case, then get a regular sort key:

   {

      result.assign(p1, p2);

      for (std::wstring::size_type i = 0; i < result.size(); ++i)

         result[i] = (std::towlower)(result[i]);

      result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());

      break;

   }

   case ::boost::BOOST_REGEX_DETAIL_NS::sort_fixed:

   {

      // get a regular sort key, and then truncate it:

      result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());

      result.erase(s_delim);

      break;

   }

   case ::boost::BOOST_REGEX_DETAIL_NS::sort_delim:

      // get a regular sort key, and then truncate everything after the delim:

      result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());

      if ((!result.empty()) && (result[0] == s_delim))

         break;

      std::size_t i;

      for (i = 0; i < result.size(); ++i)

      {

         if (result[i] == s_delim)

            break;

      }

      result.erase(i);

      break;

   }

   if (result.empty())

      result = std::wstring(1, char(0));

   return result;

}

inline c_regex_traits<wchar_t>::char_class_type  c_regex_traits<wchar_t>::lookup_classname(const wchar_t* p1, const wchar_t* p2)

{

   using namespace BOOST_REGEX_DETAIL_NS;

   static const char_class_type masks[] =

   {

      0,

      char_class_alnum,

      char_class_alpha,

      char_class_blank,

      char_class_cntrl,

      char_class_digit,

      char_class_digit,

      char_class_graph,

      char_class_horizontal,

      char_class_lower,

      char_class_lower,

      char_class_print,

      char_class_punct,

      char_class_space,

      char_class_space,

      char_class_upper,

      char_class_unicode,

      char_class_upper,

      char_class_vertical,

      char_class_alnum | char_class_word,

      char_class_alnum | char_class_word,

      char_class_xdigit,

   };

   int idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(p1, p2);

   if (idx < 0)

   {

      std::wstring s(p1, p2);

      for (std::wstring::size_type i = 0; i < s.size(); ++i)

         s[i] = (std::towlower)(s[i]);

      idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(&*s.begin(), &*s.begin() + s.size());

   }

   BOOST_REGEX_ASSERT(idx + 1 < static_cast<int>(sizeof(masks) / sizeof(masks[0])));

   return masks[idx + 1];

}

Unexecuted instantiation: boost::c_regex_traits<wchar_t>::lookup_classname(wchar_t const*, wchar_t const*)

Unexecuted instantiation: boost::c_regex_traits<wchar_t>::lookup_classname(wchar_t const*, wchar_t const*)

inline bool  c_regex_traits<wchar_t>::isctype(wchar_t c, char_class_type mask)

{

   using namespace BOOST_REGEX_DETAIL_NS;

   return

      ((mask & char_class_space) && (std::iswspace)(c))

      || ((mask & char_class_print) && (std::iswprint)(c))

      || ((mask & char_class_cntrl) && (std::iswcntrl)(c))

      || ((mask & char_class_upper) && (std::iswupper)(c))

      || ((mask & char_class_lower) && (std::iswlower)(c))

      || ((mask & char_class_alpha) && (std::iswalpha)(c))

      || ((mask & char_class_digit) && (std::iswdigit)(c))

      || ((mask & char_class_punct) && (std::iswpunct)(c))

      || ((mask & char_class_xdigit) && (std::iswxdigit)(c))

      || ((mask & char_class_blank) && (std::iswspace)(c) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c))

      || ((mask & char_class_word) && (c == '_'))

      || ((mask & char_class_unicode) && (c & ~static_cast<wchar_t>(0xff)))

      || ((mask & char_class_vertical) && (::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) || (c == L'\v')))

      || ((mask & char_class_horizontal) && (std::iswspace)(c) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) && (c != L'\v'));

}

inline c_regex_traits<wchar_t>::string_type  c_regex_traits<wchar_t>::lookup_collatename(const wchar_t* p1, const wchar_t* p2)

{

   std::string name;

   // Usual msvc warning suppression does not work here with std::string template constructor.... use a workaround instead:

   for (const wchar_t* pos = p1; pos != p2; ++pos)

      name.push_back((char)*pos);

   name = ::boost::BOOST_REGEX_DETAIL_NS::lookup_default_collate_name(name);

   if (!name.empty())

      return string_type(name.begin(), name.end());

   if (p2 - p1 == 1)

      return string_type(1, *p1);

   return string_type();

}

inline int  c_regex_traits<wchar_t>::value(wchar_t c, int radix)

{

#ifdef BOOST_BORLANDC

   // workaround for broken wcstol:

   if ((std::iswxdigit)(c) == 0)

      return -1;

#endif

   wchar_t b[2] = { c, '\0', };

   wchar_t* ep;

   int result = std::wcstol(b, &ep, radix);

   if (ep == b)

      return -1;

   return result;

}

#endif

}

#endif