ceph/src/boost/boost/regex/v4/c_regex_traits.hpp

   1 /*
   2  *
   3  * Copyright (c) 2004
   4  * John Maddock
   5  *
   6  * Use, modification and distribution are subject to the
   7  * Boost Software License, Version 1.0. (See accompanying file
   8  * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9  *
  10  */
  11
  12  /*
  13   *   LOCATION:    see http://www.boost.org for most recent version.
  14   *   FILE         c_regex_traits.hpp
  15   *   VERSION      see <boost/version.hpp>
  16   *   DESCRIPTION: Declares regular expression traits class that wraps the global C locale.
  17   */
  18
  19 #ifndef BOOST_C_REGEX_TRAITS_HPP_INCLUDED
  20 #define BOOST_C_REGEX_TRAITS_HPP_INCLUDED
  21
  22 #ifndef BOOST_REGEX_CONFIG_HPP
  23 #include <boost/regex/config.hpp>
  24 #endif
  25 #ifndef BOOST_REGEX_WORKAROUND_HPP
  26 #include <boost/regex/v4/regex_workaround.hpp>
  27 #endif
  28
  29 #include <cctype>
  30
  31 #ifdef BOOST_NO_STDC_NAMESPACE
  32 namespace std{
  33    using ::strlen; using ::tolower;
  34 }
  35 #endif
  36
  37 #ifdef BOOST_MSVC
  38 #pragma warning(push)
  39 #pragma warning(disable: 4103 4244)
  40 #endif
  41 #ifdef BOOST_HAS_ABI_HEADERS
  42 #  include BOOST_ABI_PREFIX
  43 #endif
  44 #ifdef BOOST_MSVC
  45 #pragma warning(pop)
  46 #endif
  47
  48 namespace boost{
  49
  50    namespace BOOST_REGEX_DETAIL_NS {
  51
  52       enum
  53       {
  54          char_class_space = 1 << 0,
  55          char_class_print = 1 << 1,
  56          char_class_cntrl = 1 << 2,
  57          char_class_upper = 1 << 3,
  58          char_class_lower = 1 << 4,
  59          char_class_alpha = 1 << 5,
  60          char_class_digit = 1 << 6,
  61          char_class_punct = 1 << 7,
  62          char_class_xdigit = 1 << 8,
  63          char_class_alnum = char_class_alpha | char_class_digit,
  64          char_class_graph = char_class_alnum | char_class_punct,
  65          char_class_blank = 1 << 9,
  66          char_class_word = 1 << 10,
  67          char_class_unicode = 1 << 11,
  68          char_class_horizontal = 1 << 12,
  69          char_class_vertical = 1 << 13
  70       };
  71
  72    }
  73
  74 template <class charT>
  75 struct c_regex_traits;
  76
  77 template<>
  78 struct c_regex_traits<char>
  79 {
  80    c_regex_traits(){}
  81    typedef char char_type;
  82    typedef std::size_t size_type;
  83    typedef std::string string_type;
  84    struct locale_type{};
  85    typedef boost::uint32_t char_class_type;
  86
  87    static size_type length(const char_type* p)
  88    {
  89       return (std::strlen)(p);
  90    }
  91
  92    char translate(char c) const
  93    {
  94       return c;
  95    }
  96    char translate_nocase(char c) const
  97    {
  98       return static_cast<char>((std::tolower)(static_cast<unsigned char>(c)));
  99    }
 100
 101    static string_type BOOST_REGEX_CALL transform(const char* p1, const char* p2);
 102    static string_type BOOST_REGEX_CALL transform_primary(const char* p1, const char* p2);
 103
 104    static char_class_type BOOST_REGEX_CALL lookup_classname(const char* p1, const char* p2);
 105    static string_type BOOST_REGEX_CALL lookup_collatename(const char* p1, const char* p2);
 106
 107    static bool BOOST_REGEX_CALL isctype(char, char_class_type);
 108    static int BOOST_REGEX_CALL value(char, int);
 109
 110    locale_type imbue(locale_type l)
 111    { return l; }
 112    locale_type getloc()const
 113    { return locale_type(); }
 114
 115 private:
 116    // this type is not copyable:
 117    c_regex_traits(const c_regex_traits&);
 118    c_regex_traits& operator=(const c_regex_traits&);
 119 };
 120
 121 #ifndef BOOST_NO_WREGEX
 122 template<>
 123 struct c_regex_traits<wchar_t>
 124 {
 125    c_regex_traits(){}
 126    typedef wchar_t char_type;
 127    typedef std::size_t size_type;
 128    typedef std::wstring string_type;
 129    struct locale_type{};
 130    typedef boost::uint32_t char_class_type;
 131
 132    static size_type length(const char_type* p)
 133    {
 134       return (std::wcslen)(p);
 135    }
 136
 137    wchar_t translate(wchar_t c) const
 138    {
 139       return c;
 140    }
 141    wchar_t translate_nocase(wchar_t c) const
 142    {
 143       return (std::towlower)(c);
 144    }
 145
 146    static string_type BOOST_REGEX_CALL transform(const wchar_t* p1, const wchar_t* p2);
 147    static string_type BOOST_REGEX_CALL transform_primary(const wchar_t* p1, const wchar_t* p2);
 148
 149    static char_class_type BOOST_REGEX_CALL lookup_classname(const wchar_t* p1, const wchar_t* p2);
 150    static string_type BOOST_REGEX_CALL lookup_collatename(const wchar_t* p1, const wchar_t* p2);
 151
 152    static bool BOOST_REGEX_CALL isctype(wchar_t, char_class_type);
 153    static int BOOST_REGEX_CALL value(wchar_t, int);
 154
 155    locale_type imbue(locale_type l)
 156    { return l; }
 157    locale_type getloc()const
 158    { return locale_type(); }
 159
 160 private:
 161    // this type is not copyable:
 162    c_regex_traits(const c_regex_traits&);
 163    c_regex_traits& operator=(const c_regex_traits&);
 164 };
 165
 166 #endif // BOOST_NO_WREGEX
 167
 168 inline c_regex_traits<char>::string_type BOOST_REGEX_CALL c_regex_traits<char>::transform(const char* p1, const char* p2)
 169 {
 170    std::string result(10, ' ');
 171    std::size_t s = result.size();
 172    std::size_t r;
 173    std::string src(p1, p2);
 174    while (s < (r = std::strxfrm(&*result.begin(), src.c_str(), s)))
 175    {
 176 #if defined(_CPPLIB_VER)
 177       //
 178       // A bug in VC11 and 12 causes the program to hang if we pass a null-string
 179       // to std::strxfrm, but only for certain locales :-(
 180       // Probably effects Intel and Clang or any compiler using the VC std library (Dinkumware).
 181       //
 182       if (r == INT_MAX)
 183       {
 184          result.erase();
 185          result.insert(result.begin(), static_cast<char>(0));
 186          return result;
 187       }
 188 #endif
 189       result.append(r - s + 3, ' ');
 190       s = result.size();
 191    }
 192    result.erase(r);
 193    return result;
 194 }
 195
 196 inline c_regex_traits<char>::string_type BOOST_REGEX_CALL c_regex_traits<char>::transform_primary(const char* p1, const char* p2)
 197 {
 198    static char s_delim;
 199    static const int s_collate_type = ::boost::BOOST_REGEX_DETAIL_NS::find_sort_syntax(static_cast<c_regex_traits<char>*>(0), &s_delim);
 200    std::string result;
 201    //
 202    // What we do here depends upon the format of the sort key returned by
 203    // sort key returned by this->transform:
 204    //
 205    switch (s_collate_type)
 206    {
 207    case ::boost::BOOST_REGEX_DETAIL_NS::sort_C:
 208    case ::boost::BOOST_REGEX_DETAIL_NS::sort_unknown:
 209       // the best we can do is translate to lower case, then get a regular sort key:
 210    {
 211       result.assign(p1, p2);
 212       for (std::string::size_type i = 0; i < result.size(); ++i)
 213          result[i] = static_cast<char>((std::tolower)(static_cast<unsigned char>(result[i])));
 214       result = transform(&*result.begin(), &*result.begin() + result.size());
 215       break;
 216    }
 217    case ::boost::BOOST_REGEX_DETAIL_NS::sort_fixed:
 218    {
 219       // get a regular sort key, and then truncate it:
 220       result = transform(p1, p2);
 221       result.erase(s_delim);
 222       break;
 223    }
 224    case ::boost::BOOST_REGEX_DETAIL_NS::sort_delim:
 225       // get a regular sort key, and then truncate everything after the delim:
 226       result = transform(p1, p2);
 227       if ((!result.empty()) && (result[0] == s_delim))
 228          break;
 229       std::size_t i;
 230       for (i = 0; i < result.size(); ++i)
 231       {
 232          if (result[i] == s_delim)
 233             break;
 234       }
 235       result.erase(i);
 236       break;
 237    }
 238    if (result.empty())
 239       result = std::string(1, char(0));
 240    return result;
 241 }
 242
 243 inline c_regex_traits<char>::char_class_type BOOST_REGEX_CALL c_regex_traits<char>::lookup_classname(const char* p1, const char* p2)
 244 {
 245    using namespace BOOST_REGEX_DETAIL_NS;
 246    static const char_class_type masks[] =
 247    {
 248       0,
 249       char_class_alnum,
 250       char_class_alpha,
 251       char_class_blank,
 252       char_class_cntrl,
 253       char_class_digit,
 254       char_class_digit,
 255       char_class_graph,
 256       char_class_horizontal,
 257       char_class_lower,
 258       char_class_lower,
 259       char_class_print,
 260       char_class_punct,
 261       char_class_space,
 262       char_class_space,
 263       char_class_upper,
 264       char_class_unicode,
 265       char_class_upper,
 266       char_class_vertical,
 267       char_class_alnum | char_class_word,
 268       char_class_alnum | char_class_word,
 269       char_class_xdigit,
 270    };
 271
 272    int idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(p1, p2);
 273    if (idx < 0)
 274    {
 275       std::string s(p1, p2);
 276       for (std::string::size_type i = 0; i < s.size(); ++i)
 277          s[i] = static_cast<char>((std::tolower)(static_cast<unsigned char>(s[i])));
 278       idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(&*s.begin(), &*s.begin() + s.size());
 279    }
 280    BOOST_REGEX_ASSERT(std::size_t(idx) + 1u < sizeof(masks) / sizeof(masks[0]));
 281    return masks[idx + 1];
 282 }
 283
 284 inline bool BOOST_REGEX_CALL c_regex_traits<char>::isctype(char c, char_class_type mask)
 285 {
 286    using namespace BOOST_REGEX_DETAIL_NS;
 287    return
 288       ((mask & char_class_space) && (std::isspace)(static_cast<unsigned char>(c)))
 289       || ((mask & char_class_print) && (std::isprint)(static_cast<unsigned char>(c)))
 290       || ((mask & char_class_cntrl) && (std::iscntrl)(static_cast<unsigned char>(c)))
 291       || ((mask & char_class_upper) && (std::isupper)(static_cast<unsigned char>(c)))
 292       || ((mask & char_class_lower) && (std::islower)(static_cast<unsigned char>(c)))
 293       || ((mask & char_class_alpha) && (std::isalpha)(static_cast<unsigned char>(c)))
 294       || ((mask & char_class_digit) && (std::isdigit)(static_cast<unsigned char>(c)))
 295       || ((mask & char_class_punct) && (std::ispunct)(static_cast<unsigned char>(c)))
 296       || ((mask & char_class_xdigit) && (std::isxdigit)(static_cast<unsigned char>(c)))
 297       || ((mask & char_class_blank) && (std::isspace)(static_cast<unsigned char>(c)) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c))
 298       || ((mask & char_class_word) && (c == '_'))
 299       || ((mask & char_class_vertical) && (::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) || (c == '\v')))
 300       || ((mask & char_class_horizontal) && (std::isspace)(static_cast<unsigned char>(c)) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) && (c != '\v'));
 301 }
 302
 303 inline c_regex_traits<char>::string_type BOOST_REGEX_CALL c_regex_traits<char>::lookup_collatename(const char* p1, const char* p2)
 304 {
 305    std::string s(p1, p2);
 306    s = ::boost::BOOST_REGEX_DETAIL_NS::lookup_default_collate_name(s);
 307    if (s.empty() && (p2 - p1 == 1))
 308       s.append(1, *p1);
 309    return s;
 310 }
 311
 312 inline int BOOST_REGEX_CALL c_regex_traits<char>::value(char c, int radix)
 313 {
 314    char b[2] = { c, '\0', };
 315    char* ep;
 316    int result = std::strtol(b, &ep, radix);
 317    if (ep == b)
 318       return -1;
 319    return result;
 320 }
 321
 322 #ifndef BOOST_NO_WREGEX
 323
 324 inline c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::transform(const wchar_t* p1, const wchar_t* p2)
 325 {
 326    std::size_t r;
 327    std::size_t s = 10;
 328    std::wstring src(p1, p2);
 329    std::wstring result(s, L' ');
 330    while (s < (r = std::wcsxfrm(&*result.begin(), src.c_str(), s)))
 331    {
 332 #if defined(_CPPLIB_VER)
 333       //
 334       // A bug in VC11 and 12 causes the program to hang if we pass a null-string
 335       // to std::strxfrm, but only for certain locales :-(
 336       // Probably effects Intel and Clang or any compiler using the VC std library (Dinkumware).
 337       //
 338       if (r == INT_MAX)
 339       {
 340          result.erase();
 341          result.insert(result.begin(), static_cast<wchar_t>(0));
 342          return result;
 343       }
 344 #endif
 345       result.append(r - s + 3, L' ');
 346       s = result.size();
 347    }
 348    result.erase(r);
 349    return result;
 350 }
 351
 352 inline c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::transform_primary(const wchar_t* p1, const wchar_t* p2)
 353 {
 354    static wchar_t s_delim;
 355    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);
 356    std::wstring result;
 357    //
 358    // What we do here depends upon the format of the sort key returned by
 359    // sort key returned by this->transform:
 360    //
 361    switch (s_collate_type)
 362    {
 363    case ::boost::BOOST_REGEX_DETAIL_NS::sort_C:
 364    case ::boost::BOOST_REGEX_DETAIL_NS::sort_unknown:
 365       // the best we can do is translate to lower case, then get a regular sort key:
 366    {
 367       result.assign(p1, p2);
 368       for (std::wstring::size_type i = 0; i < result.size(); ++i)
 369          result[i] = (std::towlower)(result[i]);
 370       result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());
 371       break;
 372    }
 373    case ::boost::BOOST_REGEX_DETAIL_NS::sort_fixed:
 374    {
 375       // get a regular sort key, and then truncate it:
 376       result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());
 377       result.erase(s_delim);
 378       break;
 379    }
 380    case ::boost::BOOST_REGEX_DETAIL_NS::sort_delim:
 381       // get a regular sort key, and then truncate everything after the delim:
 382       result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());
 383       if ((!result.empty()) && (result[0] == s_delim))
 384          break;
 385       std::size_t i;
 386       for (i = 0; i < result.size(); ++i)
 387       {
 388          if (result[i] == s_delim)
 389             break;
 390       }
 391       result.erase(i);
 392       break;
 393    }
 394    if (result.empty())
 395       result = std::wstring(1, char(0));
 396    return result;
 397 }
 398
 399 inline c_regex_traits<wchar_t>::char_class_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::lookup_classname(const wchar_t* p1, const wchar_t* p2)
 400 {
 401    using namespace BOOST_REGEX_DETAIL_NS;
 402    static const char_class_type masks[] =
 403    {
 404       0,
 405       char_class_alnum,
 406       char_class_alpha,
 407       char_class_blank,
 408       char_class_cntrl,
 409       char_class_digit,
 410       char_class_digit,
 411       char_class_graph,
 412       char_class_horizontal,
 413       char_class_lower,
 414       char_class_lower,
 415       char_class_print,
 416       char_class_punct,
 417       char_class_space,
 418       char_class_space,
 419       char_class_upper,
 420       char_class_unicode,
 421       char_class_upper,
 422       char_class_vertical,
 423       char_class_alnum | char_class_word,
 424       char_class_alnum | char_class_word,
 425       char_class_xdigit,
 426    };
 427
 428    int idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(p1, p2);
 429    if (idx < 0)
 430    {
 431       std::wstring s(p1, p2);
 432       for (std::wstring::size_type i = 0; i < s.size(); ++i)
 433          s[i] = (std::towlower)(s[i]);
 434       idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(&*s.begin(), &*s.begin() + s.size());
 435    }
 436    BOOST_REGEX_ASSERT(idx + 1 < static_cast<int>(sizeof(masks) / sizeof(masks[0])));
 437    return masks[idx + 1];
 438 }
 439
 440 inline bool BOOST_REGEX_CALL c_regex_traits<wchar_t>::isctype(wchar_t c, char_class_type mask)
 441 {
 442    using namespace BOOST_REGEX_DETAIL_NS;
 443    return
 444       ((mask & char_class_space) && (std::iswspace)(c))
 445       || ((mask & char_class_print) && (std::iswprint)(c))
 446       || ((mask & char_class_cntrl) && (std::iswcntrl)(c))
 447       || ((mask & char_class_upper) && (std::iswupper)(c))
 448       || ((mask & char_class_lower) && (std::iswlower)(c))
 449       || ((mask & char_class_alpha) && (std::iswalpha)(c))
 450       || ((mask & char_class_digit) && (std::iswdigit)(c))
 451       || ((mask & char_class_punct) && (std::iswpunct)(c))
 452       || ((mask & char_class_xdigit) && (std::iswxdigit)(c))
 453       || ((mask & char_class_blank) && (std::iswspace)(c) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c))
 454       || ((mask & char_class_word) && (c == '_'))
 455       || ((mask & char_class_unicode) && (c & ~static_cast<wchar_t>(0xff)))
 456       || ((mask & char_class_vertical) && (::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) || (c == L'\v')))
 457       || ((mask & char_class_horizontal) && (std::iswspace)(c) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) && (c != L'\v'));
 458 }
 459
 460 inline c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::lookup_collatename(const wchar_t* p1, const wchar_t* p2)
 461 {
 462 #ifdef BOOST_MSVC
 463 #pragma warning(push)
 464 #pragma warning(disable: 4244)
 465 #endif
 466    std::string name(p1, p2);
 467 #ifdef BOOST_MSVC
 468 #pragma warning(pop)
 469 #endif
 470    name = ::boost::BOOST_REGEX_DETAIL_NS::lookup_default_collate_name(name);
 471    if (!name.empty())
 472       return string_type(name.begin(), name.end());
 473    if (p2 - p1 == 1)
 474       return string_type(1, *p1);
 475    return string_type();
 476 }
 477
 478 inline int BOOST_REGEX_CALL c_regex_traits<wchar_t>::value(wchar_t c, int radix)
 479 {
 480 #ifdef BOOST_BORLANDC
 481    // workaround for broken wcstol:
 482    if ((std::iswxdigit)(c) == 0)
 483       return -1;
 484 #endif
 485    wchar_t b[2] = { c, '\0', };
 486    wchar_t* ep;
 487    int result = std::wcstol(b, &ep, radix);
 488    if (ep == b)
 489       return -1;
 490    return result;
 491 }
 492
 493 #endif
 494
 495 }
 496
 497 #ifdef BOOST_MSVC
 498 #pragma warning(push)
 499 #pragma warning(disable: 4103)
 500 #endif
 501 #ifdef BOOST_HAS_ABI_HEADERS
 502 #  include BOOST_ABI_SUFFIX
 503 #endif
 504 #ifdef BOOST_MSVC
 505 #pragma warning(pop)
 506 #endif
 507
 508 #endif
 509
 510
 511