source: trunk/src/bytelex.h @ 119

Last change on this file since 119 was 119, checked in by cameron, 11 years ago

Parse_PubidLiteral

File size: 13.8 KB
Line 
1/*  bytelex.h - XML lexical recognizers for pseudo-ASCII or
2    EBCDIC-family byte streams
3    Copyright (c) 2008, Robert D. Cameron.
4    Licensed to the public under the Open Software License 3.0.
5    Licensed to International Characters, Inc., under the Academic
6    Free License 3.0.
7*/
8#ifndef BYTELEX_H
9#define BYTELEX_H
10
11#include "xmlmodel.h"
12#include "multiliteral.h"
13
14template<CodeUnit_Base C, unsigned char c>
15inline bool AtChar(unsigned char x8data[]) {
16  return x8data[0] == Ord<C, c>::value;
17}
18
19template<CodeUnit_Base C>
20inline bool AtQuote(unsigned char x8data[]) {
21  return (x8data[0] == Ord<C, '"'>::value) | (x8data[0] == Ord<C, '\''>::value);
22}
23
24// Whitespace recognition.  This varies between XML 1.0 and
25// XML 1.1, but only the XML 1.0 version is needed.
26// Specific ASCII/EBCDIC versions are hard-coded here, because
27// the Ord metafunction currently only works for printable characters.
28// Could be improved. 
29template<XML_version, CodeUnit_Base C>
30inline bool at_WhiteSpace(unsigned char x8data[]);
31
32// Workaround because we lack function partial specialization.
33template<CodeUnit_Base C>
34inline bool at_WhiteSpace_10(unsigned char x8data[]) {
35  unsigned char ch = x8data[0];
36  return (ch == Ord<C, ' '>::value) || 
37         (ch == LF<C>::value) || (ch == LF<C>::value) || (ch == HT<C>::value);
38}
39
40template<>
41inline bool at_WhiteSpace<XML_1_0, ASCII>(unsigned char x8data[]) {
42        return at_WhiteSpace_10<ASCII>(x8data);
43}
44
45template<>
46inline bool at_WhiteSpace<XML_1_0, EBCDIC>(unsigned char x8data[]) {
47        return at_WhiteSpace_10<EBCDIC>(x8data);
48}
49
50template<CodeUnit_Base C>
51inline bool at_EndTag_Start(unsigned char x8data[]) {
52  return s2int16(x8data) == c2int16<C, '<', '/'>::value;
53}
54
55template<CodeUnit_Base C>
56inline bool at_Comment_Start(unsigned char x8data[]) {
57  return s4int32(x8data) == c4int32<C, '<', '!', '-', '-'>::value;
58}
59
60template<CodeUnit_Base C>
61inline bool at_DoubleHyphen(unsigned char x8data[]) {
62  return s2int16(x8data) == c2int16<C, '-', '-'>::value;
63}
64
65template<CodeUnit_Base C>
66inline bool at_Comment_End(unsigned char x8data[]) {
67  return s3int32(x8data) == c3int32<C, '-', '-', '>'>::value;
68}
69
70template<CodeUnit_Base C>
71inline bool at_CDATA_Start(unsigned char x8data[]) {
72  return s8int64(x8data) == 
73         c8int64<C, '<', '!', '[', 'C', 'D', 'A', 'T', 'A'>::value;
74}
75
76template<CodeUnit_Base C>
77inline bool at_CDATA_End(unsigned char x8data[]) {
78  return s3int32(x8data) == c3int32<C, ']', ']', '>'>::value;
79}
80
81template<CodeUnit_Base C>
82inline bool at_PI_Start(unsigned char x8data[]) {
83  return s2int16(x8data) == c2int16<C, '<', '?'>::value;
84}
85
86template<CodeUnit_Base C>
87inline bool at_PI_End(unsigned char x8data[]) {
88  return s2int16(x8data) == c2int16<C, '?', '>'>::value;
89}
90
91template<CodeUnit_Base C>
92inline bool at_CharRef_Start(unsigned char x8data[]) {
93  return s2int16(x8data) == c2int16<C, '&', '#'>::value;
94}
95
96
97template<CodeUnit_Base C>
98inline bool at_EqualsQuote(unsigned char x8data[]) {
99  uint16_t EQ = s2int16(x8data);
100  return (EQ == c2int16<C, '=', '"'>::value) | (EQ == c2int16<C, '=', '\''>::value);
101}
102
103template<CodeUnit_Base C>
104inline bool at_xmlns(unsigned char x8data[]) {
105  return s5int64(x8data) == c5int64<C, 'x', 'm', 'l', 'n', 's'>::value; 
106}
107
108template<CodeUnit_Base C>
109inline bool at_EmptyElementDelim(unsigned char x8data[]) {
110  return s2int16(x8data) == c2int16<C, '/', '>'>::value;
111}
112
113template<CodeUnit_Base C>
114inline bool at_XmlDecl_start(unsigned char x8data[]) {
115  return (s5int64(x8data) == c5int64<C, '<', '?', 'x', 'm', 'l'>::value) &&
116         at_WhiteSpace<XML_1_0, C>(&x8data[5]);
117}
118
119template<CodeUnit_Base C>
120inline bool at_version(unsigned char x8data[]) {
121  return s7int64(x8data) == c7int64<C, 'v', 'e', 'r', 's', 'i', 'o', 'n'>::value;
122}
123
124template<CodeUnit_Base C>
125inline bool at_1_0(unsigned char x8data[]) {
126  return (s5int64(x8data) == c5int64<C, '"', '1', '.', '0', '"'>::value) ||
127         (s5int64(x8data) == c5int64<C, '\'', '1', '.', '0', '\''>::value);
128}
129
130template<CodeUnit_Base C>
131inline bool at_1_1(unsigned char x8data[]) {
132  return (s5int64(x8data) == c5int64<C, '"', '1', '.', '1', '"'>::value) ||
133         (s5int64(x8data) == c5int64<C, '\'', '1', '.', '1', '\''>::value);
134}
135
136template<CodeUnit_Base C>
137inline bool at_encoding(unsigned char x8data[]) {
138  return s8int64(x8data) == c8int64<C, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g'>::value;
139}
140
141template<CodeUnit_Base C>
142inline bool at_standalone(unsigned char x8data[]) {
143  return (s8int64(x8data) == c8int64<C, 's', 't', 'a', 'n', 'd', 'a', 'l', 'o'>::value) &
144         (s2int16(&x8data[8]) == c2int16<C, 'n', 'e'>::value);
145}
146
147template<CodeUnit_Base C>
148inline bool at_yes(unsigned char x8data[]) {
149  return (s5int64(x8data) == c5int64<C, '"', 'y', 'e', 's', '"'>::value) |
150         (s5int64(x8data) == c5int64<C, '\'', 'y', 'e', 's', '\''>::value);
151}
152
153template<CodeUnit_Base C>
154inline bool at_no(unsigned char x8data[]) {
155  return (s4int32(x8data) == c4int32<C, '"', 'n', 'o', '"'>::value) |
156         (s4int32(x8data) == c4int32<C, '\'', 'n', 'o', '\''>::value);
157}
158
159template<CodeUnit_Base C>
160inline bool at_XxMmLll_WS(unsigned char x8data[]) {
161  return caseless_comp<C, 'x', 'm', 'l'>(x8data) &&
162         at_WhiteSpace<XML_1_0, C>(&x8data[3]);
163}
164
165/* The at_ElementTag_Start recognizer rules out '<!', '<?', '</'
166   combinations while returning true for '<' followed by any NameStrt
167   character.
168*/
169template<CodeUnit_Base C>
170inline bool at_ElementTag_Start(unsigned char x8data[]) {
171  return (x8data[0] == Ord<C, '<'>::value) & (x8data[1] != Ord<C, '!'>::value) &
172         (x8data[1] != Ord<C, '?'>::value) & (x8data[1] != Ord<C, '/'>::value);
173}
174
175/* The following ugly hack optimizes for ASCII. */
176template<>
177inline bool at_ElementTag_Start<ASCII>(unsigned char x8data[]) {
178  return (x8data[0] == Ord<ASCII, '<'>::value) &
179         ((x8data[1] & 0xE1) != 0x21);
180}
181
182
183inline bool at_UTF_8(unsigned char x8data[]) {
184  return caseless_comp<ASCII, 'u', 't', 'f', '-', '8'>(x8data);
185}
186
187inline bool at_UCS_2(unsigned char x8data[]) {
188  return caseless_comp<ASCII, 'u', 'c', 's', '-', '2'>(x8data);
189}
190
191inline bool at_UCS_4(unsigned char x8data[]) {
192  return caseless_comp<ASCII, 'u', 'c', 's', '-', '4'>(x8data);
193}
194
195inline bool at_UCS_2LE(unsigned char x8data[]) {
196  return caseless_comp<ASCII, 'u', 'c', 's', '-', '2', 'l', 'e'>(x8data);
197}
198
199inline bool at_UCS_2BE(unsigned char x8data[]) {
200  return caseless_comp<ASCII, 'u', 'c', 's', '-', '2', 'b', 'e'>(x8data);
201}
202
203inline bool at_UCS_4LE(unsigned char x8data[]) {
204  return caseless_comp<ASCII, 'u', 'c', 's', '-', '4', 'l', 'e'>(x8data);
205}
206
207inline bool at_UCS_4BE(unsigned char x8data[]) {
208  return caseless_comp<ASCII, 'u', 'c', 's', '-', '4', 'b', 'e'>(x8data);
209}
210
211inline bool at_UTF_16(unsigned char x8data[]) {
212  return caseless_comp<ASCII, 'u', 't', 'f', '-', '1', '6'>(x8data);
213}
214
215inline bool at_UTF_32(unsigned char x8data[]) {
216  return caseless_comp<ASCII, 'u', 't', 'f', '-', '3', '2'>(x8data);
217}
218
219inline bool at_UTF_16LE(unsigned char x8data[]) {
220  return caseless_comp<ASCII, 'u', 't', 'f', '-', '1', '6', 'l', 'e'>(x8data);
221}
222
223inline bool at_UTF_32LE(unsigned char x8data[]) {
224  return caseless_comp<ASCII, 'u', 't', 'f', '-', '3', '2', 'l', 'e'>(x8data);
225}
226
227inline bool at_UTF_16BE(unsigned char x8data[]) {
228  return caseless_comp<ASCII, 'u', 't', 'f', '-', '1', '6', 'b', 'e'>(x8data);
229}
230
231inline bool at_UTF_32BE(unsigned char x8data[]) {
232  return caseless_comp<ASCII, 'u', 't', 'f', '-', '3', '2', 'b', 'e'>(x8data);
233}
234
235inline bool at_ASCII(unsigned char x8data[]) {
236  return caseless_comp<ASCII, 'a', 's', 'c', 'i', 'i'>(x8data);
237}
238
239inline bool at_Latin1(unsigned char x8data[]) {
240  return caseless_comp<ASCII, 'l', 'a', 't', 'i', 'n', '1'>(x8data);
241}
242
243inline bool at_EBCDIC(unsigned char x8data[]) {
244  return caseless_comp<EBCDIC, 'e', 'b', 'c', 'd', 'i', 'c'>(x8data);
245}
246
247template<CodeUnit_Base C>
248inline bool at_DOCTYPE_start(unsigned char x8data[]) {
249        return s8int64(x8data) == c8int64<C, '<', '!','D', 'O', 'C', 'T', 'Y', 'P'>::value & AtChar<C,'E'>(&x8data[8]);
250}
251
252template<CodeUnit_Base C>
253inline bool at_SYSTEM(unsigned char x8data[]) {
254        return s6int64(x8data) == c6int64<C, 'S', 'Y', 'S', 'T', 'E', 'M'>::value;
255}
256
257template<CodeUnit_Base C>
258inline bool at_PUBLIC(unsigned char x8data[]) {
259        return s6int64(x8data) == c6int64<C, 'P', 'U', 'B', 'L', 'I', 'C'>::value;
260}
261
262template<CodeUnit_Base C>
263inline bool at_ELEMENT(unsigned char x8data[]) {
264        return s7int64(x8data) == c7int64<C, 'E', 'L', 'E', 'M', 'E', 'N', 'T'>::value;
265}
266
267template<CodeUnit_Base C>
268inline bool at_ATTLIST(unsigned char x8data[]) {
269        return s7int64(x8data) == c7int64<C, 'A', 'T', 'T', 'L', 'I', 'S', 'T'>::value;
270}
271
272template<CodeUnit_Base C>
273inline bool at_ENTITY(unsigned char x8data[]) {
274        return s6int64(x8data) == c6int64<C, 'E', 'N', 'T', 'I', 'T', 'Y'>::value;
275}
276
277template<CodeUnit_Base C>
278inline bool at_NOTATION(unsigned char x8data[]) {
279        return s8int64(x8data) == c8int64<C, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N'>::value;
280}
281
282template<CodeUnit_Base C>
283inline bool at_EMPTY(unsigned char x8data[]) {
284        return s5int64(x8data) == c5int64<C, 'E', 'M', 'P', 'T', 'Y'>::value;
285}
286
287template<CodeUnit_Base C>
288inline bool at_PCDATA(unsigned char x8data[]) {
289        return s7int64(x8data) == c7int64<C, '#', 'P', 'C', 'D', 'A', 'T', 'A'>::value;
290}
291
292template<CodeUnit_Base C>
293inline bool at_Para_star(unsigned char x8data[]) {
294        return s2int16(x8data) == c2int16<C, ')', '*'>::value;
295}
296
297template<CodeUnit_Base C>
298inline bool at_CDATA(unsigned char x8data[]) {
299        return s5int64(x8data) == c5int64<C, 'C', 'D', 'A', 'T', 'A'>::value;
300}
301
302template<CodeUnit_Base C>
303inline bool at_ID(unsigned char x8data[]) {
304        return s2int16(x8data) == c2int16<C, 'I', 'D'>::value;
305}
306
307template<CodeUnit_Base C>
308inline bool at_IDREF(unsigned char x8data[]) {
309        return s5int64(x8data) == c5int64<C, 'I', 'D', 'R', 'E', 'F'>::value;
310}
311
312template<CodeUnit_Base C>
313inline bool at_NDATA(unsigned char x8data[]) {
314        return s5int64(x8data) == c5int64<C, 'N', 'D', 'A', 'T', 'A'>::value;
315}
316
317template<CodeUnit_Base C>
318inline bool at_IDREFS(unsigned char x8data[]) {
319        return s6int64(x8data) == c6int64<C, 'I', 'D', 'R', 'E', 'F', 'S'>::value;
320}
321
322template<CodeUnit_Base C>
323inline bool at_ENTITIES(unsigned char x8data[]) {
324        return s8int64(x8data) == c8int64<C, 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S'>::value;
325}
326
327template<CodeUnit_Base C>
328inline bool at_NMTOKEN(unsigned char x8data[]) {
329        return s7int64(x8data) == c7int64<C, 'N', 'M', 'T', 'O', 'K', 'E', 'N'>::value;
330}
331
332template<CodeUnit_Base C>
333inline bool at_NMTOKENS(unsigned char x8data[]) {
334        return s8int64(x8data) == c8int64<C, 'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S'>::value;
335}
336
337template<CodeUnit_Base C>
338inline bool at_REQUIRED(unsigned char x8data[]) {
339        return s8int64(x8data) == c8int64<C, '#', 'R', 'E', 'Q', 'U', 'I', 'R', 'E'>::value
340          & AtChar<C,'D'>(&x8data[8]);
341}
342
343template<CodeUnit_Base C>
344inline bool at_IMPLIED(unsigned char x8data[]) {
345        return s8int64(x8data) == c8int64<C, '#', 'I', 'M', 'P', 'L', 'I', 'E', 'D'>::value;
346}
347
348template<CodeUnit_Base C>
349inline bool at_FIXED(unsigned char x8data[]) {
350        return s6int64(x8data) == c6int64<C, '#', 'F', 'I', 'X', 'E', 'D'>::value;
351}
352
353template<CodeUnit_Base C>
354inline bool at_ANY(unsigned char x8data[]) {
355        return s3int32(x8data) == c3int32<C, 'A', 'N', 'Y'>::value;
356}
357
358template<CodeUnit_Base C>
359inline bool at_INCLUDE(unsigned char x8data[]) {
360        return s7int64(x8data) == c7int64<C, 'I', 'N', 'C', 'L', 'U', 'D', 'E'>::value;
361}
362
363template<CodeUnit_Base C>
364inline bool at_IGNORE(unsigned char x8data[]) {
365        return s6int64(x8data) == c6int64<C, 'I', 'G', 'N', 'O', 'R', 'E'>::value;
366}
367
368template<CodeUnit_Base C>
369inline bool at_condSect_start(unsigned char x8data[]) {
370        return s3int32(x8data) == c3int32<C, '<', '!', '['>::value;
371}
372
373template<CodeUnit_Base C>
374inline bool at_xml(unsigned char x8data[]) { 
375  return (s4int32(x8data) == c4int32<C, '?', 'x', 'm', 'l'>::value);
376}
377
378template<CodeUnit_Base C>
379inline bool at_PubidChar(unsigned char x8data[]) {
380        switch (x8data[0]) {
381                case Ord<C, '0'>::value: case Ord<C, '1'>::value: 
382                case Ord<C, '2'>::value: case Ord<C, '3'>::value: 
383                case Ord<C, '4'>::value: case Ord<C, '5'>::value:
384                case Ord<C, '6'>::value: case Ord<C, '7'>::value:
385                case Ord<C, '8'>::value: case Ord<C, '9'>::value:
386                case Ord<C, 'A'>::value: case Ord<C, 'a'>::value:
387                case Ord<C, 'B'>::value: case Ord<C, 'b'>::value:
388                case Ord<C, 'C'>::value: case Ord<C, 'c'>::value:
389                case Ord<C, 'D'>::value: case Ord<C, 'd'>::value:
390                case Ord<C, 'E'>::value: case Ord<C, 'e'>::value:
391                case Ord<C, 'F'>::value: case Ord<C, 'f'>::value:
392                case Ord<C, 'G'>::value: case Ord<C, 'g'>::value:
393                case Ord<C, 'H'>::value: case Ord<C, 'h'>::value:
394                case Ord<C, 'I'>::value: case Ord<C, 'i'>::value:
395                case Ord<C, 'J'>::value: case Ord<C, 'j'>::value:
396                case Ord<C, 'K'>::value: case Ord<C, 'k'>::value:
397                case Ord<C, 'L'>::value: case Ord<C, 'l'>::value:
398                case Ord<C, 'M'>::value: case Ord<C, 'm'>::value:
399                case Ord<C, 'N'>::value: case Ord<C, 'n'>::value:
400                case Ord<C, 'O'>::value: case Ord<C, 'o'>::value:
401                case Ord<C, 'P'>::value: case Ord<C, 'p'>::value:
402                case Ord<C, 'Q'>::value: case Ord<C, 'q'>::value:
403                case Ord<C, 'R'>::value: case Ord<C, 'r'>::value:
404                case Ord<C, 'S'>::value: case Ord<C, 's'>::value:
405                case Ord<C, 'T'>::value: case Ord<C, 't'>::value:
406                case Ord<C, 'U'>::value: case Ord<C, 'u'>::value:
407                case Ord<C, 'V'>::value: case Ord<C, 'v'>::value:
408                case Ord<C, 'W'>::value: case Ord<C, 'w'>::value:
409                case Ord<C, 'X'>::value: case Ord<C, 'x'>::value:
410                case Ord<C, 'Y'>::value: case Ord<C, 'y'>::value:
411                case Ord<C, 'Z'>::value: case Ord<C, 'z'>::value:
412                case Ord<C, '-'>::value: case Ord<C, '\''>::value:
413                case Ord<C, '('>::value: case Ord<C, ')'>::value:
414                case Ord<C, '+'>::value: case Ord<C, ','>::value:
415                case Ord<C, '.'>::value: case Ord<C, '/'>::value:
416                case Ord<C, ':'>::value: case Ord<C, '='>::value:
417                case Ord<C, '?'>::value: case Ord<C, ';'>::value:
418                case Ord<C, '!'>::value: case Ord<C, '*'>::value:
419                case Ord<C, '#'>::value: case Ord<C, '@'>::value:
420                case Ord<C, '$'>::value: case Ord<C, '_'>::value:
421                case Ord<C, '%'>::value: case Ord<C, ' '>::value:
422                case CR<C>::value: case LF<C>::value:
423                        return true;
424                default: return false;
425        }
426}
427#endif
Note: See TracBrowser for help on using the repository browser.