[857] | 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 __HP_aCC
|
---|
| 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 | return ((p2 - p1) == (r.p2 - r.p1)) && std::equal(p1, p2, r.p1);
|
---|
| 146 | }
|
---|
| 147 | };
|
---|
| 148 | template <class charT>
|
---|
| 149 | int get_default_class_id(const charT* p1, const charT* p2)
|
---|
| 150 | {
|
---|
| 151 | static const charT data[72] = {
|
---|
| 152 | 'a', 'l', 'n', 'u', 'm',
|
---|
| 153 | 'a', 'l', 'p', 'h', 'a',
|
---|
| 154 | 'b', 'l', 'a', 'n', 'k',
|
---|
| 155 | 'c', 'n', 't', 'r', 'l',
|
---|
| 156 | 'd', 'i', 'g', 'i', 't',
|
---|
| 157 | 'g', 'r', 'a', 'p', 'h',
|
---|
| 158 | 'l', 'o', 'w', 'e', 'r',
|
---|
| 159 | 'p', 'r', 'i', 'n', 't',
|
---|
| 160 | 'p', 'u', 'n', 'c', 't',
|
---|
| 161 | 's', 'p', 'a', 'c', 'e',
|
---|
| 162 | 'u', 'n', 'i', 'c', 'o', 'd', 'e',
|
---|
| 163 | 'u', 'p', 'p', 'e', 'r',
|
---|
| 164 | 'w', 'o', 'r', 'd',
|
---|
| 165 | 'x', 'd', 'i', 'g', 'i', 't',
|
---|
| 166 | };
|
---|
| 167 |
|
---|
| 168 | static const character_pointer_range<charT> ranges[19] =
|
---|
| 169 | {
|
---|
| 170 | {data+0, data+5,}, // alnum
|
---|
| 171 | {data+5, data+10,}, // alpha
|
---|
| 172 | {data+10, data+15,}, // blank
|
---|
| 173 | {data+15, data+20,}, // cntrl
|
---|
| 174 | {data+20, data+21,}, // d
|
---|
| 175 | {data+20, data+25,}, // digit
|
---|
| 176 | {data+25, data+30,}, // graph
|
---|
| 177 | {data+30, data+31,}, // l
|
---|
| 178 | {data+30, data+35,}, // lower
|
---|
| 179 | {data+35, data+40,}, // print
|
---|
| 180 | {data+40, data+45,}, // punct
|
---|
| 181 | {data+45, data+46,}, // s
|
---|
| 182 | {data+45, data+50,}, // space
|
---|
| 183 | {data+57, data+58,}, // u
|
---|
| 184 | {data+50, data+57,}, // unicode
|
---|
| 185 | {data+57, data+62,}, // upper
|
---|
| 186 | {data+62, data+63,}, // w
|
---|
| 187 | {data+62, data+66,}, // word
|
---|
| 188 | {data+66, data+72,}, // xdigit
|
---|
| 189 | };
|
---|
| 190 | static const character_pointer_range<charT>* ranges_begin = ranges;
|
---|
| 191 | static const character_pointer_range<charT>* ranges_end = ranges + (sizeof(ranges)/sizeof(ranges[0]));
|
---|
| 192 |
|
---|
| 193 | character_pointer_range<charT> t = { p1, p2, };
|
---|
| 194 | const character_pointer_range<charT>* p = std::lower_bound(ranges_begin, ranges_end, t);
|
---|
| 195 | if((p != ranges_end) && (t == *p))
|
---|
| 196 | return static_cast<int>(p - ranges);
|
---|
| 197 | return -1;
|
---|
| 198 | }
|
---|
| 199 |
|
---|
| 200 | //
|
---|
| 201 | // helper functions:
|
---|
| 202 | //
|
---|
| 203 | template <class charT>
|
---|
| 204 | std::ptrdiff_t global_length(const charT* p)
|
---|
| 205 | {
|
---|
| 206 | std::ptrdiff_t n = 0;
|
---|
| 207 | while(*p)
|
---|
| 208 | {
|
---|
| 209 | ++p;
|
---|
| 210 | ++n;
|
---|
| 211 | }
|
---|
| 212 | return n;
|
---|
| 213 | }
|
---|
| 214 | template<>
|
---|
| 215 | inline std::ptrdiff_t global_length<char>(const char* p)
|
---|
| 216 | {
|
---|
| 217 | return (std::strlen)(p);
|
---|
| 218 | }
|
---|
| 219 | #ifndef BOOST_NO_WREGEX
|
---|
| 220 | template<>
|
---|
| 221 | inline std::ptrdiff_t global_length<wchar_t>(const wchar_t* p)
|
---|
| 222 | {
|
---|
| 223 | return (std::wcslen)(p);
|
---|
| 224 | }
|
---|
| 225 | #endif
|
---|
| 226 | template <class charT>
|
---|
| 227 | inline charT BOOST_REGEX_CALL global_lower(charT c)
|
---|
| 228 | {
|
---|
| 229 | return c;
|
---|
| 230 | }
|
---|
| 231 | template <class charT>
|
---|
| 232 | inline charT BOOST_REGEX_CALL global_upper(charT c)
|
---|
| 233 | {
|
---|
| 234 | return c;
|
---|
| 235 | }
|
---|
| 236 |
|
---|
| 237 | BOOST_REGEX_DECL char BOOST_REGEX_CALL do_global_lower(char c);
|
---|
| 238 | BOOST_REGEX_DECL char BOOST_REGEX_CALL do_global_upper(char c);
|
---|
| 239 | #ifndef BOOST_NO_WREGEX
|
---|
| 240 | BOOST_REGEX_DECL wchar_t BOOST_REGEX_CALL do_global_lower(wchar_t c);
|
---|
| 241 | BOOST_REGEX_DECL wchar_t BOOST_REGEX_CALL do_global_upper(wchar_t c);
|
---|
| 242 | #endif
|
---|
| 243 | #ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
|
---|
| 244 | BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL do_global_lower(unsigned short c);
|
---|
| 245 | BOOST_REGEX_DECL unsigned short BOOST_REGEX_CALL do_global_upper(unsigned short c);
|
---|
| 246 | #endif
|
---|
| 247 | //
|
---|
| 248 | // This sucks: declare template specialisations of global_lower/global_upper
|
---|
| 249 | // that just forward to the non-template implementation functions. We do
|
---|
| 250 | // this because there is one compiler (Compaq Tru64 C++) that doesn't seem
|
---|
| 251 | // to differentiate between templates and non-template overloads....
|
---|
| 252 | // what's more, the primary template, plus all overloads have to be
|
---|
| 253 | // defined in the same translation unit (if one is inline they all must be)
|
---|
| 254 | // otherwise the "local template instantiation" compiler option can pick
|
---|
| 255 | // the wrong instantiation when linking:
|
---|
| 256 | //
|
---|
| 257 | template<> inline char BOOST_REGEX_CALL global_lower<char>(char c){ return do_global_lower(c); }
|
---|
| 258 | template<> inline char BOOST_REGEX_CALL global_upper<char>(char c){ return do_global_upper(c); }
|
---|
| 259 | #ifndef BOOST_NO_WREGEX
|
---|
| 260 | template<> inline wchar_t BOOST_REGEX_CALL global_lower<wchar_t>(wchar_t c){ return do_global_lower(c); }
|
---|
| 261 | template<> inline wchar_t BOOST_REGEX_CALL global_upper<wchar_t>(wchar_t c){ return do_global_upper(c); }
|
---|
| 262 | #endif
|
---|
| 263 | #ifdef BOOST_REGEX_HAS_OTHER_WCHAR_T
|
---|
| 264 | template<> inline unsigned short BOOST_REGEX_CALL global_lower<unsigned short>(unsigned short c){ return do_global_lower(c); }
|
---|
| 265 | template<> inline unsigned short BOOST_REGEX_CALL global_upper<unsigned short>(unsigned short c){ return do_global_upper(c); }
|
---|
| 266 | #endif
|
---|
| 267 |
|
---|
| 268 | template <class charT>
|
---|
| 269 | int global_value(charT c)
|
---|
| 270 | {
|
---|
| 271 | static const charT zero = '0';
|
---|
| 272 | static const charT nine = '9';
|
---|
| 273 | static const charT a = 'a';
|
---|
| 274 | static const charT f = 'f';
|
---|
| 275 | static const charT A = 'A';
|
---|
| 276 | static const charT F = 'F';
|
---|
| 277 |
|
---|
| 278 | if(c > f) return -1;
|
---|
| 279 | if(c >= a) return 10 + (c - a);
|
---|
| 280 | if(c > F) return -1;
|
---|
| 281 | if(c >= A) return 10 + (c - A);
|
---|
| 282 | if(c > nine) return -1;
|
---|
| 283 | if(c >= zero) return c - zero;
|
---|
| 284 | return -1;
|
---|
| 285 | }
|
---|
| 286 | template <class charT, class traits>
|
---|
| 287 | int global_toi(const charT*& p1, const charT* p2, int radix, const traits& t)
|
---|
| 288 | {
|
---|
| 289 | (void)t; // warning suppression
|
---|
| 290 | int next_value = t.value(*p1, radix);
|
---|
| 291 | if((p1 == p2) || (next_value < 0) || (next_value >= radix))
|
---|
| 292 | return -1;
|
---|
| 293 | int result = 0;
|
---|
| 294 | while(p1 != p2)
|
---|
| 295 | {
|
---|
| 296 | next_value = t.value(*p1, radix);
|
---|
| 297 | if((next_value < 0) || (next_value >= radix))
|
---|
| 298 | break;
|
---|
| 299 | result *= radix;
|
---|
| 300 | result += next_value;
|
---|
| 301 | ++p1;
|
---|
| 302 | }
|
---|
| 303 | return result;
|
---|
| 304 | }
|
---|
| 305 |
|
---|
| 306 | } // re_detail
|
---|
| 307 | } // boost
|
---|
| 308 |
|
---|
| 309 | #ifdef BOOST_HAS_ABI_HEADERS
|
---|
| 310 | # include BOOST_ABI_SUFFIX
|
---|
| 311 | #endif
|
---|
| 312 |
|
---|
| 313 | #endif
|
---|