boost/boost/regex/v4/regex_traits_defaults.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         regex_traits_defaults.hpp
  15   *   VERSION      see <boost/version.hpp>
  16   *   DESCRIPTION: Declares API's for access to regex_traits default properties.
  17   */
  18
  19 #ifndef BOOST_REGEX_TRAITS_DEFAULTS_HPP_INCLUDED
  20 #define BOOST_REGEX_TRAITS_DEFAULTS_HPP_INCLUDED
  21
  22 #ifdef BOOST_HAS_ABI_HEADERS
  23 #  include BOOST_ABI_PREFIX
  24 #endif
  25
  26 #ifndef BOOST_REGEX_SYNTAX_TYPE_HPP
  27 #include <boost/regex/v4/syntax_type.hpp>
  28 #endif
  29 #ifndef BOOST_REGEX_ERROR_TYPE_HPP
  30 #include <boost/regex/v4/error_type.hpp>
  31 #endif
  32
  33 #ifdef BOOST_NO_STDC_NAMESPACE
  34 namespace std{
  35    using ::strlen;
  36 }
  37 #endif
  38
  39 namespace boost{ namespace re_detail{
  40
  41
  42 //
  43 // helpers to suppress warnings:
  44 //
  45 template <class charT>
  46 inline bool is_extended(charT c)
  47 { return c > 256; }
  48 inline bool is_extended(char)
  49 { return false; }
  50
  51
  52 BOOST_REGEX_DECL const char* BOOST_REGEX_CALL get_default_syntax(regex_constants::syntax_type n);
  53 BOOST_REGEX_DECL const char* BOOST_REGEX_CALL get_default_error_string(regex_constants::error_type n);
  54 BOOST_REGEX_DECL regex_constants::syntax_type BOOST_REGEX_CALL get_default_syntax_type(char c);
  55 BOOST_REGEX_DECL regex_constants::escape_syntax_type BOOST_REGEX_CALL get_default_escape_syntax_type(char c);
  56
  57 // is charT c a combining character?
  58 BOOST_REGEX_DECL bool BOOST_REGEX_CALL is_combining_implementation(uint_least16_t s);
  59
  60 template <class charT>
  61 inline bool is_combining(charT c)
  62 {
  63    return (c <= static_cast<charT>(0)) ? false : ((c >= static_cast<charT>((std::numeric_limits<uint_least16_t>::max)())) ? false : is_combining_implementation(static_cast<unsigned short>(c)));
  64 }
  65 template <>
  66 inline bool is_combining<char>(char)
  67 {
  68    return false;
  69 }
  70 template <>
  71 inline bool is_combining<signed char>(signed char)
  72 {
  73    return false;
  74 }
  75 template <>
  76 inline bool is_combining<unsigned char>(unsigned char)
  77 {
  78    return false;
  79 }
  80 #ifndef __hpux // can't use WCHAR_MIN/MAX in pp-directives.
  81 #ifdef _MSC_VER
  82 template<>
  83 inline bool is_combining<wchar_t>(wchar_t c)
  84 {
  85    return is_combining_implementation(static_cast<unsigned short>(c));
  86 }
  87 #elif !defined(__DECCXX) && !defined(__osf__) && !defined(__OSF__) && defined(WCHAR_MIN) && (WCHAR_MIN == 0) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
  88 #if defined(WCHAR_MAX) && (WCHAR_MAX <= USHRT_MAX)
  89 template<>
  90 inline bool is_combining<wchar_t>(wchar_t c)
  91 {
  92    return is_combining_implementation(static_cast<unsigned short>(c));
  93 }
  94 #else
  95 template<>
  96 inline bool is_combining<wchar_t>(wchar_t c)
  97 {
  98    return (c >= (std::numeric_limits<uint_least16_t>::max)()) ? false : is_combining_implementation(static_cast<unsigned short>(c));
  99 }
 100 #endif
 101 #endif
 102 #endif
 103
 104 //
 105 // is a charT c a line separator?
 106 //
 107 template <class charT>
 108 inline bool is_separator(charT c)
 109 {
 110    return BOOST_REGEX_MAKE_BOOL(
 111       (c == static_cast<charT>('\n'))
 112       || (c == static_cast<charT>('\r'))
 113       || (c == static_cast<charT>('\f'))
 114       || (static_cast<boost::uint16_t>(c) == 0x2028u)
 115       || (static_cast<boost::uint16_t>(c) == 0x2029u)
 116       || (static_cast<boost::uint16_t>(c) == 0x85u));
 117 }
 118 template <>
 119 inline bool is_separator<char>(char c)
 120 {
 121    return BOOST_REGEX_MAKE_BOOL((c == '\n') || (c == '\r') || (c == '\f'));
 122 }
 123
 124 //
 125 // get a default collating element:
 126 //
 127 BOOST_REGEX_DECL std::string BOOST_REGEX_CALL lookup_default_collate_name(const std::string& name);
 128
 129 //
 130 // get the id of a character clasification, the individual
 131 // traits classes then transform that id into a bitmask:
 132 //
 133 template <class charT>
 134 struct character_pointer_range
 135 {
 136    const charT* p1;
 137    const charT* p2;
 138
 139    bool operator < (const character_pointer_range& r)const
 140    {
 141       return std::lexicographical_compare(p1, p2, r.p1, r.p2);
 142    }
 143    bool operator == (const character_pointer_range& r)const
 144    {
 145       // Not only do we check that the ranges are of equal size before
 146       // calling std::equal, but there is no other algorithm available:
 147       // not even a non-standard MS one.  So forward to unchecked_equal
 148       // in the MS case.
 149       return ((p2 - p1) == (r.p2 - r.p1)) && re_detail::equal(p1, p2, r.p1);
 150    }
 151 };
 152 template <class charT>
 153 int get_default_class_id(const charT* p1, const charT* p2)
 154 {
 155    static const charT data[72] = {
 156       'a', 'l', 'n', 'u', 'm',
 157       'a', 'l', 'p', 'h', 'a',
 158       'b', 'l', 'a', 'n', 'k',
 159       'c', 'n', 't', 'r', 'l',
 160       'd', 'i', 'g', 'i', 't',
 161       'g', 'r', 'a', 'p', 'h',
 162       'l', 'o', 'w', 'e', 'r',
 163       'p', 'r', 'i', 'n', 't',
 164       'p', 'u', 'n', 'c', 't',
 165       's', 'p', 'a', 'c', 'e',
 166       'u', 'n', 'i', 'c', 'o', 'd', 'e',
 167       'u', 'p', 'p', 'e', 'r',
 168       'w', 'o', 'r', 'd',
 169       'x', 'd', 'i', 'g', 'i', 't',
 170    };
 171
 172    static const character_pointer_range<charT> ranges[19] =
 173    {
 174       {data+0, data+5,}, // alnum
 175       {data+5, data+10,}, // alpha
 176       {data+10, data+15,}, // blank
 177       {data+15, data+20,}, // cntrl
 178       {data+20, data+21,}, // d
 179       {data+20, data+25,}, // digit
 180       {data+25, data+30,}, // graph
 181       {data+30, data+31,}, // l
 182       {data+30, data+35,}, // lower
 183       {data+35, data+40,}, // print
 184       {data+40, data+45,}, // punct
 185       {data+45, data+46,}, // s
 186       {data+45, data+50,}, // space
 187       {data+57, data+58,}, // u
 188       {data+50, data+57,}, // unicode
 189       {data+57, data+62,}, // upper
 190       {data+62, data+63,}, // w
 191       {data+62, data+66,}, // word
 192       {data+66, data+72,}, // xdigit
 193    };
 194    static const character_pointer_range<charT>* ranges_begin = ranges;
 195    static const character_pointer_range<charT>* ranges_end = ranges + (sizeof(ranges)/sizeof(ranges[0]));
 196
 197    character_pointer_range<charT> t = { p1, p2, };
 198    const character_pointer_range<charT>* p = std::lower_bound(ranges_begin, ranges_end, t);
 199    if((p != ranges_end) && (t == *p))
 200       return static_cast<int>(p - ranges);
 201    return -1;
 202 }
 203
 204 //
 205 // helper functions:
 206 //
 207 template <class charT>
 208 std::ptrdiff_t global_length(const charT* p)
 209 {
 210    std::ptrdiff_t n = 0;
 211    while(*p)
 212    {
 213       ++p;
 214       ++n;
 215    }
 216    return n;
 217 }
 218 template<>
 219 inline std::ptrdiff_t global_length<char>(const char* p)
 220 {
 221    return (std::strlen)(p);
 222 }
 223 #ifndef BOOST_NO_WREGEX
 224 template<>
 225 inline std::ptrdiff_t global_length<wchar_t>(const wchar_t* p)
 226 {
 227    return (std::wcslen)(p);
 228 }
 229 #endif
 230 template <class charT>
 231 inline charT BOOST_REGEX_CALL global_lower(charT c)
 232 {
 233    return c;
 234 }
 235 template <class charT>
 236 inline charT BOOST_REGEX_CALL global_upper(charT c)
 237 {
 238    return c;
 239 }
 240
 241 BOOST_REGEX_DECL char BOOST_REGEX_CALL do_global_lower(char c);
 242 BOOST_REGEX_DECL char BOOST_REGEX_CALL do_global_upper(char c);
 243 #ifndef BOOST_NO_WREGEX
 244 BOOST_REGEX_DECL wchar_t BOOST_REGEX_CALL do_global_lower(wchar_t c);
 245 BOOST_REGEX_DECL wchar_t BOOST_REGEX_CALL do_global_upper(wchar_t c);
 246 #endif
 247 #ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
 248 BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL do_global_lower(unsigned short c);
 249 BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL do_global_upper(unsigned short c);
 250 #endif
 251 //
 252 // This sucks: declare template specialisations of global_lower/global_upper
 253 // that just forward to the non-template implementation functions.  We do
 254 // this because there is one compiler (Compaq Tru64 C++) that doesn't seem
 255 // to differentiate between templates and non-template overloads....
 256 // what's more, the primary template, plus all overloads have to be
 257 // defined in the same translation unit (if one is inline they all must be)
 258 // otherwise the "local template instantiation" compiler option can pick
 259 // the wrong instantiation when linking:
 260 //
 261 template<> inline char BOOST_REGEX_CALL global_lower<char>(char c){ return do_global_lower(c); }
 262 template<> inline char BOOST_REGEX_CALL global_upper<char>(char c){ return do_global_upper(c); }
 263 #ifndef BOOST_NO_WREGEX
 264 template<> inline wchar_t BOOST_REGEX_CALL global_lower<wchar_t>(wchar_t c){ return do_global_lower(c); }
 265 template<> inline wchar_t BOOST_REGEX_CALL global_upper<wchar_t>(wchar_t c){ return do_global_upper(c); }
 266 #endif
 267 #ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
 268 template<> inline unsigned short BOOST_REGEX_CALL global_lower<unsigned short>(unsigned short c){ return do_global_lower(c); }
 269 template<> inline unsigned short BOOST_REGEX_CALL global_upper<unsigned short>(unsigned short c){ return do_global_upper(c); }
 270 #endif
 271
 272 template <class charT>
 273 int global_value(charT c)
 274 {
 275    static const charT zero = '0';
 276    static const charT nine = '9';
 277    static const charT a = 'a';
 278    static const charT f = 'f';
 279    static const charT A = 'A';
 280    static const charT F = 'F';
 281
 282    if(c > f) return -1;
 283    if(c >= a) return 10 + (c - a);
 284    if(c > F) return -1;
 285    if(c >= A) return 10 + (c - A);
 286    if(c > nine) return -1;
 287    if(c >= zero) return c - zero;
 288    return -1;
 289 }
 290 template <class charT, class traits>
 291 int global_toi(const charT*& p1, const charT* p2, int radix, const traits& t)
 292 {
 293    (void)t; // warning suppression
 294    int next_value = t.value(*p1, radix);
 295    if((p1 == p2) || (next_value < 0) || (next_value >= radix))
 296       return -1;
 297    int result = 0;
 298    while(p1 != p2)
 299    {
 300       next_value = t.value(*p1, radix);
 301       if((next_value < 0) || (next_value >= radix))
 302          break;
 303       result *= radix;
 304       result += next_value;
 305       ++p1;
 306    }
 307    return result;
 308 }
 309
 310 } // re_detail
 311 } // boost
 312
 313 #ifdef BOOST_HAS_ABI_HEADERS
 314 #  include BOOST_ABI_SUFFIX
 315 #endif
 316
 317 #endif