source: icXML/icXML-devel/src/icxmlc/XMLMultiliteral.h @ 2720

Last change on this file since 2720 was 2720, checked in by cameron, 6 years ago

Initial check-in of icXML 0.8 source files

File size: 78.7 KB
Line 
1/* XMLMultiliteral.h
2    Copyright (c) 2008, Robert D. Cameron.
3    Licensed to the public under the Open Software License 3.0.
4    Licensed to International Characters, Inc., under the Academic
5    Free License 3.0.
6
7    This is a generated file using XMLMultiliteral.py.  Do not edit.
8
9*/
10
11#if !defined(XERCESC_INCLUDE_GUARD_XML_MULTILITERAL_H)
12#define XERCESC_INCLUDE_GUARD_XML_MULTILITERAL_H
13
14
15#include <xercesc/framework/XMLRecognizer.hpp>
16#include <xercesc/util/XercesDefs.hpp>
17#include <stdint.h>
18
19XERCES_CPP_NAMESPACE_BEGIN
20
21/***********************************************************************************************/
22
23template<XMLRecognizer::Encodings Format>
24static bool atColon(const XMLCh * const character) { throw; }
25
26template<XMLRecognizer::Encodings Format>
27static bool atOctothorpe(const void * const character) { throw; }
28
29template<XMLRecognizer::Encodings Format>
30static bool atX(const void * const character) { throw; }
31
32template<XMLRecognizer::Encodings Format>
33static bool atHexDigit(const void * const string, unsigned int & val) { throw; }
34
35template<XMLRecognizer::Encodings Format>
36static bool atDigit(const void * const string, unsigned int & val) { throw; }
37
38template<XMLRecognizer::Encodings Format>
39static bool atRefGt(const void * const string) { throw; }
40
41template<XMLRecognizer::Encodings Format>
42static bool atRefLt(const void * const string) { throw; }
43
44template<XMLRecognizer::Encodings Format>
45static bool atRefAmp(const void * const string) { throw; }
46
47template<XMLRecognizer::Encodings Format>
48static bool atRefApos(const void * const string) { throw; }
49
50template<XMLRecognizer::Encodings Format>
51static bool atRefQuot(const void * const string) { throw; }
52
53/***********************************************************************************************/
54
55#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
56#define LOW_BYTE_SHIFT 8
57#define HIGH_BYTE_SHIFT 0
58#else
59#define LOW_BYTE_SHIFT 0
60#define HIGH_BYTE_SHIFT 8
61#endif
62
63/***********************************************************************************************/
64
65template<XMLRecognizer::Encodings Format, typename Char>
66inline bool __atHexDigit(const Char * const string, unsigned int & val);
67
68template<XMLRecognizer::Encodings Format, typename Char>
69inline bool __atDigit(const Char * const string, unsigned int & val);
70
71template<XMLRecognizer::Encodings Format, typename Char, char character>
72inline bool __caselessEq(const Char * const string);
73
74/***********************************************************************************************/
75
76
77
78template<XMLRecognizer::Encodings Format, uint8_t c>
79struct __ChOrd { const static uint8_t value = 0; };
80
81template <uint8_t c1, uint8_t c2>
82struct __ChConv16
83{
84    static uint16_t const value =
85    (((uint16_t)c1) << LOW_BYTE_SHIFT) | (((uint16_t)c2) << HIGH_BYTE_SHIFT);
86};
87
88template <uint8_t c1, uint8_t c2, uint8_t c3, uint8_t c4>
89struct __ChConv32
90{
91    static uint32_t const value =
92    (((uint32_t)__ChConv16<c1, c2>::value) << (2 * LOW_BYTE_SHIFT)) |
93    (((uint32_t)__ChConv16<c3, c4>::value) << (2 * HIGH_BYTE_SHIFT));
94};
95
96template <uint8_t c1, uint8_t c2, uint8_t c3, uint8_t c4, uint8_t c5, uint8_t c6, uint8_t c7, uint8_t c8>
97struct __ChConv64
98{
99    static uint64_t const value =
100    (((uint64_t)__ChConv32<c1, c2, c3, c4>::value) << (4 * LOW_BYTE_SHIFT)) |
101    (((uint64_t)__ChConv32<c5, c6, c7, c8>::value) << (4 * HIGH_BYTE_SHIFT));
102};
103
104template <XMLRecognizer::Encodings Format,
105          const uint8_t c1, const uint8_t c2, const uint8_t c3, const uint8_t c4>
106IDISA_ALWAYS_INLINE
107static const uint32_t __StringConst4()
108{
109    return __ChConv32<
110    __ChOrd<Format, c1>::value,
111    __ChOrd<Format, c2>::value,
112    __ChOrd<Format, c3>::value,
113    __ChOrd<Format, c4>::value>::value;
114}
115
116template <XMLRecognizer::Encodings Format,
117          const uint8_t c1, const uint8_t c2, const uint8_t c3, const uint8_t c4,
118          const uint8_t c5, const uint8_t c6, const uint8_t c7, const uint8_t c8>
119IDISA_ALWAYS_INLINE
120static const uint64_t __StringConst8()
121{
122    return __ChConv64<
123    __ChOrd<Format, c1>::value,
124    __ChOrd<Format, c2>::value,
125    __ChOrd<Format, c3>::value,
126    __ChOrd<Format, c4>::value,
127    __ChOrd<Format, c5>::value,
128    __ChOrd<Format, c6>::value,
129    __ChOrd<Format, c7>::value,
130    __ChOrd<Format, c8>::value>::value;
131}
132
133IDISA_ALWAYS_INLINE
134static const uint16_t __Conv16_2(const void * s)
135{
136   return reinterpret_cast<const uint16_t*>(s)[0];
137}
138
139IDISA_ALWAYS_INLINE
140static const uint32_t __Conv32_4(const void * s)
141{
142   return reinterpret_cast<const uint32_t*>(s)[0];
143}
144
145IDISA_ALWAYS_INLINE
146static const uint32_t __Conv32_3(const void * s)
147{
148   return __Conv32_4(s) & (0x00FFFFFF << LOW_BYTE_SHIFT);
149}
150
151IDISA_ALWAYS_INLINE
152static const uint64_t __Conv64_8(const void * s)
153{
154   return reinterpret_cast<const uint64_t*>(s)[0];
155}
156
157IDISA_ALWAYS_INLINE
158static const uint64_t __Conv64_5(const void * s)
159{
160   return __Conv64_8(s) & (0x000000FFFFFFFFFFULL << (3 * LOW_BYTE_SHIFT));
161}
162
163IDISA_ALWAYS_INLINE
164static const uint64_t __Conv64_6(const void * s)
165{
166   return __Conv64_8(s) & (0x0000FFFFFFFFFFFFULL << (2 * LOW_BYTE_SHIFT));
167}
168
169IDISA_ALWAYS_INLINE
170static const uint64_t __Conv64_7(const void * s)
171{
172   return __Conv64_8(s) & (0x00FFFFFFFFFFFFFFULL << LOW_BYTE_SHIFT);
173}
174
175template<XMLRecognizer::Encodings Format>
176struct __CodeUnit { const static unsigned int size = 1; };
177
178#define CODE_UNIT_SIZE(FORMAT) (__CodeUnit<FORMAT>::size)
179
180template<> struct __ChOrd<XMLRecognizer::EBCDIC,'"'> { const static uint8_t value = 0x7f; };
181template<> struct __ChOrd<XMLRecognizer::EBCDIC,'\''> { const static uint8_t value = 0x7d; };
182template<> struct __ChOrd<XMLRecognizer::EBCDIC,'/'> { const static uint8_t value = 0x61; };
183template<> struct __ChOrd<XMLRecognizer::EBCDIC,'?'> { const static uint8_t value = 0x6f; };
184template<> struct __ChOrd<XMLRecognizer::EBCDIC,'!'> { const static uint8_t value = 0x5a; };
185template<> struct __ChOrd<XMLRecognizer::EBCDIC,'&'> { const static uint8_t value = 0x50; };
186template<> struct __ChOrd<XMLRecognizer::EBCDIC,'#'> { const static uint8_t value = 0x7b; };
187template<> struct __ChOrd<XMLRecognizer::EBCDIC,'-'> { const static uint8_t value = 0x60; };
188template<> struct __ChOrd<XMLRecognizer::EBCDIC,'['> { const static uint8_t value = 0xba; };
189template<> struct __ChOrd<XMLRecognizer::EBCDIC,'>'> { const static uint8_t value = 0x6e; };
190template<> struct __ChOrd<XMLRecognizer::EBCDIC,'='> { const static uint8_t value = 0x7e; };
191template<> struct __ChOrd<XMLRecognizer::EBCDIC,' '> { const static uint8_t value = 0x40; };
192template<> struct __ChOrd<XMLRecognizer::EBCDIC,'\t'> { const static uint8_t value = 0x5; };
193template<> struct __ChOrd<XMLRecognizer::EBCDIC,'\n'> { const static uint8_t value = 0x25; };
194template<> struct __ChOrd<XMLRecognizer::EBCDIC,'\r'> { const static uint8_t value = 0xd; };
195template<> struct __ChOrd<XMLRecognizer::EBCDIC,':'> { const static uint8_t value = 0x7a; };
196template<> struct __ChOrd<XMLRecognizer::EBCDIC,';'> { const static uint8_t value = 0x5e; };
197template<> struct __ChOrd<XMLRecognizer::EBCDIC,'.'> { const static uint8_t value = 0x4b; };
198template<> struct __ChOrd<XMLRecognizer::EBCDIC,'a'> { const static uint8_t value = 0x81; };
199template<> struct __ChOrd<XMLRecognizer::EBCDIC,'b'> { const static uint8_t value = 0x82; };
200template<> struct __ChOrd<XMLRecognizer::EBCDIC,'c'> { const static uint8_t value = 0x83; };
201template<> struct __ChOrd<XMLRecognizer::EBCDIC,'d'> { const static uint8_t value = 0x84; };
202template<> struct __ChOrd<XMLRecognizer::EBCDIC,'e'> { const static uint8_t value = 0x85; };
203template<> struct __ChOrd<XMLRecognizer::EBCDIC,'f'> { const static uint8_t value = 0x86; };
204template<> struct __ChOrd<XMLRecognizer::EBCDIC,'g'> { const static uint8_t value = 0x87; };
205template<> struct __ChOrd<XMLRecognizer::EBCDIC,'h'> { const static uint8_t value = 0x88; };
206template<> struct __ChOrd<XMLRecognizer::EBCDIC,'i'> { const static uint8_t value = 0x89; };
207template<> struct __ChOrd<XMLRecognizer::EBCDIC,'j'> { const static uint8_t value = 0x91; };
208template<> struct __ChOrd<XMLRecognizer::EBCDIC,'k'> { const static uint8_t value = 0x92; };
209template<> struct __ChOrd<XMLRecognizer::EBCDIC,'l'> { const static uint8_t value = 0x93; };
210template<> struct __ChOrd<XMLRecognizer::EBCDIC,'m'> { const static uint8_t value = 0x94; };
211template<> struct __ChOrd<XMLRecognizer::EBCDIC,'n'> { const static uint8_t value = 0x95; };
212template<> struct __ChOrd<XMLRecognizer::EBCDIC,'o'> { const static uint8_t value = 0x96; };
213template<> struct __ChOrd<XMLRecognizer::EBCDIC,'p'> { const static uint8_t value = 0x97; };
214template<> struct __ChOrd<XMLRecognizer::EBCDIC,'q'> { const static uint8_t value = 0x98; };
215template<> struct __ChOrd<XMLRecognizer::EBCDIC,'r'> { const static uint8_t value = 0x99; };
216template<> struct __ChOrd<XMLRecognizer::EBCDIC,'s'> { const static uint8_t value = 0xa2; };
217template<> struct __ChOrd<XMLRecognizer::EBCDIC,'t'> { const static uint8_t value = 0xa3; };
218template<> struct __ChOrd<XMLRecognizer::EBCDIC,'u'> { const static uint8_t value = 0xa4; };
219template<> struct __ChOrd<XMLRecognizer::EBCDIC,'v'> { const static uint8_t value = 0xa5; };
220template<> struct __ChOrd<XMLRecognizer::EBCDIC,'w'> { const static uint8_t value = 0xa6; };
221template<> struct __ChOrd<XMLRecognizer::EBCDIC,'x'> { const static uint8_t value = 0xa7; };
222template<> struct __ChOrd<XMLRecognizer::EBCDIC,'y'> { const static uint8_t value = 0xa8; };
223template<> struct __ChOrd<XMLRecognizer::EBCDIC,'z'> { const static uint8_t value = 0xa9; };
224template<> struct __ChOrd<XMLRecognizer::EBCDIC,'A'> { const static uint8_t value = 0xc1; };
225template<> struct __ChOrd<XMLRecognizer::EBCDIC,'B'> { const static uint8_t value = 0xc2; };
226template<> struct __ChOrd<XMLRecognizer::EBCDIC,'C'> { const static uint8_t value = 0xc3; };
227template<> struct __ChOrd<XMLRecognizer::EBCDIC,'D'> { const static uint8_t value = 0xc4; };
228template<> struct __ChOrd<XMLRecognizer::EBCDIC,'E'> { const static uint8_t value = 0xc5; };
229template<> struct __ChOrd<XMLRecognizer::EBCDIC,'F'> { const static uint8_t value = 0xc6; };
230template<> struct __ChOrd<XMLRecognizer::EBCDIC,'G'> { const static uint8_t value = 0xc7; };
231template<> struct __ChOrd<XMLRecognizer::EBCDIC,'H'> { const static uint8_t value = 0xc8; };
232template<> struct __ChOrd<XMLRecognizer::EBCDIC,'I'> { const static uint8_t value = 0xc9; };
233template<> struct __ChOrd<XMLRecognizer::EBCDIC,'J'> { const static uint8_t value = 0xd1; };
234template<> struct __ChOrd<XMLRecognizer::EBCDIC,'K'> { const static uint8_t value = 0xd2; };
235template<> struct __ChOrd<XMLRecognizer::EBCDIC,'L'> { const static uint8_t value = 0xd3; };
236template<> struct __ChOrd<XMLRecognizer::EBCDIC,'M'> { const static uint8_t value = 0xd4; };
237template<> struct __ChOrd<XMLRecognizer::EBCDIC,'N'> { const static uint8_t value = 0xd5; };
238template<> struct __ChOrd<XMLRecognizer::EBCDIC,'O'> { const static uint8_t value = 0xd6; };
239template<> struct __ChOrd<XMLRecognizer::EBCDIC,'P'> { const static uint8_t value = 0xd7; };
240template<> struct __ChOrd<XMLRecognizer::EBCDIC,'Q'> { const static uint8_t value = 0xd8; };
241template<> struct __ChOrd<XMLRecognizer::EBCDIC,'R'> { const static uint8_t value = 0xd9; };
242template<> struct __ChOrd<XMLRecognizer::EBCDIC,'S'> { const static uint8_t value = 0xe2; };
243template<> struct __ChOrd<XMLRecognizer::EBCDIC,'T'> { const static uint8_t value = 0xe3; };
244template<> struct __ChOrd<XMLRecognizer::EBCDIC,'U'> { const static uint8_t value = 0xe4; };
245template<> struct __ChOrd<XMLRecognizer::EBCDIC,'V'> { const static uint8_t value = 0xe5; };
246template<> struct __ChOrd<XMLRecognizer::EBCDIC,'W'> { const static uint8_t value = 0xe6; };
247template<> struct __ChOrd<XMLRecognizer::EBCDIC,'X'> { const static uint8_t value = 0xe7; };
248template<> struct __ChOrd<XMLRecognizer::EBCDIC,'Y'> { const static uint8_t value = 0xe8; };
249template<> struct __ChOrd<XMLRecognizer::EBCDIC,'Z'> { const static uint8_t value = 0xe9; };
250template<> struct __ChOrd<XMLRecognizer::EBCDIC,'0'> { const static uint8_t value = 0xf0; };
251template<> struct __ChOrd<XMLRecognizer::EBCDIC,'1'> { const static uint8_t value = 0xf1; };
252template<> struct __ChOrd<XMLRecognizer::EBCDIC,'2'> { const static uint8_t value = 0xf2; };
253template<> struct __ChOrd<XMLRecognizer::EBCDIC,'3'> { const static uint8_t value = 0xf3; };
254template<> struct __ChOrd<XMLRecognizer::EBCDIC,'4'> { const static uint8_t value = 0xf4; };
255template<> struct __ChOrd<XMLRecognizer::EBCDIC,'5'> { const static uint8_t value = 0xf5; };
256template<> struct __ChOrd<XMLRecognizer::EBCDIC,'6'> { const static uint8_t value = 0xf6; };
257template<> struct __ChOrd<XMLRecognizer::EBCDIC,'7'> { const static uint8_t value = 0xf7; };
258template<> struct __ChOrd<XMLRecognizer::EBCDIC,'8'> { const static uint8_t value = 0xf8; };
259template<> struct __ChOrd<XMLRecognizer::EBCDIC,'9'> { const static uint8_t value = 0xf9; };
260
261template<> struct __CodeUnit<XMLRecognizer::EBCDIC> { const static unsigned int size = 1; };
262
263template<> IDISA_ALWAYS_INLINE
264bool atX<XMLRecognizer::EBCDIC>(const void * const character)
265{
266    return __caselessEq<XMLRecognizer::EBCDIC, uint8_t, 'x'>(&((reinterpret_cast<const uint8_t*>(character))[0]));
267}
268
269template<> IDISA_ALWAYS_INLINE
270bool atOctothorpe<XMLRecognizer::EBCDIC>(const void * const character)
271{
272    return ((reinterpret_cast<const uint8_t*>(character))[0] == __ChOrd<XMLRecognizer::EBCDIC, '#'>::value);
273}
274
275
276template<> IDISA_ALWAYS_INLINE
277bool atHexDigit<XMLRecognizer::EBCDIC>(const void * const character, unsigned int & val)
278{
279    return __atHexDigit<XMLRecognizer::EBCDIC, uint8_t>(reinterpret_cast<const uint8_t*>(character), val);
280}
281
282
283template<> IDISA_ALWAYS_INLINE
284bool atDigit<XMLRecognizer::EBCDIC>(const void * const character, unsigned int & val)
285{
286    return __atDigit<XMLRecognizer::EBCDIC, uint8_t>(reinterpret_cast<const uint8_t*>(character), val);
287}
288
289
290
291template<> IDISA_ALWAYS_INLINE
292bool atRefGt<XMLRecognizer::EBCDIC>(const void * const string)
293{
294    const uint32_t refGt = __StringConst4<XMLRecognizer::EBCDIC, '&', 'g',  't', ';'>();
295    return __Conv32_4(string) == refGt;
296}
297
298
299
300template<> IDISA_ALWAYS_INLINE
301bool atRefLt<XMLRecognizer::EBCDIC>(const void * const string)
302{
303    const uint32_t refLt = __StringConst4<XMLRecognizer::EBCDIC, '&', 'l',  't', ';'>();
304    return __Conv32_4(string) == refLt;
305}
306
307
308
309template<> IDISA_ALWAYS_INLINE
310bool atRefAmp<XMLRecognizer::EBCDIC>(const void * const string)
311{
312    const uint32_t refAmp = __StringConst4<XMLRecognizer::EBCDIC, 'a', 'm',  'p', ';'>();
313    return refAmp == __Conv32_4(&(reinterpret_cast<const uint8_t*>(string)[1]));
314}
315
316
317
318template<> IDISA_ALWAYS_INLINE
319bool atRefApos<XMLRecognizer::EBCDIC>(const void * const string)
320{
321    const uint64_t refApos =
322    __StringConst8<XMLRecognizer::EBCDIC, '&', 'a',  'p', 'o', 's', ';', 0, 0>();
323    return __Conv64_6(string) == refApos;
324}
325
326
327
328template<> IDISA_ALWAYS_INLINE
329bool atRefQuot<XMLRecognizer::EBCDIC>(const void * const string)
330{
331    const uint64_t refQuot =
332    __StringConst8<XMLRecognizer::EBCDIC, '&', 'q',  'u', 'o', 't', ';', 0, 0>();
333    return __Conv64_6(string) == refQuot;
334}
335
336template<> struct __ChOrd<XMLRecognizer::UCS_4B,'"'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x22>::value; };
337template<> struct __ChOrd<XMLRecognizer::UCS_4B,'\''> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x27>::value; };
338template<> struct __ChOrd<XMLRecognizer::UCS_4B,'/'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x2f>::value; };
339template<> struct __ChOrd<XMLRecognizer::UCS_4B,'?'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x3f>::value; };
340template<> struct __ChOrd<XMLRecognizer::UCS_4B,'!'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x21>::value; };
341template<> struct __ChOrd<XMLRecognizer::UCS_4B,'&'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x26>::value; };
342template<> struct __ChOrd<XMLRecognizer::UCS_4B,'#'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x23>::value; };
343template<> struct __ChOrd<XMLRecognizer::UCS_4B,'-'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x2d>::value; };
344template<> struct __ChOrd<XMLRecognizer::UCS_4B,'['> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x5b>::value; };
345template<> struct __ChOrd<XMLRecognizer::UCS_4B,'>'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x3e>::value; };
346template<> struct __ChOrd<XMLRecognizer::UCS_4B,'='> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x3d>::value; };
347template<> struct __ChOrd<XMLRecognizer::UCS_4B,' '> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x20>::value; };
348template<> struct __ChOrd<XMLRecognizer::UCS_4B,'\t'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x9>::value; };
349template<> struct __ChOrd<XMLRecognizer::UCS_4B,'\n'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0xa>::value; };
350template<> struct __ChOrd<XMLRecognizer::UCS_4B,'\r'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0xd>::value; };
351template<> struct __ChOrd<XMLRecognizer::UCS_4B,':'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x3a>::value; };
352template<> struct __ChOrd<XMLRecognizer::UCS_4B,';'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x3b>::value; };
353template<> struct __ChOrd<XMLRecognizer::UCS_4B,'.'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x2e>::value; };
354template<> struct __ChOrd<XMLRecognizer::UCS_4B,'a'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x61>::value; };
355template<> struct __ChOrd<XMLRecognizer::UCS_4B,'b'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x62>::value; };
356template<> struct __ChOrd<XMLRecognizer::UCS_4B,'c'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x63>::value; };
357template<> struct __ChOrd<XMLRecognizer::UCS_4B,'d'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x64>::value; };
358template<> struct __ChOrd<XMLRecognizer::UCS_4B,'e'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x65>::value; };
359template<> struct __ChOrd<XMLRecognizer::UCS_4B,'f'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x66>::value; };
360template<> struct __ChOrd<XMLRecognizer::UCS_4B,'g'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x67>::value; };
361template<> struct __ChOrd<XMLRecognizer::UCS_4B,'h'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x68>::value; };
362template<> struct __ChOrd<XMLRecognizer::UCS_4B,'i'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x69>::value; };
363template<> struct __ChOrd<XMLRecognizer::UCS_4B,'j'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x6a>::value; };
364template<> struct __ChOrd<XMLRecognizer::UCS_4B,'k'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x6b>::value; };
365template<> struct __ChOrd<XMLRecognizer::UCS_4B,'l'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x6c>::value; };
366template<> struct __ChOrd<XMLRecognizer::UCS_4B,'m'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x6d>::value; };
367template<> struct __ChOrd<XMLRecognizer::UCS_4B,'n'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x6e>::value; };
368template<> struct __ChOrd<XMLRecognizer::UCS_4B,'o'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x6f>::value; };
369template<> struct __ChOrd<XMLRecognizer::UCS_4B,'p'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x70>::value; };
370template<> struct __ChOrd<XMLRecognizer::UCS_4B,'q'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x71>::value; };
371template<> struct __ChOrd<XMLRecognizer::UCS_4B,'r'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x72>::value; };
372template<> struct __ChOrd<XMLRecognizer::UCS_4B,'s'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x73>::value; };
373template<> struct __ChOrd<XMLRecognizer::UCS_4B,'t'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x74>::value; };
374template<> struct __ChOrd<XMLRecognizer::UCS_4B,'u'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x75>::value; };
375template<> struct __ChOrd<XMLRecognizer::UCS_4B,'v'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x76>::value; };
376template<> struct __ChOrd<XMLRecognizer::UCS_4B,'w'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x77>::value; };
377template<> struct __ChOrd<XMLRecognizer::UCS_4B,'x'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x78>::value; };
378template<> struct __ChOrd<XMLRecognizer::UCS_4B,'y'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x79>::value; };
379template<> struct __ChOrd<XMLRecognizer::UCS_4B,'z'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x7a>::value; };
380template<> struct __ChOrd<XMLRecognizer::UCS_4B,'A'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x41>::value; };
381template<> struct __ChOrd<XMLRecognizer::UCS_4B,'B'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x42>::value; };
382template<> struct __ChOrd<XMLRecognizer::UCS_4B,'C'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x43>::value; };
383template<> struct __ChOrd<XMLRecognizer::UCS_4B,'D'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x44>::value; };
384template<> struct __ChOrd<XMLRecognizer::UCS_4B,'E'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x45>::value; };
385template<> struct __ChOrd<XMLRecognizer::UCS_4B,'F'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x46>::value; };
386template<> struct __ChOrd<XMLRecognizer::UCS_4B,'G'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x47>::value; };
387template<> struct __ChOrd<XMLRecognizer::UCS_4B,'H'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x48>::value; };
388template<> struct __ChOrd<XMLRecognizer::UCS_4B,'I'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x49>::value; };
389template<> struct __ChOrd<XMLRecognizer::UCS_4B,'J'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x4a>::value; };
390template<> struct __ChOrd<XMLRecognizer::UCS_4B,'K'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x4b>::value; };
391template<> struct __ChOrd<XMLRecognizer::UCS_4B,'L'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x4c>::value; };
392template<> struct __ChOrd<XMLRecognizer::UCS_4B,'M'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x4d>::value; };
393template<> struct __ChOrd<XMLRecognizer::UCS_4B,'N'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x4e>::value; };
394template<> struct __ChOrd<XMLRecognizer::UCS_4B,'O'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x4f>::value; };
395template<> struct __ChOrd<XMLRecognizer::UCS_4B,'P'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x50>::value; };
396template<> struct __ChOrd<XMLRecognizer::UCS_4B,'Q'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x51>::value; };
397template<> struct __ChOrd<XMLRecognizer::UCS_4B,'R'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x52>::value; };
398template<> struct __ChOrd<XMLRecognizer::UCS_4B,'S'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x53>::value; };
399template<> struct __ChOrd<XMLRecognizer::UCS_4B,'T'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x54>::value; };
400template<> struct __ChOrd<XMLRecognizer::UCS_4B,'U'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x55>::value; };
401template<> struct __ChOrd<XMLRecognizer::UCS_4B,'V'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x56>::value; };
402template<> struct __ChOrd<XMLRecognizer::UCS_4B,'W'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x57>::value; };
403template<> struct __ChOrd<XMLRecognizer::UCS_4B,'X'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x58>::value; };
404template<> struct __ChOrd<XMLRecognizer::UCS_4B,'Y'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x59>::value; };
405template<> struct __ChOrd<XMLRecognizer::UCS_4B,'Z'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x5a>::value; };
406template<> struct __ChOrd<XMLRecognizer::UCS_4B,'0'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x30>::value; };
407template<> struct __ChOrd<XMLRecognizer::UCS_4B,'1'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x31>::value; };
408template<> struct __ChOrd<XMLRecognizer::UCS_4B,'2'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x32>::value; };
409template<> struct __ChOrd<XMLRecognizer::UCS_4B,'3'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x33>::value; };
410template<> struct __ChOrd<XMLRecognizer::UCS_4B,'4'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x34>::value; };
411template<> struct __ChOrd<XMLRecognizer::UCS_4B,'5'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x35>::value; };
412template<> struct __ChOrd<XMLRecognizer::UCS_4B,'6'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x36>::value; };
413template<> struct __ChOrd<XMLRecognizer::UCS_4B,'7'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x37>::value; };
414template<> struct __ChOrd<XMLRecognizer::UCS_4B,'8'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x38>::value; };
415template<> struct __ChOrd<XMLRecognizer::UCS_4B,'9'> { const static uint32_t value = __ChConv32<0x0,0x0,0x0,0x39>::value; };
416
417template<> struct __CodeUnit<XMLRecognizer::UCS_4B> { const static unsigned int size = 4; };
418
419template<> IDISA_ALWAYS_INLINE
420bool atX<XMLRecognizer::UCS_4B>(const void * const character)
421{
422    return __caselessEq<XMLRecognizer::UCS_4B, uint32_t, 'x'>(&((reinterpret_cast<const uint32_t*>(character))[0]));
423}
424
425template<> IDISA_ALWAYS_INLINE
426bool atOctothorpe<XMLRecognizer::UCS_4B>(const void * const character)
427{
428    return ((reinterpret_cast<const uint32_t*>(character))[0] == __ChOrd<XMLRecognizer::UCS_4B, '#'>::value);
429}
430
431
432template<> IDISA_ALWAYS_INLINE
433bool atHexDigit<XMLRecognizer::UCS_4B>(const void * const character, unsigned int & val)
434{
435    return __atHexDigit<XMLRecognizer::UCS_4B, uint32_t>(reinterpret_cast<const uint32_t*>(character), val);
436}
437
438
439template<> IDISA_ALWAYS_INLINE
440bool atDigit<XMLRecognizer::UCS_4B>(const void * const character, unsigned int & val)
441{
442    return __atDigit<XMLRecognizer::UCS_4B, uint32_t>(reinterpret_cast<const uint32_t*>(character), val);
443}
444
445template<> struct __ChOrd<XMLRecognizer::UCS_4L,'"'> { const static uint32_t value = __ChConv32<0x22,0x0,0x0,0x0>::value; };
446template<> struct __ChOrd<XMLRecognizer::UCS_4L,'\''> { const static uint32_t value = __ChConv32<0x27,0x0,0x0,0x0>::value; };
447template<> struct __ChOrd<XMLRecognizer::UCS_4L,'/'> { const static uint32_t value = __ChConv32<0x2f,0x0,0x0,0x0>::value; };
448template<> struct __ChOrd<XMLRecognizer::UCS_4L,'?'> { const static uint32_t value = __ChConv32<0x3f,0x0,0x0,0x0>::value; };
449template<> struct __ChOrd<XMLRecognizer::UCS_4L,'!'> { const static uint32_t value = __ChConv32<0x21,0x0,0x0,0x0>::value; };
450template<> struct __ChOrd<XMLRecognizer::UCS_4L,'&'> { const static uint32_t value = __ChConv32<0x26,0x0,0x0,0x0>::value; };
451template<> struct __ChOrd<XMLRecognizer::UCS_4L,'#'> { const static uint32_t value = __ChConv32<0x23,0x0,0x0,0x0>::value; };
452template<> struct __ChOrd<XMLRecognizer::UCS_4L,'-'> { const static uint32_t value = __ChConv32<0x2d,0x0,0x0,0x0>::value; };
453template<> struct __ChOrd<XMLRecognizer::UCS_4L,'['> { const static uint32_t value = __ChConv32<0x5b,0x0,0x0,0x0>::value; };
454template<> struct __ChOrd<XMLRecognizer::UCS_4L,'>'> { const static uint32_t value = __ChConv32<0x3e,0x0,0x0,0x0>::value; };
455template<> struct __ChOrd<XMLRecognizer::UCS_4L,'='> { const static uint32_t value = __ChConv32<0x3d,0x0,0x0,0x0>::value; };
456template<> struct __ChOrd<XMLRecognizer::UCS_4L,' '> { const static uint32_t value = __ChConv32<0x20,0x0,0x0,0x0>::value; };
457template<> struct __ChOrd<XMLRecognizer::UCS_4L,'\t'> { const static uint32_t value = __ChConv32<0x9,0x0,0x0,0x0>::value; };
458template<> struct __ChOrd<XMLRecognizer::UCS_4L,'\n'> { const static uint32_t value = __ChConv32<0xa,0x0,0x0,0x0>::value; };
459template<> struct __ChOrd<XMLRecognizer::UCS_4L,'\r'> { const static uint32_t value = __ChConv32<0xd,0x0,0x0,0x0>::value; };
460template<> struct __ChOrd<XMLRecognizer::UCS_4L,':'> { const static uint32_t value = __ChConv32<0x3a,0x0,0x0,0x0>::value; };
461template<> struct __ChOrd<XMLRecognizer::UCS_4L,';'> { const static uint32_t value = __ChConv32<0x3b,0x0,0x0,0x0>::value; };
462template<> struct __ChOrd<XMLRecognizer::UCS_4L,'.'> { const static uint32_t value = __ChConv32<0x2e,0x0,0x0,0x0>::value; };
463template<> struct __ChOrd<XMLRecognizer::UCS_4L,'a'> { const static uint32_t value = __ChConv32<0x61,0x0,0x0,0x0>::value; };
464template<> struct __ChOrd<XMLRecognizer::UCS_4L,'b'> { const static uint32_t value = __ChConv32<0x62,0x0,0x0,0x0>::value; };
465template<> struct __ChOrd<XMLRecognizer::UCS_4L,'c'> { const static uint32_t value = __ChConv32<0x63,0x0,0x0,0x0>::value; };
466template<> struct __ChOrd<XMLRecognizer::UCS_4L,'d'> { const static uint32_t value = __ChConv32<0x64,0x0,0x0,0x0>::value; };
467template<> struct __ChOrd<XMLRecognizer::UCS_4L,'e'> { const static uint32_t value = __ChConv32<0x65,0x0,0x0,0x0>::value; };
468template<> struct __ChOrd<XMLRecognizer::UCS_4L,'f'> { const static uint32_t value = __ChConv32<0x66,0x0,0x0,0x0>::value; };
469template<> struct __ChOrd<XMLRecognizer::UCS_4L,'g'> { const static uint32_t value = __ChConv32<0x67,0x0,0x0,0x0>::value; };
470template<> struct __ChOrd<XMLRecognizer::UCS_4L,'h'> { const static uint32_t value = __ChConv32<0x68,0x0,0x0,0x0>::value; };
471template<> struct __ChOrd<XMLRecognizer::UCS_4L,'i'> { const static uint32_t value = __ChConv32<0x69,0x0,0x0,0x0>::value; };
472template<> struct __ChOrd<XMLRecognizer::UCS_4L,'j'> { const static uint32_t value = __ChConv32<0x6a,0x0,0x0,0x0>::value; };
473template<> struct __ChOrd<XMLRecognizer::UCS_4L,'k'> { const static uint32_t value = __ChConv32<0x6b,0x0,0x0,0x0>::value; };
474template<> struct __ChOrd<XMLRecognizer::UCS_4L,'l'> { const static uint32_t value = __ChConv32<0x6c,0x0,0x0,0x0>::value; };
475template<> struct __ChOrd<XMLRecognizer::UCS_4L,'m'> { const static uint32_t value = __ChConv32<0x6d,0x0,0x0,0x0>::value; };
476template<> struct __ChOrd<XMLRecognizer::UCS_4L,'n'> { const static uint32_t value = __ChConv32<0x6e,0x0,0x0,0x0>::value; };
477template<> struct __ChOrd<XMLRecognizer::UCS_4L,'o'> { const static uint32_t value = __ChConv32<0x6f,0x0,0x0,0x0>::value; };
478template<> struct __ChOrd<XMLRecognizer::UCS_4L,'p'> { const static uint32_t value = __ChConv32<0x70,0x0,0x0,0x0>::value; };
479template<> struct __ChOrd<XMLRecognizer::UCS_4L,'q'> { const static uint32_t value = __ChConv32<0x71,0x0,0x0,0x0>::value; };
480template<> struct __ChOrd<XMLRecognizer::UCS_4L,'r'> { const static uint32_t value = __ChConv32<0x72,0x0,0x0,0x0>::value; };
481template<> struct __ChOrd<XMLRecognizer::UCS_4L,'s'> { const static uint32_t value = __ChConv32<0x73,0x0,0x0,0x0>::value; };
482template<> struct __ChOrd<XMLRecognizer::UCS_4L,'t'> { const static uint32_t value = __ChConv32<0x74,0x0,0x0,0x0>::value; };
483template<> struct __ChOrd<XMLRecognizer::UCS_4L,'u'> { const static uint32_t value = __ChConv32<0x75,0x0,0x0,0x0>::value; };
484template<> struct __ChOrd<XMLRecognizer::UCS_4L,'v'> { const static uint32_t value = __ChConv32<0x76,0x0,0x0,0x0>::value; };
485template<> struct __ChOrd<XMLRecognizer::UCS_4L,'w'> { const static uint32_t value = __ChConv32<0x77,0x0,0x0,0x0>::value; };
486template<> struct __ChOrd<XMLRecognizer::UCS_4L,'x'> { const static uint32_t value = __ChConv32<0x78,0x0,0x0,0x0>::value; };
487template<> struct __ChOrd<XMLRecognizer::UCS_4L,'y'> { const static uint32_t value = __ChConv32<0x79,0x0,0x0,0x0>::value; };
488template<> struct __ChOrd<XMLRecognizer::UCS_4L,'z'> { const static uint32_t value = __ChConv32<0x7a,0x0,0x0,0x0>::value; };
489template<> struct __ChOrd<XMLRecognizer::UCS_4L,'A'> { const static uint32_t value = __ChConv32<0x41,0x0,0x0,0x0>::value; };
490template<> struct __ChOrd<XMLRecognizer::UCS_4L,'B'> { const static uint32_t value = __ChConv32<0x42,0x0,0x0,0x0>::value; };
491template<> struct __ChOrd<XMLRecognizer::UCS_4L,'C'> { const static uint32_t value = __ChConv32<0x43,0x0,0x0,0x0>::value; };
492template<> struct __ChOrd<XMLRecognizer::UCS_4L,'D'> { const static uint32_t value = __ChConv32<0x44,0x0,0x0,0x0>::value; };
493template<> struct __ChOrd<XMLRecognizer::UCS_4L,'E'> { const static uint32_t value = __ChConv32<0x45,0x0,0x0,0x0>::value; };
494template<> struct __ChOrd<XMLRecognizer::UCS_4L,'F'> { const static uint32_t value = __ChConv32<0x46,0x0,0x0,0x0>::value; };
495template<> struct __ChOrd<XMLRecognizer::UCS_4L,'G'> { const static uint32_t value = __ChConv32<0x47,0x0,0x0,0x0>::value; };
496template<> struct __ChOrd<XMLRecognizer::UCS_4L,'H'> { const static uint32_t value = __ChConv32<0x48,0x0,0x0,0x0>::value; };
497template<> struct __ChOrd<XMLRecognizer::UCS_4L,'I'> { const static uint32_t value = __ChConv32<0x49,0x0,0x0,0x0>::value; };
498template<> struct __ChOrd<XMLRecognizer::UCS_4L,'J'> { const static uint32_t value = __ChConv32<0x4a,0x0,0x0,0x0>::value; };
499template<> struct __ChOrd<XMLRecognizer::UCS_4L,'K'> { const static uint32_t value = __ChConv32<0x4b,0x0,0x0,0x0>::value; };
500template<> struct __ChOrd<XMLRecognizer::UCS_4L,'L'> { const static uint32_t value = __ChConv32<0x4c,0x0,0x0,0x0>::value; };
501template<> struct __ChOrd<XMLRecognizer::UCS_4L,'M'> { const static uint32_t value = __ChConv32<0x4d,0x0,0x0,0x0>::value; };
502template<> struct __ChOrd<XMLRecognizer::UCS_4L,'N'> { const static uint32_t value = __ChConv32<0x4e,0x0,0x0,0x0>::value; };
503template<> struct __ChOrd<XMLRecognizer::UCS_4L,'O'> { const static uint32_t value = __ChConv32<0x4f,0x0,0x0,0x0>::value; };
504template<> struct __ChOrd<XMLRecognizer::UCS_4L,'P'> { const static uint32_t value = __ChConv32<0x50,0x0,0x0,0x0>::value; };
505template<> struct __ChOrd<XMLRecognizer::UCS_4L,'Q'> { const static uint32_t value = __ChConv32<0x51,0x0,0x0,0x0>::value; };
506template<> struct __ChOrd<XMLRecognizer::UCS_4L,'R'> { const static uint32_t value = __ChConv32<0x52,0x0,0x0,0x0>::value; };
507template<> struct __ChOrd<XMLRecognizer::UCS_4L,'S'> { const static uint32_t value = __ChConv32<0x53,0x0,0x0,0x0>::value; };
508template<> struct __ChOrd<XMLRecognizer::UCS_4L,'T'> { const static uint32_t value = __ChConv32<0x54,0x0,0x0,0x0>::value; };
509template<> struct __ChOrd<XMLRecognizer::UCS_4L,'U'> { const static uint32_t value = __ChConv32<0x55,0x0,0x0,0x0>::value; };
510template<> struct __ChOrd<XMLRecognizer::UCS_4L,'V'> { const static uint32_t value = __ChConv32<0x56,0x0,0x0,0x0>::value; };
511template<> struct __ChOrd<XMLRecognizer::UCS_4L,'W'> { const static uint32_t value = __ChConv32<0x57,0x0,0x0,0x0>::value; };
512template<> struct __ChOrd<XMLRecognizer::UCS_4L,'X'> { const static uint32_t value = __ChConv32<0x58,0x0,0x0,0x0>::value; };
513template<> struct __ChOrd<XMLRecognizer::UCS_4L,'Y'> { const static uint32_t value = __ChConv32<0x59,0x0,0x0,0x0>::value; };
514template<> struct __ChOrd<XMLRecognizer::UCS_4L,'Z'> { const static uint32_t value = __ChConv32<0x5a,0x0,0x0,0x0>::value; };
515template<> struct __ChOrd<XMLRecognizer::UCS_4L,'0'> { const static uint32_t value = __ChConv32<0x30,0x0,0x0,0x0>::value; };
516template<> struct __ChOrd<XMLRecognizer::UCS_4L,'1'> { const static uint32_t value = __ChConv32<0x31,0x0,0x0,0x0>::value; };
517template<> struct __ChOrd<XMLRecognizer::UCS_4L,'2'> { const static uint32_t value = __ChConv32<0x32,0x0,0x0,0x0>::value; };
518template<> struct __ChOrd<XMLRecognizer::UCS_4L,'3'> { const static uint32_t value = __ChConv32<0x33,0x0,0x0,0x0>::value; };
519template<> struct __ChOrd<XMLRecognizer::UCS_4L,'4'> { const static uint32_t value = __ChConv32<0x34,0x0,0x0,0x0>::value; };
520template<> struct __ChOrd<XMLRecognizer::UCS_4L,'5'> { const static uint32_t value = __ChConv32<0x35,0x0,0x0,0x0>::value; };
521template<> struct __ChOrd<XMLRecognizer::UCS_4L,'6'> { const static uint32_t value = __ChConv32<0x36,0x0,0x0,0x0>::value; };
522template<> struct __ChOrd<XMLRecognizer::UCS_4L,'7'> { const static uint32_t value = __ChConv32<0x37,0x0,0x0,0x0>::value; };
523template<> struct __ChOrd<XMLRecognizer::UCS_4L,'8'> { const static uint32_t value = __ChConv32<0x38,0x0,0x0,0x0>::value; };
524template<> struct __ChOrd<XMLRecognizer::UCS_4L,'9'> { const static uint32_t value = __ChConv32<0x39,0x0,0x0,0x0>::value; };
525
526template<> struct __CodeUnit<XMLRecognizer::UCS_4L> { const static unsigned int size = 4; };
527
528template<> IDISA_ALWAYS_INLINE
529bool atX<XMLRecognizer::UCS_4L>(const void * const character)
530{
531    return __caselessEq<XMLRecognizer::UCS_4L, uint32_t, 'x'>(&((reinterpret_cast<const uint32_t*>(character))[0]));
532}
533
534template<> IDISA_ALWAYS_INLINE
535bool atOctothorpe<XMLRecognizer::UCS_4L>(const void * const character)
536{
537    return ((reinterpret_cast<const uint32_t*>(character))[0] == __ChOrd<XMLRecognizer::UCS_4L, '#'>::value);
538}
539
540
541template<> IDISA_ALWAYS_INLINE
542bool atHexDigit<XMLRecognizer::UCS_4L>(const void * const character, unsigned int & val)
543{
544    return __atHexDigit<XMLRecognizer::UCS_4L, uint32_t>(reinterpret_cast<const uint32_t*>(character), val);
545}
546
547
548template<> IDISA_ALWAYS_INLINE
549bool atDigit<XMLRecognizer::UCS_4L>(const void * const character, unsigned int & val)
550{
551    return __atDigit<XMLRecognizer::UCS_4L, uint32_t>(reinterpret_cast<const uint32_t*>(character), val);
552}
553
554template<> struct __ChOrd<XMLRecognizer::US_ASCII,'"'> { const static uint8_t value = 0x22; };
555template<> struct __ChOrd<XMLRecognizer::US_ASCII,'\''> { const static uint8_t value = 0x27; };
556template<> struct __ChOrd<XMLRecognizer::US_ASCII,'/'> { const static uint8_t value = 0x2f; };
557template<> struct __ChOrd<XMLRecognizer::US_ASCII,'?'> { const static uint8_t value = 0x3f; };
558template<> struct __ChOrd<XMLRecognizer::US_ASCII,'!'> { const static uint8_t value = 0x21; };
559template<> struct __ChOrd<XMLRecognizer::US_ASCII,'&'> { const static uint8_t value = 0x26; };
560template<> struct __ChOrd<XMLRecognizer::US_ASCII,'#'> { const static uint8_t value = 0x23; };
561template<> struct __ChOrd<XMLRecognizer::US_ASCII,'-'> { const static uint8_t value = 0x2d; };
562template<> struct __ChOrd<XMLRecognizer::US_ASCII,'['> { const static uint8_t value = 0x5b; };
563template<> struct __ChOrd<XMLRecognizer::US_ASCII,'>'> { const static uint8_t value = 0x3e; };
564template<> struct __ChOrd<XMLRecognizer::US_ASCII,'='> { const static uint8_t value = 0x3d; };
565template<> struct __ChOrd<XMLRecognizer::US_ASCII,' '> { const static uint8_t value = 0x20; };
566template<> struct __ChOrd<XMLRecognizer::US_ASCII,'\t'> { const static uint8_t value = 0x9; };
567template<> struct __ChOrd<XMLRecognizer::US_ASCII,'\n'> { const static uint8_t value = 0xa; };
568template<> struct __ChOrd<XMLRecognizer::US_ASCII,'\r'> { const static uint8_t value = 0xd; };
569template<> struct __ChOrd<XMLRecognizer::US_ASCII,':'> { const static uint8_t value = 0x3a; };
570template<> struct __ChOrd<XMLRecognizer::US_ASCII,';'> { const static uint8_t value = 0x3b; };
571template<> struct __ChOrd<XMLRecognizer::US_ASCII,'.'> { const static uint8_t value = 0x2e; };
572template<> struct __ChOrd<XMLRecognizer::US_ASCII,'a'> { const static uint8_t value = 0x61; };
573template<> struct __ChOrd<XMLRecognizer::US_ASCII,'b'> { const static uint8_t value = 0x62; };
574template<> struct __ChOrd<XMLRecognizer::US_ASCII,'c'> { const static uint8_t value = 0x63; };
575template<> struct __ChOrd<XMLRecognizer::US_ASCII,'d'> { const static uint8_t value = 0x64; };
576template<> struct __ChOrd<XMLRecognizer::US_ASCII,'e'> { const static uint8_t value = 0x65; };
577template<> struct __ChOrd<XMLRecognizer::US_ASCII,'f'> { const static uint8_t value = 0x66; };
578template<> struct __ChOrd<XMLRecognizer::US_ASCII,'g'> { const static uint8_t value = 0x67; };
579template<> struct __ChOrd<XMLRecognizer::US_ASCII,'h'> { const static uint8_t value = 0x68; };
580template<> struct __ChOrd<XMLRecognizer::US_ASCII,'i'> { const static uint8_t value = 0x69; };
581template<> struct __ChOrd<XMLRecognizer::US_ASCII,'j'> { const static uint8_t value = 0x6a; };
582template<> struct __ChOrd<XMLRecognizer::US_ASCII,'k'> { const static uint8_t value = 0x6b; };
583template<> struct __ChOrd<XMLRecognizer::US_ASCII,'l'> { const static uint8_t value = 0x6c; };
584template<> struct __ChOrd<XMLRecognizer::US_ASCII,'m'> { const static uint8_t value = 0x6d; };
585template<> struct __ChOrd<XMLRecognizer::US_ASCII,'n'> { const static uint8_t value = 0x6e; };
586template<> struct __ChOrd<XMLRecognizer::US_ASCII,'o'> { const static uint8_t value = 0x6f; };
587template<> struct __ChOrd<XMLRecognizer::US_ASCII,'p'> { const static uint8_t value = 0x70; };
588template<> struct __ChOrd<XMLRecognizer::US_ASCII,'q'> { const static uint8_t value = 0x71; };
589template<> struct __ChOrd<XMLRecognizer::US_ASCII,'r'> { const static uint8_t value = 0x72; };
590template<> struct __ChOrd<XMLRecognizer::US_ASCII,'s'> { const static uint8_t value = 0x73; };
591template<> struct __ChOrd<XMLRecognizer::US_ASCII,'t'> { const static uint8_t value = 0x74; };
592template<> struct __ChOrd<XMLRecognizer::US_ASCII,'u'> { const static uint8_t value = 0x75; };
593template<> struct __ChOrd<XMLRecognizer::US_ASCII,'v'> { const static uint8_t value = 0x76; };
594template<> struct __ChOrd<XMLRecognizer::US_ASCII,'w'> { const static uint8_t value = 0x77; };
595template<> struct __ChOrd<XMLRecognizer::US_ASCII,'x'> { const static uint8_t value = 0x78; };
596template<> struct __ChOrd<XMLRecognizer::US_ASCII,'y'> { const static uint8_t value = 0x79; };
597template<> struct __ChOrd<XMLRecognizer::US_ASCII,'z'> { const static uint8_t value = 0x7a; };
598template<> struct __ChOrd<XMLRecognizer::US_ASCII,'A'> { const static uint8_t value = 0x41; };
599template<> struct __ChOrd<XMLRecognizer::US_ASCII,'B'> { const static uint8_t value = 0x42; };
600template<> struct __ChOrd<XMLRecognizer::US_ASCII,'C'> { const static uint8_t value = 0x43; };
601template<> struct __ChOrd<XMLRecognizer::US_ASCII,'D'> { const static uint8_t value = 0x44; };
602template<> struct __ChOrd<XMLRecognizer::US_ASCII,'E'> { const static uint8_t value = 0x45; };
603template<> struct __ChOrd<XMLRecognizer::US_ASCII,'F'> { const static uint8_t value = 0x46; };
604template<> struct __ChOrd<XMLRecognizer::US_ASCII,'G'> { const static uint8_t value = 0x47; };
605template<> struct __ChOrd<XMLRecognizer::US_ASCII,'H'> { const static uint8_t value = 0x48; };
606template<> struct __ChOrd<XMLRecognizer::US_ASCII,'I'> { const static uint8_t value = 0x49; };
607template<> struct __ChOrd<XMLRecognizer::US_ASCII,'J'> { const static uint8_t value = 0x4a; };
608template<> struct __ChOrd<XMLRecognizer::US_ASCII,'K'> { const static uint8_t value = 0x4b; };
609template<> struct __ChOrd<XMLRecognizer::US_ASCII,'L'> { const static uint8_t value = 0x4c; };
610template<> struct __ChOrd<XMLRecognizer::US_ASCII,'M'> { const static uint8_t value = 0x4d; };
611template<> struct __ChOrd<XMLRecognizer::US_ASCII,'N'> { const static uint8_t value = 0x4e; };
612template<> struct __ChOrd<XMLRecognizer::US_ASCII,'O'> { const static uint8_t value = 0x4f; };
613template<> struct __ChOrd<XMLRecognizer::US_ASCII,'P'> { const static uint8_t value = 0x50; };
614template<> struct __ChOrd<XMLRecognizer::US_ASCII,'Q'> { const static uint8_t value = 0x51; };
615template<> struct __ChOrd<XMLRecognizer::US_ASCII,'R'> { const static uint8_t value = 0x52; };
616template<> struct __ChOrd<XMLRecognizer::US_ASCII,'S'> { const static uint8_t value = 0x53; };
617template<> struct __ChOrd<XMLRecognizer::US_ASCII,'T'> { const static uint8_t value = 0x54; };
618template<> struct __ChOrd<XMLRecognizer::US_ASCII,'U'> { const static uint8_t value = 0x55; };
619template<> struct __ChOrd<XMLRecognizer::US_ASCII,'V'> { const static uint8_t value = 0x56; };
620template<> struct __ChOrd<XMLRecognizer::US_ASCII,'W'> { const static uint8_t value = 0x57; };
621template<> struct __ChOrd<XMLRecognizer::US_ASCII,'X'> { const static uint8_t value = 0x58; };
622template<> struct __ChOrd<XMLRecognizer::US_ASCII,'Y'> { const static uint8_t value = 0x59; };
623template<> struct __ChOrd<XMLRecognizer::US_ASCII,'Z'> { const static uint8_t value = 0x5a; };
624template<> struct __ChOrd<XMLRecognizer::US_ASCII,'0'> { const static uint8_t value = 0x30; };
625template<> struct __ChOrd<XMLRecognizer::US_ASCII,'1'> { const static uint8_t value = 0x31; };
626template<> struct __ChOrd<XMLRecognizer::US_ASCII,'2'> { const static uint8_t value = 0x32; };
627template<> struct __ChOrd<XMLRecognizer::US_ASCII,'3'> { const static uint8_t value = 0x33; };
628template<> struct __ChOrd<XMLRecognizer::US_ASCII,'4'> { const static uint8_t value = 0x34; };
629template<> struct __ChOrd<XMLRecognizer::US_ASCII,'5'> { const static uint8_t value = 0x35; };
630template<> struct __ChOrd<XMLRecognizer::US_ASCII,'6'> { const static uint8_t value = 0x36; };
631template<> struct __ChOrd<XMLRecognizer::US_ASCII,'7'> { const static uint8_t value = 0x37; };
632template<> struct __ChOrd<XMLRecognizer::US_ASCII,'8'> { const static uint8_t value = 0x38; };
633template<> struct __ChOrd<XMLRecognizer::US_ASCII,'9'> { const static uint8_t value = 0x39; };
634
635template<> struct __CodeUnit<XMLRecognizer::US_ASCII> { const static unsigned int size = 1; };
636
637template<> IDISA_ALWAYS_INLINE
638bool atX<XMLRecognizer::US_ASCII>(const void * const character)
639{
640    return __caselessEq<XMLRecognizer::US_ASCII, uint8_t, 'x'>(&((reinterpret_cast<const uint8_t*>(character))[0]));
641}
642
643template<> IDISA_ALWAYS_INLINE
644bool atOctothorpe<XMLRecognizer::US_ASCII>(const void * const character)
645{
646    return ((reinterpret_cast<const uint8_t*>(character))[0] == __ChOrd<XMLRecognizer::US_ASCII, '#'>::value);
647}
648
649
650template<> IDISA_ALWAYS_INLINE
651bool atHexDigit<XMLRecognizer::US_ASCII>(const void * const character, unsigned int & val)
652{
653    return __atHexDigit<XMLRecognizer::US_ASCII, uint8_t>(reinterpret_cast<const uint8_t*>(character), val);
654}
655
656
657template<> IDISA_ALWAYS_INLINE
658bool atDigit<XMLRecognizer::US_ASCII>(const void * const character, unsigned int & val)
659{
660    return __atDigit<XMLRecognizer::US_ASCII, uint8_t>(reinterpret_cast<const uint8_t*>(character), val);
661}
662
663
664
665template<> IDISA_ALWAYS_INLINE
666bool atRefGt<XMLRecognizer::US_ASCII>(const void * const string)
667{
668    const uint32_t refGt = __StringConst4<XMLRecognizer::US_ASCII, '&', 'g',  't', ';'>();
669    return __Conv32_4(string) == refGt;
670}
671
672
673
674template<> IDISA_ALWAYS_INLINE
675bool atRefLt<XMLRecognizer::US_ASCII>(const void * const string)
676{
677    const uint32_t refLt = __StringConst4<XMLRecognizer::US_ASCII, '&', 'l',  't', ';'>();
678    return __Conv32_4(string) == refLt;
679}
680
681
682
683template<> IDISA_ALWAYS_INLINE
684bool atRefAmp<XMLRecognizer::US_ASCII>(const void * const string)
685{
686    const uint32_t refAmp = __StringConst4<XMLRecognizer::US_ASCII, 'a', 'm',  'p', ';'>();
687    return refAmp == __Conv32_4(&(reinterpret_cast<const uint8_t*>(string)[1]));
688}
689
690
691
692template<> IDISA_ALWAYS_INLINE
693bool atRefApos<XMLRecognizer::US_ASCII>(const void * const string)
694{
695    const uint64_t refApos =
696    __StringConst8<XMLRecognizer::US_ASCII, '&', 'a',  'p', 'o', 's', ';', 0, 0>();
697    return __Conv64_6(string) == refApos;
698}
699
700
701
702template<> IDISA_ALWAYS_INLINE
703bool atRefQuot<XMLRecognizer::US_ASCII>(const void * const string)
704{
705    const uint64_t refQuot =
706    __StringConst8<XMLRecognizer::US_ASCII, '&', 'q',  'u', 'o', 't', ';', 0, 0>();
707    return __Conv64_6(string) == refQuot;
708}
709
710template<> struct __ChOrd<XMLRecognizer::UTF_8,'"'> { const static uint8_t value = 0x22; };
711template<> struct __ChOrd<XMLRecognizer::UTF_8,'\''> { const static uint8_t value = 0x27; };
712template<> struct __ChOrd<XMLRecognizer::UTF_8,'/'> { const static uint8_t value = 0x2f; };
713template<> struct __ChOrd<XMLRecognizer::UTF_8,'?'> { const static uint8_t value = 0x3f; };
714template<> struct __ChOrd<XMLRecognizer::UTF_8,'!'> { const static uint8_t value = 0x21; };
715template<> struct __ChOrd<XMLRecognizer::UTF_8,'&'> { const static uint8_t value = 0x26; };
716template<> struct __ChOrd<XMLRecognizer::UTF_8,'#'> { const static uint8_t value = 0x23; };
717template<> struct __ChOrd<XMLRecognizer::UTF_8,'-'> { const static uint8_t value = 0x2d; };
718template<> struct __ChOrd<XMLRecognizer::UTF_8,'['> { const static uint8_t value = 0x5b; };
719template<> struct __ChOrd<XMLRecognizer::UTF_8,'>'> { const static uint8_t value = 0x3e; };
720template<> struct __ChOrd<XMLRecognizer::UTF_8,'='> { const static uint8_t value = 0x3d; };
721template<> struct __ChOrd<XMLRecognizer::UTF_8,' '> { const static uint8_t value = 0x20; };
722template<> struct __ChOrd<XMLRecognizer::UTF_8,'\t'> { const static uint8_t value = 0x9; };
723template<> struct __ChOrd<XMLRecognizer::UTF_8,'\n'> { const static uint8_t value = 0xa; };
724template<> struct __ChOrd<XMLRecognizer::UTF_8,'\r'> { const static uint8_t value = 0xd; };
725template<> struct __ChOrd<XMLRecognizer::UTF_8,':'> { const static uint8_t value = 0x3a; };
726template<> struct __ChOrd<XMLRecognizer::UTF_8,';'> { const static uint8_t value = 0x3b; };
727template<> struct __ChOrd<XMLRecognizer::UTF_8,'.'> { const static uint8_t value = 0x2e; };
728template<> struct __ChOrd<XMLRecognizer::UTF_8,'a'> { const static uint8_t value = 0x61; };
729template<> struct __ChOrd<XMLRecognizer::UTF_8,'b'> { const static uint8_t value = 0x62; };
730template<> struct __ChOrd<XMLRecognizer::UTF_8,'c'> { const static uint8_t value = 0x63; };
731template<> struct __ChOrd<XMLRecognizer::UTF_8,'d'> { const static uint8_t value = 0x64; };
732template<> struct __ChOrd<XMLRecognizer::UTF_8,'e'> { const static uint8_t value = 0x65; };
733template<> struct __ChOrd<XMLRecognizer::UTF_8,'f'> { const static uint8_t value = 0x66; };
734template<> struct __ChOrd<XMLRecognizer::UTF_8,'g'> { const static uint8_t value = 0x67; };
735template<> struct __ChOrd<XMLRecognizer::UTF_8,'h'> { const static uint8_t value = 0x68; };
736template<> struct __ChOrd<XMLRecognizer::UTF_8,'i'> { const static uint8_t value = 0x69; };
737template<> struct __ChOrd<XMLRecognizer::UTF_8,'j'> { const static uint8_t value = 0x6a; };
738template<> struct __ChOrd<XMLRecognizer::UTF_8,'k'> { const static uint8_t value = 0x6b; };
739template<> struct __ChOrd<XMLRecognizer::UTF_8,'l'> { const static uint8_t value = 0x6c; };
740template<> struct __ChOrd<XMLRecognizer::UTF_8,'m'> { const static uint8_t value = 0x6d; };
741template<> struct __ChOrd<XMLRecognizer::UTF_8,'n'> { const static uint8_t value = 0x6e; };
742template<> struct __ChOrd<XMLRecognizer::UTF_8,'o'> { const static uint8_t value = 0x6f; };
743template<> struct __ChOrd<XMLRecognizer::UTF_8,'p'> { const static uint8_t value = 0x70; };
744template<> struct __ChOrd<XMLRecognizer::UTF_8,'q'> { const static uint8_t value = 0x71; };
745template<> struct __ChOrd<XMLRecognizer::UTF_8,'r'> { const static uint8_t value = 0x72; };
746template<> struct __ChOrd<XMLRecognizer::UTF_8,'s'> { const static uint8_t value = 0x73; };
747template<> struct __ChOrd<XMLRecognizer::UTF_8,'t'> { const static uint8_t value = 0x74; };
748template<> struct __ChOrd<XMLRecognizer::UTF_8,'u'> { const static uint8_t value = 0x75; };
749template<> struct __ChOrd<XMLRecognizer::UTF_8,'v'> { const static uint8_t value = 0x76; };
750template<> struct __ChOrd<XMLRecognizer::UTF_8,'w'> { const static uint8_t value = 0x77; };
751template<> struct __ChOrd<XMLRecognizer::UTF_8,'x'> { const static uint8_t value = 0x78; };
752template<> struct __ChOrd<XMLRecognizer::UTF_8,'y'> { const static uint8_t value = 0x79; };
753template<> struct __ChOrd<XMLRecognizer::UTF_8,'z'> { const static uint8_t value = 0x7a; };
754template<> struct __ChOrd<XMLRecognizer::UTF_8,'A'> { const static uint8_t value = 0x41; };
755template<> struct __ChOrd<XMLRecognizer::UTF_8,'B'> { const static uint8_t value = 0x42; };
756template<> struct __ChOrd<XMLRecognizer::UTF_8,'C'> { const static uint8_t value = 0x43; };
757template<> struct __ChOrd<XMLRecognizer::UTF_8,'D'> { const static uint8_t value = 0x44; };
758template<> struct __ChOrd<XMLRecognizer::UTF_8,'E'> { const static uint8_t value = 0x45; };
759template<> struct __ChOrd<XMLRecognizer::UTF_8,'F'> { const static uint8_t value = 0x46; };
760template<> struct __ChOrd<XMLRecognizer::UTF_8,'G'> { const static uint8_t value = 0x47; };
761template<> struct __ChOrd<XMLRecognizer::UTF_8,'H'> { const static uint8_t value = 0x48; };
762template<> struct __ChOrd<XMLRecognizer::UTF_8,'I'> { const static uint8_t value = 0x49; };
763template<> struct __ChOrd<XMLRecognizer::UTF_8,'J'> { const static uint8_t value = 0x4a; };
764template<> struct __ChOrd<XMLRecognizer::UTF_8,'K'> { const static uint8_t value = 0x4b; };
765template<> struct __ChOrd<XMLRecognizer::UTF_8,'L'> { const static uint8_t value = 0x4c; };
766template<> struct __ChOrd<XMLRecognizer::UTF_8,'M'> { const static uint8_t value = 0x4d; };
767template<> struct __ChOrd<XMLRecognizer::UTF_8,'N'> { const static uint8_t value = 0x4e; };
768template<> struct __ChOrd<XMLRecognizer::UTF_8,'O'> { const static uint8_t value = 0x4f; };
769template<> struct __ChOrd<XMLRecognizer::UTF_8,'P'> { const static uint8_t value = 0x50; };
770template<> struct __ChOrd<XMLRecognizer::UTF_8,'Q'> { const static uint8_t value = 0x51; };
771template<> struct __ChOrd<XMLRecognizer::UTF_8,'R'> { const static uint8_t value = 0x52; };
772template<> struct __ChOrd<XMLRecognizer::UTF_8,'S'> { const static uint8_t value = 0x53; };
773template<> struct __ChOrd<XMLRecognizer::UTF_8,'T'> { const static uint8_t value = 0x54; };
774template<> struct __ChOrd<XMLRecognizer::UTF_8,'U'> { const static uint8_t value = 0x55; };
775template<> struct __ChOrd<XMLRecognizer::UTF_8,'V'> { const static uint8_t value = 0x56; };
776template<> struct __ChOrd<XMLRecognizer::UTF_8,'W'> { const static uint8_t value = 0x57; };
777template<> struct __ChOrd<XMLRecognizer::UTF_8,'X'> { const static uint8_t value = 0x58; };
778template<> struct __ChOrd<XMLRecognizer::UTF_8,'Y'> { const static uint8_t value = 0x59; };
779template<> struct __ChOrd<XMLRecognizer::UTF_8,'Z'> { const static uint8_t value = 0x5a; };
780template<> struct __ChOrd<XMLRecognizer::UTF_8,'0'> { const static uint8_t value = 0x30; };
781template<> struct __ChOrd<XMLRecognizer::UTF_8,'1'> { const static uint8_t value = 0x31; };
782template<> struct __ChOrd<XMLRecognizer::UTF_8,'2'> { const static uint8_t value = 0x32; };
783template<> struct __ChOrd<XMLRecognizer::UTF_8,'3'> { const static uint8_t value = 0x33; };
784template<> struct __ChOrd<XMLRecognizer::UTF_8,'4'> { const static uint8_t value = 0x34; };
785template<> struct __ChOrd<XMLRecognizer::UTF_8,'5'> { const static uint8_t value = 0x35; };
786template<> struct __ChOrd<XMLRecognizer::UTF_8,'6'> { const static uint8_t value = 0x36; };
787template<> struct __ChOrd<XMLRecognizer::UTF_8,'7'> { const static uint8_t value = 0x37; };
788template<> struct __ChOrd<XMLRecognizer::UTF_8,'8'> { const static uint8_t value = 0x38; };
789template<> struct __ChOrd<XMLRecognizer::UTF_8,'9'> { const static uint8_t value = 0x39; };
790
791template<> struct __CodeUnit<XMLRecognizer::UTF_8> { const static unsigned int size = 1; };
792
793template<> IDISA_ALWAYS_INLINE
794bool atX<XMLRecognizer::UTF_8>(const void * const character)
795{
796    return __caselessEq<XMLRecognizer::UTF_8, uint8_t, 'x'>(&((reinterpret_cast<const uint8_t*>(character))[0]));
797}
798
799template<> IDISA_ALWAYS_INLINE
800bool atOctothorpe<XMLRecognizer::UTF_8>(const void * const character)
801{
802    return ((reinterpret_cast<const uint8_t*>(character))[0] == __ChOrd<XMLRecognizer::UTF_8, '#'>::value);
803}
804
805
806template<> IDISA_ALWAYS_INLINE
807bool atHexDigit<XMLRecognizer::UTF_8>(const void * const character, unsigned int & val)
808{
809    return __atHexDigit<XMLRecognizer::UTF_8, uint8_t>(reinterpret_cast<const uint8_t*>(character), val);
810}
811
812
813template<> IDISA_ALWAYS_INLINE
814bool atDigit<XMLRecognizer::UTF_8>(const void * const character, unsigned int & val)
815{
816    return __atDigit<XMLRecognizer::UTF_8, uint8_t>(reinterpret_cast<const uint8_t*>(character), val);
817}
818
819
820
821template<> IDISA_ALWAYS_INLINE
822bool atRefGt<XMLRecognizer::UTF_8>(const void * const string)
823{
824    const uint32_t refGt = __StringConst4<XMLRecognizer::UTF_8, '&', 'g',  't', ';'>();
825    return __Conv32_4(string) == refGt;
826}
827
828
829
830template<> IDISA_ALWAYS_INLINE
831bool atRefLt<XMLRecognizer::UTF_8>(const void * const string)
832{
833    const uint32_t refLt = __StringConst4<XMLRecognizer::UTF_8, '&', 'l',  't', ';'>();
834    return __Conv32_4(string) == refLt;
835}
836
837
838
839template<> IDISA_ALWAYS_INLINE
840bool atRefAmp<XMLRecognizer::UTF_8>(const void * const string)
841{
842    const uint32_t refAmp = __StringConst4<XMLRecognizer::UTF_8, 'a', 'm',  'p', ';'>();
843    return refAmp == __Conv32_4(&(reinterpret_cast<const uint8_t*>(string)[1]));
844}
845
846
847
848template<> IDISA_ALWAYS_INLINE
849bool atRefApos<XMLRecognizer::UTF_8>(const void * const string)
850{
851    const uint64_t refApos =
852    __StringConst8<XMLRecognizer::UTF_8, '&', 'a',  'p', 'o', 's', ';', 0, 0>();
853    return __Conv64_6(string) == refApos;
854}
855
856
857
858template<> IDISA_ALWAYS_INLINE
859bool atRefQuot<XMLRecognizer::UTF_8>(const void * const string)
860{
861    const uint64_t refQuot =
862    __StringConst8<XMLRecognizer::UTF_8, '&', 'q',  'u', 'o', 't', ';', 0, 0>();
863    return __Conv64_6(string) == refQuot;
864}
865
866template<> struct __ChOrd<XMLRecognizer::UTF_16B,'"'> { const static uint16_t value = __ChConv16<0x0,0x22>::value; };
867template<> struct __ChOrd<XMLRecognizer::UTF_16B,'\''> { const static uint16_t value = __ChConv16<0x0,0x27>::value; };
868template<> struct __ChOrd<XMLRecognizer::UTF_16B,'/'> { const static uint16_t value = __ChConv16<0x0,0x2f>::value; };
869template<> struct __ChOrd<XMLRecognizer::UTF_16B,'?'> { const static uint16_t value = __ChConv16<0x0,0x3f>::value; };
870template<> struct __ChOrd<XMLRecognizer::UTF_16B,'!'> { const static uint16_t value = __ChConv16<0x0,0x21>::value; };
871template<> struct __ChOrd<XMLRecognizer::UTF_16B,'&'> { const static uint16_t value = __ChConv16<0x0,0x26>::value; };
872template<> struct __ChOrd<XMLRecognizer::UTF_16B,'#'> { const static uint16_t value = __ChConv16<0x0,0x23>::value; };
873template<> struct __ChOrd<XMLRecognizer::UTF_16B,'-'> { const static uint16_t value = __ChConv16<0x0,0x2d>::value; };
874template<> struct __ChOrd<XMLRecognizer::UTF_16B,'['> { const static uint16_t value = __ChConv16<0x0,0x5b>::value; };
875template<> struct __ChOrd<XMLRecognizer::UTF_16B,'>'> { const static uint16_t value = __ChConv16<0x0,0x3e>::value; };
876template<> struct __ChOrd<XMLRecognizer::UTF_16B,'='> { const static uint16_t value = __ChConv16<0x0,0x3d>::value; };
877template<> struct __ChOrd<XMLRecognizer::UTF_16B,' '> { const static uint16_t value = __ChConv16<0x0,0x20>::value; };
878template<> struct __ChOrd<XMLRecognizer::UTF_16B,'\t'> { const static uint16_t value = __ChConv16<0x0,0x9>::value; };
879template<> struct __ChOrd<XMLRecognizer::UTF_16B,'\n'> { const static uint16_t value = __ChConv16<0x0,0xa>::value; };
880template<> struct __ChOrd<XMLRecognizer::UTF_16B,'\r'> { const static uint16_t value = __ChConv16<0x0,0xd>::value; };
881template<> struct __ChOrd<XMLRecognizer::UTF_16B,':'> { const static uint16_t value = __ChConv16<0x0,0x3a>::value; };
882template<> struct __ChOrd<XMLRecognizer::UTF_16B,';'> { const static uint16_t value = __ChConv16<0x0,0x3b>::value; };
883template<> struct __ChOrd<XMLRecognizer::UTF_16B,'.'> { const static uint16_t value = __ChConv16<0x0,0x2e>::value; };
884template<> struct __ChOrd<XMLRecognizer::UTF_16B,'a'> { const static uint16_t value = __ChConv16<0x0,0x61>::value; };
885template<> struct __ChOrd<XMLRecognizer::UTF_16B,'b'> { const static uint16_t value = __ChConv16<0x0,0x62>::value; };
886template<> struct __ChOrd<XMLRecognizer::UTF_16B,'c'> { const static uint16_t value = __ChConv16<0x0,0x63>::value; };
887template<> struct __ChOrd<XMLRecognizer::UTF_16B,'d'> { const static uint16_t value = __ChConv16<0x0,0x64>::value; };
888template<> struct __ChOrd<XMLRecognizer::UTF_16B,'e'> { const static uint16_t value = __ChConv16<0x0,0x65>::value; };
889template<> struct __ChOrd<XMLRecognizer::UTF_16B,'f'> { const static uint16_t value = __ChConv16<0x0,0x66>::value; };
890template<> struct __ChOrd<XMLRecognizer::UTF_16B,'g'> { const static uint16_t value = __ChConv16<0x0,0x67>::value; };
891template<> struct __ChOrd<XMLRecognizer::UTF_16B,'h'> { const static uint16_t value = __ChConv16<0x0,0x68>::value; };
892template<> struct __ChOrd<XMLRecognizer::UTF_16B,'i'> { const static uint16_t value = __ChConv16<0x0,0x69>::value; };
893template<> struct __ChOrd<XMLRecognizer::UTF_16B,'j'> { const static uint16_t value = __ChConv16<0x0,0x6a>::value; };
894template<> struct __ChOrd<XMLRecognizer::UTF_16B,'k'> { const static uint16_t value = __ChConv16<0x0,0x6b>::value; };
895template<> struct __ChOrd<XMLRecognizer::UTF_16B,'l'> { const static uint16_t value = __ChConv16<0x0,0x6c>::value; };
896template<> struct __ChOrd<XMLRecognizer::UTF_16B,'m'> { const static uint16_t value = __ChConv16<0x0,0x6d>::value; };
897template<> struct __ChOrd<XMLRecognizer::UTF_16B,'n'> { const static uint16_t value = __ChConv16<0x0,0x6e>::value; };
898template<> struct __ChOrd<XMLRecognizer::UTF_16B,'o'> { const static uint16_t value = __ChConv16<0x0,0x6f>::value; };
899template<> struct __ChOrd<XMLRecognizer::UTF_16B,'p'> { const static uint16_t value = __ChConv16<0x0,0x70>::value; };
900template<> struct __ChOrd<XMLRecognizer::UTF_16B,'q'> { const static uint16_t value = __ChConv16<0x0,0x71>::value; };
901template<> struct __ChOrd<XMLRecognizer::UTF_16B,'r'> { const static uint16_t value = __ChConv16<0x0,0x72>::value; };
902template<> struct __ChOrd<XMLRecognizer::UTF_16B,'s'> { const static uint16_t value = __ChConv16<0x0,0x73>::value; };
903template<> struct __ChOrd<XMLRecognizer::UTF_16B,'t'> { const static uint16_t value = __ChConv16<0x0,0x74>::value; };
904template<> struct __ChOrd<XMLRecognizer::UTF_16B,'u'> { const static uint16_t value = __ChConv16<0x0,0x75>::value; };
905template<> struct __ChOrd<XMLRecognizer::UTF_16B,'v'> { const static uint16_t value = __ChConv16<0x0,0x76>::value; };
906template<> struct __ChOrd<XMLRecognizer::UTF_16B,'w'> { const static uint16_t value = __ChConv16<0x0,0x77>::value; };
907template<> struct __ChOrd<XMLRecognizer::UTF_16B,'x'> { const static uint16_t value = __ChConv16<0x0,0x78>::value; };
908template<> struct __ChOrd<XMLRecognizer::UTF_16B,'y'> { const static uint16_t value = __ChConv16<0x0,0x79>::value; };
909template<> struct __ChOrd<XMLRecognizer::UTF_16B,'z'> { const static uint16_t value = __ChConv16<0x0,0x7a>::value; };
910template<> struct __ChOrd<XMLRecognizer::UTF_16B,'A'> { const static uint16_t value = __ChConv16<0x0,0x41>::value; };
911template<> struct __ChOrd<XMLRecognizer::UTF_16B,'B'> { const static uint16_t value = __ChConv16<0x0,0x42>::value; };
912template<> struct __ChOrd<XMLRecognizer::UTF_16B,'C'> { const static uint16_t value = __ChConv16<0x0,0x43>::value; };
913template<> struct __ChOrd<XMLRecognizer::UTF_16B,'D'> { const static uint16_t value = __ChConv16<0x0,0x44>::value; };
914template<> struct __ChOrd<XMLRecognizer::UTF_16B,'E'> { const static uint16_t value = __ChConv16<0x0,0x45>::value; };
915template<> struct __ChOrd<XMLRecognizer::UTF_16B,'F'> { const static uint16_t value = __ChConv16<0x0,0x46>::value; };
916template<> struct __ChOrd<XMLRecognizer::UTF_16B,'G'> { const static uint16_t value = __ChConv16<0x0,0x47>::value; };
917template<> struct __ChOrd<XMLRecognizer::UTF_16B,'H'> { const static uint16_t value = __ChConv16<0x0,0x48>::value; };
918template<> struct __ChOrd<XMLRecognizer::UTF_16B,'I'> { const static uint16_t value = __ChConv16<0x0,0x49>::value; };
919template<> struct __ChOrd<XMLRecognizer::UTF_16B,'J'> { const static uint16_t value = __ChConv16<0x0,0x4a>::value; };
920template<> struct __ChOrd<XMLRecognizer::UTF_16B,'K'> { const static uint16_t value = __ChConv16<0x0,0x4b>::value; };
921template<> struct __ChOrd<XMLRecognizer::UTF_16B,'L'> { const static uint16_t value = __ChConv16<0x0,0x4c>::value; };
922template<> struct __ChOrd<XMLRecognizer::UTF_16B,'M'> { const static uint16_t value = __ChConv16<0x0,0x4d>::value; };
923template<> struct __ChOrd<XMLRecognizer::UTF_16B,'N'> { const static uint16_t value = __ChConv16<0x0,0x4e>::value; };
924template<> struct __ChOrd<XMLRecognizer::UTF_16B,'O'> { const static uint16_t value = __ChConv16<0x0,0x4f>::value; };
925template<> struct __ChOrd<XMLRecognizer::UTF_16B,'P'> { const static uint16_t value = __ChConv16<0x0,0x50>::value; };
926template<> struct __ChOrd<XMLRecognizer::UTF_16B,'Q'> { const static uint16_t value = __ChConv16<0x0,0x51>::value; };
927template<> struct __ChOrd<XMLRecognizer::UTF_16B,'R'> { const static uint16_t value = __ChConv16<0x0,0x52>::value; };
928template<> struct __ChOrd<XMLRecognizer::UTF_16B,'S'> { const static uint16_t value = __ChConv16<0x0,0x53>::value; };
929template<> struct __ChOrd<XMLRecognizer::UTF_16B,'T'> { const static uint16_t value = __ChConv16<0x0,0x54>::value; };
930template<> struct __ChOrd<XMLRecognizer::UTF_16B,'U'> { const static uint16_t value = __ChConv16<0x0,0x55>::value; };
931template<> struct __ChOrd<XMLRecognizer::UTF_16B,'V'> { const static uint16_t value = __ChConv16<0x0,0x56>::value; };
932template<> struct __ChOrd<XMLRecognizer::UTF_16B,'W'> { const static uint16_t value = __ChConv16<0x0,0x57>::value; };
933template<> struct __ChOrd<XMLRecognizer::UTF_16B,'X'> { const static uint16_t value = __ChConv16<0x0,0x58>::value; };
934template<> struct __ChOrd<XMLRecognizer::UTF_16B,'Y'> { const static uint16_t value = __ChConv16<0x0,0x59>::value; };
935template<> struct __ChOrd<XMLRecognizer::UTF_16B,'Z'> { const static uint16_t value = __ChConv16<0x0,0x5a>::value; };
936template<> struct __ChOrd<XMLRecognizer::UTF_16B,'0'> { const static uint16_t value = __ChConv16<0x0,0x30>::value; };
937template<> struct __ChOrd<XMLRecognizer::UTF_16B,'1'> { const static uint16_t value = __ChConv16<0x0,0x31>::value; };
938template<> struct __ChOrd<XMLRecognizer::UTF_16B,'2'> { const static uint16_t value = __ChConv16<0x0,0x32>::value; };
939template<> struct __ChOrd<XMLRecognizer::UTF_16B,'3'> { const static uint16_t value = __ChConv16<0x0,0x33>::value; };
940template<> struct __ChOrd<XMLRecognizer::UTF_16B,'4'> { const static uint16_t value = __ChConv16<0x0,0x34>::value; };
941template<> struct __ChOrd<XMLRecognizer::UTF_16B,'5'> { const static uint16_t value = __ChConv16<0x0,0x35>::value; };
942template<> struct __ChOrd<XMLRecognizer::UTF_16B,'6'> { const static uint16_t value = __ChConv16<0x0,0x36>::value; };
943template<> struct __ChOrd<XMLRecognizer::UTF_16B,'7'> { const static uint16_t value = __ChConv16<0x0,0x37>::value; };
944template<> struct __ChOrd<XMLRecognizer::UTF_16B,'8'> { const static uint16_t value = __ChConv16<0x0,0x38>::value; };
945template<> struct __ChOrd<XMLRecognizer::UTF_16B,'9'> { const static uint16_t value = __ChConv16<0x0,0x39>::value; };
946
947template<> struct __CodeUnit<XMLRecognizer::UTF_16B> { const static unsigned int size = 2; };
948
949template<> IDISA_ALWAYS_INLINE
950bool atX<XMLRecognizer::UTF_16B>(const void * const character)
951{
952    return __caselessEq<XMLRecognizer::UTF_16B, uint16_t, 'x'>(&((reinterpret_cast<const uint16_t*>(character))[0]));
953}
954
955template<> IDISA_ALWAYS_INLINE
956bool atOctothorpe<XMLRecognizer::UTF_16B>(const void * const character)
957{
958    return ((reinterpret_cast<const uint16_t*>(character))[0] == __ChOrd<XMLRecognizer::UTF_16B, '#'>::value);
959}
960
961
962template<> IDISA_ALWAYS_INLINE
963bool atHexDigit<XMLRecognizer::UTF_16B>(const void * const character, unsigned int & val)
964{
965    return __atHexDigit<XMLRecognizer::UTF_16B, uint16_t>(reinterpret_cast<const uint16_t*>(character), val);
966}
967
968
969template<> IDISA_ALWAYS_INLINE
970bool atDigit<XMLRecognizer::UTF_16B>(const void * const character, unsigned int & val)
971{
972    return __atDigit<XMLRecognizer::UTF_16B, uint16_t>(reinterpret_cast<const uint16_t*>(character), val);
973}
974
975template<> struct __ChOrd<XMLRecognizer::UTF_16L,'"'> { const static uint16_t value = __ChConv16<0x22,0x0>::value; };
976template<> struct __ChOrd<XMLRecognizer::UTF_16L,'\''> { const static uint16_t value = __ChConv16<0x27,0x0>::value; };
977template<> struct __ChOrd<XMLRecognizer::UTF_16L,'/'> { const static uint16_t value = __ChConv16<0x2f,0x0>::value; };
978template<> struct __ChOrd<XMLRecognizer::UTF_16L,'?'> { const static uint16_t value = __ChConv16<0x3f,0x0>::value; };
979template<> struct __ChOrd<XMLRecognizer::UTF_16L,'!'> { const static uint16_t value = __ChConv16<0x21,0x0>::value; };
980template<> struct __ChOrd<XMLRecognizer::UTF_16L,'&'> { const static uint16_t value = __ChConv16<0x26,0x0>::value; };
981template<> struct __ChOrd<XMLRecognizer::UTF_16L,'#'> { const static uint16_t value = __ChConv16<0x23,0x0>::value; };
982template<> struct __ChOrd<XMLRecognizer::UTF_16L,'-'> { const static uint16_t value = __ChConv16<0x2d,0x0>::value; };
983template<> struct __ChOrd<XMLRecognizer::UTF_16L,'['> { const static uint16_t value = __ChConv16<0x5b,0x0>::value; };
984template<> struct __ChOrd<XMLRecognizer::UTF_16L,'>'> { const static uint16_t value = __ChConv16<0x3e,0x0>::value; };
985template<> struct __ChOrd<XMLRecognizer::UTF_16L,'='> { const static uint16_t value = __ChConv16<0x3d,0x0>::value; };
986template<> struct __ChOrd<XMLRecognizer::UTF_16L,' '> { const static uint16_t value = __ChConv16<0x20,0x0>::value; };
987template<> struct __ChOrd<XMLRecognizer::UTF_16L,'\t'> { const static uint16_t value = __ChConv16<0x9,0x0>::value; };
988template<> struct __ChOrd<XMLRecognizer::UTF_16L,'\n'> { const static uint16_t value = __ChConv16<0xa,0x0>::value; };
989template<> struct __ChOrd<XMLRecognizer::UTF_16L,'\r'> { const static uint16_t value = __ChConv16<0xd,0x0>::value; };
990template<> struct __ChOrd<XMLRecognizer::UTF_16L,':'> { const static uint16_t value = __ChConv16<0x3a,0x0>::value; };
991template<> struct __ChOrd<XMLRecognizer::UTF_16L,';'> { const static uint16_t value = __ChConv16<0x3b,0x0>::value; };
992template<> struct __ChOrd<XMLRecognizer::UTF_16L,'.'> { const static uint16_t value = __ChConv16<0x2e,0x0>::value; };
993template<> struct __ChOrd<XMLRecognizer::UTF_16L,'a'> { const static uint16_t value = __ChConv16<0x61,0x0>::value; };
994template<> struct __ChOrd<XMLRecognizer::UTF_16L,'b'> { const static uint16_t value = __ChConv16<0x62,0x0>::value; };
995template<> struct __ChOrd<XMLRecognizer::UTF_16L,'c'> { const static uint16_t value = __ChConv16<0x63,0x0>::value; };
996template<> struct __ChOrd<XMLRecognizer::UTF_16L,'d'> { const static uint16_t value = __ChConv16<0x64,0x0>::value; };
997template<> struct __ChOrd<XMLRecognizer::UTF_16L,'e'> { const static uint16_t value = __ChConv16<0x65,0x0>::value; };
998template<> struct __ChOrd<XMLRecognizer::UTF_16L,'f'> { const static uint16_t value = __ChConv16<0x66,0x0>::value; };
999template<> struct __ChOrd<XMLRecognizer::UTF_16L,'g'> { const static uint16_t value = __ChConv16<0x67,0x0>::value; };
1000template<> struct __ChOrd<XMLRecognizer::UTF_16L,'h'> { const static uint16_t value = __ChConv16<0x68,0x0>::value; };
1001template<> struct __ChOrd<XMLRecognizer::UTF_16L,'i'> { const static uint16_t value = __ChConv16<0x69,0x0>::value; };
1002template<> struct __ChOrd<XMLRecognizer::UTF_16L,'j'> { const static uint16_t value = __ChConv16<0x6a,0x0>::value; };
1003template<> struct __ChOrd<XMLRecognizer::UTF_16L,'k'> { const static uint16_t value = __ChConv16<0x6b,0x0>::value; };
1004template<> struct __ChOrd<XMLRecognizer::UTF_16L,'l'> { const static uint16_t value = __ChConv16<0x6c,0x0>::value; };
1005template<> struct __ChOrd<XMLRecognizer::UTF_16L,'m'> { const static uint16_t value = __ChConv16<0x6d,0x0>::value; };
1006template<> struct __ChOrd<XMLRecognizer::UTF_16L,'n'> { const static uint16_t value = __ChConv16<0x6e,0x0>::value; };
1007template<> struct __ChOrd<XMLRecognizer::UTF_16L,'o'> { const static uint16_t value = __ChConv16<0x6f,0x0>::value; };
1008template<> struct __ChOrd<XMLRecognizer::UTF_16L,'p'> { const static uint16_t value = __ChConv16<0x70,0x0>::value; };
1009template<> struct __ChOrd<XMLRecognizer::UTF_16L,'q'> { const static uint16_t value = __ChConv16<0x71,0x0>::value; };
1010template<> struct __ChOrd<XMLRecognizer::UTF_16L,'r'> { const static uint16_t value = __ChConv16<0x72,0x0>::value; };
1011template<> struct __ChOrd<XMLRecognizer::UTF_16L,'s'> { const static uint16_t value = __ChConv16<0x73,0x0>::value; };
1012template<> struct __ChOrd<XMLRecognizer::UTF_16L,'t'> { const static uint16_t value = __ChConv16<0x74,0x0>::value; };
1013template<> struct __ChOrd<XMLRecognizer::UTF_16L,'u'> { const static uint16_t value = __ChConv16<0x75,0x0>::value; };
1014template<> struct __ChOrd<XMLRecognizer::UTF_16L,'v'> { const static uint16_t value = __ChConv16<0x76,0x0>::value; };
1015template<> struct __ChOrd<XMLRecognizer::UTF_16L,'w'> { const static uint16_t value = __ChConv16<0x77,0x0>::value; };
1016template<> struct __ChOrd<XMLRecognizer::UTF_16L,'x'> { const static uint16_t value = __ChConv16<0x78,0x0>::value; };
1017template<> struct __ChOrd<XMLRecognizer::UTF_16L,'y'> { const static uint16_t value = __ChConv16<0x79,0x0>::value; };
1018template<> struct __ChOrd<XMLRecognizer::UTF_16L,'z'> { const static uint16_t value = __ChConv16<0x7a,0x0>::value; };
1019template<> struct __ChOrd<XMLRecognizer::UTF_16L,'A'> { const static uint16_t value = __ChConv16<0x41,0x0>::value; };
1020template<> struct __ChOrd<XMLRecognizer::UTF_16L,'B'> { const static uint16_t value = __ChConv16<0x42,0x0>::value; };
1021template<> struct __ChOrd<XMLRecognizer::UTF_16L,'C'> { const static uint16_t value = __ChConv16<0x43,0x0>::value; };
1022template<> struct __ChOrd<XMLRecognizer::UTF_16L,'D'> { const static uint16_t value = __ChConv16<0x44,0x0>::value; };
1023template<> struct __ChOrd<XMLRecognizer::UTF_16L,'E'> { const static uint16_t value = __ChConv16<0x45,0x0>::value; };
1024template<> struct __ChOrd<XMLRecognizer::UTF_16L,'F'> { const static uint16_t value = __ChConv16<0x46,0x0>::value; };
1025template<> struct __ChOrd<XMLRecognizer::UTF_16L,'G'> { const static uint16_t value = __ChConv16<0x47,0x0>::value; };
1026template<> struct __ChOrd<XMLRecognizer::UTF_16L,'H'> { const static uint16_t value = __ChConv16<0x48,0x0>::value; };
1027template<> struct __ChOrd<XMLRecognizer::UTF_16L,'I'> { const static uint16_t value = __ChConv16<0x49,0x0>::value; };
1028template<> struct __ChOrd<XMLRecognizer::UTF_16L,'J'> { const static uint16_t value = __ChConv16<0x4a,0x0>::value; };
1029template<> struct __ChOrd<XMLRecognizer::UTF_16L,'K'> { const static uint16_t value = __ChConv16<0x4b,0x0>::value; };
1030template<> struct __ChOrd<XMLRecognizer::UTF_16L,'L'> { const static uint16_t value = __ChConv16<0x4c,0x0>::value; };
1031template<> struct __ChOrd<XMLRecognizer::UTF_16L,'M'> { const static uint16_t value = __ChConv16<0x4d,0x0>::value; };
1032template<> struct __ChOrd<XMLRecognizer::UTF_16L,'N'> { const static uint16_t value = __ChConv16<0x4e,0x0>::value; };
1033template<> struct __ChOrd<XMLRecognizer::UTF_16L,'O'> { const static uint16_t value = __ChConv16<0x4f,0x0>::value; };
1034template<> struct __ChOrd<XMLRecognizer::UTF_16L,'P'> { const static uint16_t value = __ChConv16<0x50,0x0>::value; };
1035template<> struct __ChOrd<XMLRecognizer::UTF_16L,'Q'> { const static uint16_t value = __ChConv16<0x51,0x0>::value; };
1036template<> struct __ChOrd<XMLRecognizer::UTF_16L,'R'> { const static uint16_t value = __ChConv16<0x52,0x0>::value; };
1037template<> struct __ChOrd<XMLRecognizer::UTF_16L,'S'> { const static uint16_t value = __ChConv16<0x53,0x0>::value; };
1038template<> struct __ChOrd<XMLRecognizer::UTF_16L,'T'> { const static uint16_t value = __ChConv16<0x54,0x0>::value; };
1039template<> struct __ChOrd<XMLRecognizer::UTF_16L,'U'> { const static uint16_t value = __ChConv16<0x55,0x0>::value; };
1040template<> struct __ChOrd<XMLRecognizer::UTF_16L,'V'> { const static uint16_t value = __ChConv16<0x56,0x0>::value; };
1041template<> struct __ChOrd<XMLRecognizer::UTF_16L,'W'> { const static uint16_t value = __ChConv16<0x57,0x0>::value; };
1042template<> struct __ChOrd<XMLRecognizer::UTF_16L,'X'> { const static uint16_t value = __ChConv16<0x58,0x0>::value; };
1043template<> struct __ChOrd<XMLRecognizer::UTF_16L,'Y'> { const static uint16_t value = __ChConv16<0x59,0x0>::value; };
1044template<> struct __ChOrd<XMLRecognizer::UTF_16L,'Z'> { const static uint16_t value = __ChConv16<0x5a,0x0>::value; };
1045template<> struct __ChOrd<XMLRecognizer::UTF_16L,'0'> { const static uint16_t value = __ChConv16<0x30,0x0>::value; };
1046template<> struct __ChOrd<XMLRecognizer::UTF_16L,'1'> { const static uint16_t value = __ChConv16<0x31,0x0>::value; };
1047template<> struct __ChOrd<XMLRecognizer::UTF_16L,'2'> { const static uint16_t value = __ChConv16<0x32,0x0>::value; };
1048template<> struct __ChOrd<XMLRecognizer::UTF_16L,'3'> { const static uint16_t value = __ChConv16<0x33,0x0>::value; };
1049template<> struct __ChOrd<XMLRecognizer::UTF_16L,'4'> { const static uint16_t value = __ChConv16<0x34,0x0>::value; };
1050template<> struct __ChOrd<XMLRecognizer::UTF_16L,'5'> { const static uint16_t value = __ChConv16<0x35,0x0>::value; };
1051template<> struct __ChOrd<XMLRecognizer::UTF_16L,'6'> { const static uint16_t value = __ChConv16<0x36,0x0>::value; };
1052template<> struct __ChOrd<XMLRecognizer::UTF_16L,'7'> { const static uint16_t value = __ChConv16<0x37,0x0>::value; };
1053template<> struct __ChOrd<XMLRecognizer::UTF_16L,'8'> { const static uint16_t value = __ChConv16<0x38,0x0>::value; };
1054template<> struct __ChOrd<XMLRecognizer::UTF_16L,'9'> { const static uint16_t value = __ChConv16<0x39,0x0>::value; };
1055
1056template<> struct __CodeUnit<XMLRecognizer::UTF_16L> { const static unsigned int size = 2; };
1057
1058template<> IDISA_ALWAYS_INLINE
1059bool atX<XMLRecognizer::UTF_16L>(const void * const character)
1060{
1061    return __caselessEq<XMLRecognizer::UTF_16L, uint16_t, 'x'>(&((reinterpret_cast<const uint16_t*>(character))[0]));
1062}
1063
1064template<> IDISA_ALWAYS_INLINE
1065bool atOctothorpe<XMLRecognizer::UTF_16L>(const void * const character)
1066{
1067    return ((reinterpret_cast<const uint16_t*>(character))[0] == __ChOrd<XMLRecognizer::UTF_16L, '#'>::value);
1068}
1069
1070
1071template<> IDISA_ALWAYS_INLINE
1072bool atHexDigit<XMLRecognizer::UTF_16L>(const void * const character, unsigned int & val)
1073{
1074    return __atHexDigit<XMLRecognizer::UTF_16L, uint16_t>(reinterpret_cast<const uint16_t*>(character), val);
1075}
1076
1077
1078template<> IDISA_ALWAYS_INLINE
1079bool atDigit<XMLRecognizer::UTF_16L>(const void * const character, unsigned int & val)
1080{
1081    return __atDigit<XMLRecognizer::UTF_16L, uint16_t>(reinterpret_cast<const uint16_t*>(character), val);
1082}
1083
1084
1085
1086/***********************************************************************************************/
1087
1088static bool atAttribute(const XMLCh character)
1089{
1090    return (character == __ChOrd<XMLRecognizer::UTF_16L, '='>::value);
1091}
1092
1093static bool atStartTagWithAttributes(const XMLCh character)
1094{
1095    return atAttribute(character);
1096}
1097
1098static bool atStartTagWithoutAttributes(const XMLCh character, bool & isEmpty)
1099{
1100    const XMLCh EMPTY_TAG = __ChOrd<XMLRecognizer::UTF_16L, '.'>::value;
1101    const XMLCh CLOSE_TAG = __ChOrd<XMLRecognizer::UTF_16L, '>'>::value;
1102    isEmpty = (character == EMPTY_TAG);
1103    return ((character & ~(EMPTY_TAG ^ CLOSE_TAG)) == (EMPTY_TAG & CLOSE_TAG));
1104}
1105
1106static bool atEndOfStartTag(const XMLCh character, bool & isEmpty)
1107{
1108    return atStartTagWithoutAttributes(character, isEmpty);
1109}
1110
1111static bool atEndTag(const XMLCh character)
1112{
1113    return (character == __ChOrd<XMLRecognizer::UTF_16L, '/'>::value);
1114}
1115
1116static bool atProcessingInstruction(const XMLCh character)
1117{
1118    return (character == __ChOrd<XMLRecognizer::UTF_16L, '?'>::value);
1119}
1120
1121static bool atComment(const XMLCh character)
1122{
1123    return (character == __ChOrd<XMLRecognizer::UTF_16L, '-'>::value);
1124}
1125
1126static bool atCDATA(const XMLCh character)
1127{
1128    return (character == __ChOrd<XMLRecognizer::UTF_16L, '['>::value);
1129}
1130
1131
1132/***********************************************************************************************/
1133
1134template<XMLRecognizer::Encodings Format, typename Char> IDISA_ALWAYS_INLINE
1135bool __atDigit(const Char * const character, unsigned int & val)
1136{
1137    const Char canon_0  = __ChOrd<Format, '0'>::value;
1138    const Char canon_9  = __ChOrd<Format, '9'>::value;
1139
1140    const Char ch = *character;
1141
1142    if ((ch >= canon_0) & (ch <= canon_9))
1143    {
1144        val = (val * 10) + ch - canon_0;
1145        return true;
1146    }
1147
1148    return false;
1149}
1150
1151template<XMLRecognizer::Encodings Format, typename Char> IDISA_ALWAYS_INLINE
1152bool __atHexDigit(const Char * const character, unsigned int & val)
1153{
1154    const Char canon_0  = __ChOrd<Format, '0'>::value;
1155    const Char canon_9  = __ChOrd<Format, '9'>::value;
1156
1157    const Char case_bit = __ChOrd<Format, 'a'>::value ^ __ChOrd<Format, 'A'>::value;
1158    const Char canon_A  = __ChOrd<Format, 'a'>::value | case_bit;
1159    const Char canon_F  = __ChOrd<Format, 'f'>::value | case_bit;
1160
1161    const Char ch = *character;
1162
1163    if ((ch >= canon_0) & (ch <= canon_9))
1164    {
1165        val = (val << 4) | (ch - canon_0);
1166        return true;
1167    }
1168
1169    const Char canon_ch = ch | case_bit;
1170    if ((canon_ch >= canon_A) & (canon_ch <= canon_F))
1171    {
1172        val = (val << 4) | (canon_ch - canon_A + 10);
1173        return true;
1174    }
1175
1176    return false;
1177}
1178
1179template<XMLRecognizer::Encodings Format, typename Char, char character> IDISA_ALWAYS_INLINE
1180bool __caselessEq(const Char * const string)
1181{
1182    const Char case_bit = __ChOrd<Format, character>::value ^ __ChOrd<Format, character ^ 0x20>::value;
1183    const Char canon  = __ChOrd<Format, character>::value | case_bit;
1184    const Char ch = string[0] | case_bit;
1185    return (ch == canon);
1186}
1187
1188#undef LOW_BYTE_SHIFT
1189#undef HIGH_BYTE_SHIFT
1190
1191XERCES_CPP_NAMESPACE_END
1192
1193#endif
Note: See TracBrowser for help on using the repository browser.