3 // Testing character type and state type with char_traits and codecvt
4 // specializations for the C++ library testsuite.
6 // Copyright (C) 2003, 2005 Free Software Foundation, Inc.
8 // This file is part of the GNU ISO C++ Library. This library is free
9 // software; you can redistribute it and/or modify it under the
10 // terms of the GNU General Public License as published by the
11 // Free Software Foundation; either version 2, or (at your option)
14 // This library is distributed in the hope that it will be useful,
15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 // GNU General Public License for more details.
19 // You should have received a copy of the GNU General Public License along
20 // with this library; see the file COPYING. If not, write to the Free
21 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
24 // As a special exception, you may use this file as part of a free software
25 // library without restriction. Specifically, if other files instantiate
26 // templates or use macros or inline functions from this file, or you compile
27 // this file and link it with other files to produce an executable, this
28 // file does not by itself cause the resulting executable to be covered by
29 // the GNU General Public License. This exception does not however
30 // invalidate any other reasons why the executable file might be covered by
31 // the GNU General Public License.
33 #ifndef _GLIBCXX_TESTSUITE_CHARACTER_H
34 #define _GLIBCXX_TESTSUITE_CHARACTER_H
37 #include <string> // for char_traits
38 #include <locale> // for codecvt
39 #include <ext/pod_char_traits.h>
49 operator==(const pod_int& lhs, const pod_int& rhs)
50 { return lhs.value == rhs.value; }
53 operator<(const pod_int& lhs, const pod_int& rhs)
54 { return lhs.value < rhs.value; }
62 operator==(const pod_state& lhs, const pod_state& rhs)
63 { return lhs.value == rhs.value; }
66 operator<(const pod_state& lhs, const pod_state& rhs)
67 { return lhs.value < rhs.value; }
69 // Alternate character types.
70 using __gnu_cxx::character;
71 typedef character<unsigned char, pod_int, pod_state> pod_char;
72 typedef character<unsigned char, unsigned int, pod_state> pod_uchar;
73 typedef character<unsigned short, unsigned int> pod_ushort;
79 inline pod_char::char_type
80 pod_char::char_type::from(const V2& v)
82 char_type ret = { static_cast<value_type>(v.value) };
89 pod_char::char_type::to(const char_type& c)
98 inline pod_uchar::char_type
99 pod_uchar::char_type::from(const V2& v)
102 ret.value = (v >> 5);
107 template<typename V2>
109 pod_uchar::char_type::to(const char_type& c)
110 { return static_cast<V2>(c.value << 5); }
111 }; // namespace __gnu_test
115 // codecvt specialization
117 // The conversion performed by the specialization is not supposed to
118 // be useful, rather it has been designed to demonstrate the
119 // essential features of stateful conversions:
120 // * Number and value of bytes for each internal character depends on the
121 // state in addition to the character itself.
122 // * Unshift produces an unshift sequence and resets the state. On input
123 // the unshift sequence causes the state to be reset.
125 // The conversion for output is as follows:
126 // 1. Calculate the value tmp by xor-ing the state and the internal
128 // 2. Split tmp into either two or three bytes depending on the value of
129 // state. Output those bytes.
130 // 3. tmp becomes the new value of state.
132 class codecvt<__gnu_test::pod_uchar, char, __gnu_test::pod_state>
133 : public __codecvt_abstract_base<__gnu_test::pod_uchar, char,
134 __gnu_test::pod_state>
137 typedef codecvt_base::result result;
138 typedef __gnu_test::pod_uchar intern_type;
139 typedef char extern_type;
140 typedef __gnu_test::pod_state state_type;
141 typedef __codecvt_abstract_base<intern_type, extern_type, state_type>
144 explicit codecvt(size_t refs = 0) : base_type(refs)
147 static locale::id id;
154 do_out(state_type& state, const intern_type* from,
155 const intern_type* from_end, const intern_type*& from_next,
156 extern_type* to, extern_type* to_limit,
157 extern_type*& to_next) const
159 while (from < from_end && to < to_limit)
161 unsigned char tmp = (state.value ^ from->value);
162 if (state.value & 0x8)
164 if (to >= to_limit - 2)
167 *to++ = ((tmp >> 3) & 0x7);
168 *to++ = ((tmp >> 6) & 0x3);
172 if (to >= to_limit - 1)
175 *to++ = ((tmp >> 4) & 0xf);
183 return (from < from_end) ? partial : ok;
187 do_in(state_type& state, const extern_type* from,
188 const extern_type* from_end, const extern_type*& from_next,
189 intern_type* to, intern_type* to_limit,
190 intern_type*& to_next) const
192 while (from < from_end && to < to_limit)
194 unsigned char c = *from;
204 if (state.value & 0x8)
206 if (from >= from_end - 2)
208 tmp = (*from++ & 0x7);
209 tmp |= ((*from++ << 3) & 0x38);
210 tmp |= ((*from++ << 6) & 0xc0);
214 if (from >= from_end - 1)
216 tmp = (*from++ & 0xf);
217 tmp |= ((*from++ << 4) & 0xf0);
219 to->value = (tmp ^ state.value);
226 return (from < from_end) ? partial : ok;
230 do_unshift(state_type& state, extern_type* to, extern_type* to_limit,
231 extern_type*& to_next) const
233 for (unsigned int i = 0; i < CHAR_BIT; ++i)
235 unsigned int mask = (1 << i);
236 if (state.value & mask)
244 state.value &= ~mask;
245 *to++ = static_cast<unsigned char>(~mask);
250 return state.value == 0 ? ok : error;
254 do_encoding() const throw()
258 do_always_noconv() const throw()
262 do_length(state_type& state, const extern_type* from,
263 const extern_type* end, size_t max) const
265 const extern_type* beg = from;
266 while (from < end && max)
268 unsigned char c = *from;
278 if (state.value & 0x8)
282 tmp = (*from++ & 0x7);
283 tmp |= ((*from++ << 3) & 0x38);
284 tmp |= ((*from++ << 6) & 0xc0);
290 tmp = (*from++ & 0xf);
291 tmp |= ((*from++ << 4) & 0xf0);
299 // Maximum 8 bytes unshift sequence followed by max 3 bytes for
302 do_max_length() const throw()
307 class ctype<__gnu_test::pod_uchar>
308 : public __ctype_abstract_base<__gnu_test::pod_uchar>
311 typedef __gnu_test::pod_uchar char_type;
313 explicit ctype(size_t refs = 0)
314 : __ctype_abstract_base<__gnu_test::pod_uchar>(refs) { }
316 static locale::id id;
323 do_is(mask m, char_type c) const
326 virtual const char_type*
327 do_is(const char_type* low, const char_type* high, mask* vec) const
329 fill_n(vec, high - low, mask());
333 virtual const char_type*
334 do_scan_is(mask m, const char_type* low, const char_type* high) const
337 virtual const char_type*
338 do_scan_not(mask m, const char_type* low, const char_type* high) const
342 do_toupper(char_type c) const
345 virtual const char_type*
346 do_toupper(char_type* low, const char_type* high) const
350 do_tolower(char_type c) const
353 virtual const char_type*
354 do_tolower(char_type* low, const char_type* high) const
358 do_widen(char c) const
359 { return __gnu_test::pod_uchar::from<char>(c); }
362 do_widen(const char* low, const char* high, char_type* dest) const
364 transform(low, high, dest, &__gnu_test::pod_uchar::from<char>);
369 do_narrow(char_type, char dfault) const
372 virtual const char_type*
373 do_narrow(const char_type* low, const char_type* high,
374 char dfault, char* dest) const
376 fill_n(dest, high - low, dfault);
382 #endif // _GLIBCXX_TESTSUITE_CHARACTER_H