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)
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.
19 #ifndef BOOST_REGEX_TRAITS_DEFAULTS_HPP_INCLUDED
20 #define BOOST_REGEX_TRAITS_DEFAULTS_HPP_INCLUDED
22 #ifdef BOOST_HAS_ABI_HEADERS
23 # include BOOST_ABI_PREFIX
26 #ifndef BOOST_REGEX_SYNTAX_TYPE_HPP
27 #include <boost/regex/v4/syntax_type.hpp>
29 #ifndef BOOST_REGEX_ERROR_TYPE_HPP
30 #include <boost/regex/v4/error_type.hpp>
33 #ifdef BOOST_NO_STDC_NAMESPACE
39 namespace boost{ namespace re_detail{
43 // helpers to suppress warnings:
45 template <class charT>
46 inline bool is_extended(charT c)
48 inline bool is_extended(char)
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);
57 // is charT c a combining character?
58 BOOST_REGEX_DECL bool BOOST_REGEX_CALL is_combining_implementation(uint_least16_t s);
60 template <class charT>
61 inline bool is_combining(charT c)
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)));
66 inline bool is_combining<char>(char)
71 inline bool is_combining<signed char>(signed char)
76 inline bool is_combining<unsigned char>(unsigned char)
80 #ifndef __hpux // can't use WCHAR_MIN/MAX in pp-directives.
83 inline bool is_combining<wchar_t>(wchar_t c)
85 return is_combining_implementation(static_cast<unsigned short>(c));
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)
90 inline bool is_combining<wchar_t>(wchar_t c)
92 return is_combining_implementation(static_cast<unsigned short>(c));
96 inline bool is_combining<wchar_t>(wchar_t c)
98 return (c >= (std::numeric_limits<uint_least16_t>::max)()) ? false : is_combining_implementation(static_cast<unsigned short>(c));
105 // is a charT c a line separator?
107 template <class charT>
108 inline bool is_separator(charT c)
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));
119 inline bool is_separator<char>(char c)
121 return BOOST_REGEX_MAKE_BOOL((c == '\n') || (c == '\r') || (c == '\f'));
125 // get a default collating element:
127 BOOST_REGEX_DECL std::string BOOST_REGEX_CALL lookup_default_collate_name(const std::string& name);
130 // get the id of a character clasification, the individual
131 // traits classes then transform that id into a bitmask:
133 template <class charT>
134 struct character_pointer_range
139 bool operator < (const character_pointer_range& r)const
141 return std::lexicographical_compare(p1, p2, r.p1, r.p2);
143 bool operator == (const character_pointer_range& r)const
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
149 return ((p2 - p1) == (r.p2 - r.p1)) && re_detail::equal(p1, p2, r.p1);
152 template <class charT>
153 int get_default_class_id(const charT* p1, const charT* p2)
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',
169 'x', 'd', 'i', 'g', 'i', 't',
172 static const character_pointer_range<charT> ranges[19] =
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
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]));
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);
207 template <class charT>
208 std::ptrdiff_t global_length(const charT* p)
210 std::ptrdiff_t n = 0;
219 inline std::ptrdiff_t global_length<char>(const char* p)
221 return (std::strlen)(p);
223 #ifndef BOOST_NO_WREGEX
225 inline std::ptrdiff_t global_length<wchar_t>(const wchar_t* p)
227 return (std::wcslen)(p);
230 template <class charT>
231 inline charT BOOST_REGEX_CALL global_lower(charT c)
235 template <class charT>
236 inline charT BOOST_REGEX_CALL global_upper(charT c)
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);
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);
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:
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); }
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); }
272 template <class charT>
273 int global_value(charT c)
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';
283 if(c >= a) return 10 + (c - a);
285 if(c >= A) return 10 + (c - A);
286 if(c > nine) return -1;
287 if(c >= zero) return c - zero;
290 template <class charT, class traits>
291 int global_toi(const charT*& p1, const charT* p2, int radix, const traits& t)
293 (void)t; // warning suppression
294 int next_value = t.value(*p1, radix);
295 if((p1 == p2) || (next_value < 0) || (next_value >= radix))
300 next_value = t.value(*p1, radix);
301 if((next_value < 0) || (next_value >= radix))
304 result += next_value;
313 #ifdef BOOST_HAS_ABI_HEADERS
314 # include BOOST_ABI_SUFFIX