source: trunk/src/bytelex.h @ 115

Last change on this file since 115 was 115, checked in by lindanl, 11 years ago

various error checks in parsing

File size: 11.5 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
32template<>
33inline bool at_WhiteSpace<XML_1_0, ASCII>(unsigned char x8data[]) {
34  unsigned char ch = x8data[0];
35  return (ch == Ord<ASCII, ' '>::value) || 
36         (ch == 0x0A) || (ch == 0x0D) || (ch == 0x09);
37}
38
39template<>
40inline bool at_WhiteSpace<XML_1_0, EBCDIC>(unsigned char x8data[]) {
41  unsigned char ch = x8data[0];
42  return (ch == Ord<EBCDIC, ' '>::value) || 
43         (ch == 0x25) || (ch == 0x0D) || (ch == 0x05);
44}
45
46template<CodeUnit_Base C>
47inline bool at_EndTag_Start(unsigned char x8data[]) {
48  return s2int16(x8data) == c2int16<C, '<', '/'>::value;
49}
50
51template<CodeUnit_Base C>
52inline bool at_Comment_Start(unsigned char x8data[]) {
53  return s4int32(x8data) == c4int32<C, '<', '!', '-', '-'>::value;
54}
55
56template<CodeUnit_Base C>
57inline bool at_DoubleHyphen(unsigned char x8data[]) {
58  return s2int16(x8data) == c2int16<C, '-', '-'>::value;
59}
60
61template<CodeUnit_Base C>
62inline bool at_Comment_End(unsigned char x8data[]) {
63  return s3int32(x8data) == c3int32<C, '-', '-', '>'>::value;
64}
65
66template<CodeUnit_Base C>
67inline bool at_CDATA_Start(unsigned char x8data[]) {
68  return s8int64(x8data) == 
69         c8int64<C, '<', '!', '[', 'C', 'D', 'A', 'T', 'A'>::value;
70}
71
72template<CodeUnit_Base C>
73inline bool at_CDATA_End(unsigned char x8data[]) {
74  return s3int32(x8data) == c3int32<C, ']', ']', '>'>::value;
75}
76
77template<CodeUnit_Base C>
78inline bool at_PI_Start(unsigned char x8data[]) {
79  return s2int16(x8data) == c2int16<C, '<', '?'>::value;
80}
81
82template<CodeUnit_Base C>
83inline bool at_PI_End(unsigned char x8data[]) {
84  return s2int16(x8data) == c2int16<C, '?', '>'>::value;
85}
86
87template<CodeUnit_Base C>
88inline bool at_CharRef_Start(unsigned char x8data[]) {
89  return s2int16(x8data) == c2int16<C, '&', '#'>::value;
90}
91
92
93template<CodeUnit_Base C>
94inline bool at_EqualsQuote(unsigned char x8data[]) {
95  uint16_t EQ = s2int16(x8data);
96  return (EQ == c2int16<C, '=', '"'>::value) | (EQ == c2int16<C, '=', '\''>::value);
97}
98
99template<CodeUnit_Base C>
100inline bool at_xmlns(unsigned char x8data[]) {
101  return s5int64(x8data) == c5int64<C, 'x', 'm', 'l', 'n', 's'>::value; 
102}
103
104template<CodeUnit_Base C>
105inline bool at_EmptyElementDelim(unsigned char x8data[]) {
106  return s2int16(x8data) == c2int16<C, '/', '>'>::value;
107}
108
109template<CodeUnit_Base C>
110inline bool at_XmlDecl_start(unsigned char x8data[]) {
111  return (s5int64(x8data) == c5int64<C, '<', '?', 'x', 'm', 'l'>::value) &&
112         at_WhiteSpace<XML_1_0, C>(&x8data[5]);
113}
114
115template<CodeUnit_Base C>
116inline bool at_version(unsigned char x8data[]) {
117  return s7int64(x8data) == c7int64<C, 'v', 'e', 'r', 's', 'i', 'o', 'n'>::value;
118}
119
120template<CodeUnit_Base C>
121inline bool at_1_0(unsigned char x8data[]) {
122  return (s5int64(x8data) == c5int64<C, '"', '1', '.', '0', '"'>::value) ||
123         (s5int64(x8data) == c5int64<C, '\'', '1', '.', '0', '\''>::value);
124}
125
126template<CodeUnit_Base C>
127inline bool at_1_1(unsigned char x8data[]) {
128  return (s5int64(x8data) == c5int64<C, '"', '1', '.', '1', '"'>::value) ||
129         (s5int64(x8data) == c5int64<C, '\'', '1', '.', '1', '\''>::value);
130}
131
132template<CodeUnit_Base C>
133inline bool at_encoding(unsigned char x8data[]) {
134  return s8int64(x8data) == c8int64<C, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g'>::value;
135}
136
137template<CodeUnit_Base C>
138inline bool at_standalone(unsigned char x8data[]) {
139  return (s8int64(x8data) == c8int64<C, 's', 't', 'a', 'n', 'd', 'a', 'l', 'o'>::value) &
140         (s2int16(&x8data[8]) == c2int16<C, 'n', 'e'>::value);
141}
142
143template<CodeUnit_Base C>
144inline bool at_yes(unsigned char x8data[]) {
145  return (s5int64(x8data) == c5int64<C, '"', 'y', 'e', 's', '"'>::value) |
146         (s5int64(x8data) == c5int64<C, '\'', 'y', 'e', 's', '\''>::value);
147}
148
149template<CodeUnit_Base C>
150inline bool at_no(unsigned char x8data[]) {
151  return (s4int32(x8data) == c4int32<C, '"', 'n', 'o', '"'>::value) |
152         (s4int32(x8data) == c4int32<C, '\'', 'n', 'o', '\''>::value);
153}
154
155template<CodeUnit_Base C>
156inline bool at_XxMmLll_WS(unsigned char x8data[]) {
157  return caseless_comp<C, 'x', 'm', 'l'>(x8data) &&
158         at_WhiteSpace<XML_1_0, C>(&x8data[3]);
159}
160
161/* The at_ElementTag_Start recognizer rules out '<!', '<?', '</'
162   combinations while returning true for '<' followed by any NameStrt
163   character.
164*/
165template<CodeUnit_Base C>
166inline bool at_ElementTag_Start(unsigned char x8data[]) {
167  return (x8data[0] == Ord<C, '<'>::value) & (x8data[1] != Ord<C, '!'>::value) &
168         (x8data[1] != Ord<C, '?'>::value) & (x8data[1] != Ord<C, '/'>::value);
169}
170
171/* The following ugly hack optimizes for ASCII. */
172template<>
173inline bool at_ElementTag_Start<ASCII>(unsigned char x8data[]) {
174  return (x8data[0] == Ord<ASCII, '<'>::value) &
175         ((x8data[1] & 0xE1) != 0x21);
176}
177
178
179inline bool at_UTF_8(unsigned char x8data[]) {
180  return caseless_comp<ASCII, 'u', 't', 'f', '-', '8'>(x8data);
181}
182
183inline bool at_UCS_2(unsigned char x8data[]) {
184  return caseless_comp<ASCII, 'u', 'c', 's', '-', '2'>(x8data);
185}
186
187inline bool at_UCS_4(unsigned char x8data[]) {
188  return caseless_comp<ASCII, 'u', 'c', 's', '-', '4'>(x8data);
189}
190
191inline bool at_UCS_2LE(unsigned char x8data[]) {
192  return caseless_comp<ASCII, 'u', 'c', 's', '-', '2', 'l', 'e'>(x8data);
193}
194
195inline bool at_UCS_2BE(unsigned char x8data[]) {
196  return caseless_comp<ASCII, 'u', 'c', 's', '-', '2', 'b', 'e'>(x8data);
197}
198
199inline bool at_UCS_4LE(unsigned char x8data[]) {
200  return caseless_comp<ASCII, 'u', 'c', 's', '-', '4', 'l', 'e'>(x8data);
201}
202
203inline bool at_UCS_4BE(unsigned char x8data[]) {
204  return caseless_comp<ASCII, 'u', 'c', 's', '-', '4', 'b', 'e'>(x8data);
205}
206
207inline bool at_UTF_16(unsigned char x8data[]) {
208  return caseless_comp<ASCII, 'u', 't', 'f', '-', '1', '6'>(x8data);
209}
210
211inline bool at_UTF_32(unsigned char x8data[]) {
212  return caseless_comp<ASCII, 'u', 't', 'f', '-', '3', '2'>(x8data);
213}
214
215inline bool at_UTF_16LE(unsigned char x8data[]) {
216  return caseless_comp<ASCII, 'u', 't', 'f', '-', '1', '6', 'l', 'e'>(x8data);
217}
218
219inline bool at_UTF_32LE(unsigned char x8data[]) {
220  return caseless_comp<ASCII, 'u', 't', 'f', '-', '3', '2', 'l', 'e'>(x8data);
221}
222
223inline bool at_UTF_16BE(unsigned char x8data[]) {
224  return caseless_comp<ASCII, 'u', 't', 'f', '-', '1', '6', 'b', 'e'>(x8data);
225}
226
227inline bool at_UTF_32BE(unsigned char x8data[]) {
228  return caseless_comp<ASCII, 'u', 't', 'f', '-', '3', '2', 'b', 'e'>(x8data);
229}
230
231inline bool at_ASCII(unsigned char x8data[]) {
232  return caseless_comp<ASCII, 'a', 's', 'c', 'i', 'i'>(x8data);
233}
234
235inline bool at_Latin1(unsigned char x8data[]) {
236  return caseless_comp<ASCII, 'l', 'a', 't', 'i', 'n', '1'>(x8data);
237}
238
239inline bool at_EBCDIC(unsigned char x8data[]) {
240  return caseless_comp<EBCDIC, 'e', 'b', 'c', 'd', 'i', 'c'>(x8data);
241}
242
243template<CodeUnit_Base C>
244inline bool at_DOCTYPE_start(unsigned char x8data[]) {
245        return s8int64(x8data) == c8int64<C, '<', '!','D', 'O', 'C', 'T', 'Y', 'P'>::value & AtChar<C,'E'>(&x8data[8]);
246}
247
248template<CodeUnit_Base C>
249inline bool at_SYSTEM(unsigned char x8data[]) {
250        return s6int64(x8data) == c6int64<C, 'S', 'Y', 'S', 'T', 'E', 'M'>::value;
251}
252
253template<CodeUnit_Base C>
254inline bool at_PUBLIC(unsigned char x8data[]) {
255        return s6int64(x8data) == c6int64<C, 'P', 'U', 'B', 'L', 'I', 'C'>::value;
256}
257
258template<CodeUnit_Base C>
259inline bool at_ELEMENT(unsigned char x8data[]) {
260        return s7int64(x8data) == c7int64<C, 'E', 'L', 'E', 'M', 'E', 'N', 'T'>::value;
261}
262
263template<CodeUnit_Base C>
264inline bool at_ATTLIST(unsigned char x8data[]) {
265        return s7int64(x8data) == c7int64<C, 'A', 'T', 'T', 'L', 'I', 'S', 'T'>::value;
266}
267
268template<CodeUnit_Base C>
269inline bool at_ENTITY(unsigned char x8data[]) {
270        return s6int64(x8data) == c6int64<C, 'E', 'N', 'T', 'I', 'T', 'Y'>::value;
271}
272
273template<CodeUnit_Base C>
274inline bool at_NOTATION(unsigned char x8data[]) {
275        return s8int64(x8data) == c8int64<C, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N'>::value;
276}
277
278template<CodeUnit_Base C>
279inline bool at_EMPTY(unsigned char x8data[]) {
280        return s5int64(x8data) == c5int64<C, 'E', 'M', 'P', 'T', 'Y'>::value;
281}
282
283template<CodeUnit_Base C>
284inline bool at_PCDATA(unsigned char x8data[]) {
285        return s7int64(x8data) == c7int64<C, '#', 'P', 'C', 'D', 'A', 'T', 'A'>::value;
286}
287
288template<CodeUnit_Base C>
289inline bool at_Para_star(unsigned char x8data[]) {
290        return s2int16(x8data) == c2int16<C, ')', '*'>::value;
291}
292
293template<CodeUnit_Base C>
294inline bool at_CDATA(unsigned char x8data[]) {
295        return s5int64(x8data) == c5int64<C, 'C', 'D', 'A', 'T', 'A'>::value;
296}
297
298template<CodeUnit_Base C>
299inline bool at_ID(unsigned char x8data[]) {
300        return s2int16(x8data) == c2int16<C, 'I', 'D'>::value;
301}
302
303template<CodeUnit_Base C>
304inline bool at_IDREF(unsigned char x8data[]) {
305        return s5int64(x8data) == c5int64<C, 'I', 'D', 'R', 'E', 'F'>::value;
306}
307
308template<CodeUnit_Base C>
309inline bool at_NDATA(unsigned char x8data[]) {
310        return s5int64(x8data) == c5int64<C, 'N', 'D', 'A', 'T', 'A'>::value;
311}
312
313template<CodeUnit_Base C>
314inline bool at_IDREFS(unsigned char x8data[]) {
315        return s6int64(x8data) == c6int64<C, 'I', 'D', 'R', 'E', 'F', 'S'>::value;
316}
317
318template<CodeUnit_Base C>
319inline bool at_ENTITIES(unsigned char x8data[]) {
320        return s8int64(x8data) == c8int64<C, 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S'>::value;
321}
322
323template<CodeUnit_Base C>
324inline bool at_NMTOKEN(unsigned char x8data[]) {
325        return s7int64(x8data) == c7int64<C, 'N', 'M', 'T', 'O', 'K', 'E', 'N'>::value;
326}
327
328template<CodeUnit_Base C>
329inline bool at_NMTOKENS(unsigned char x8data[]) {
330        return s8int64(x8data) == c8int64<C, 'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S'>::value;
331}
332
333template<CodeUnit_Base C>
334inline bool at_REQUIRED(unsigned char x8data[]) {
335        return s8int64(x8data) == c8int64<C, '#', 'R', 'E', 'Q', 'U', 'I', 'R', 'E'>::value
336          & AtChar<C,'D'>(&x8data[8]);
337}
338
339template<CodeUnit_Base C>
340inline bool at_IMPLIED(unsigned char x8data[]) {
341        return s8int64(x8data) == c8int64<C, '#', 'I', 'M', 'P', 'L', 'I', 'E', 'D'>::value;
342}
343
344template<CodeUnit_Base C>
345inline bool at_FIXED(unsigned char x8data[]) {
346        return s6int64(x8data) == c6int64<C, '#', 'F', 'I', 'X', 'E', 'D'>::value;
347}
348
349template<CodeUnit_Base C>
350inline bool at_ANY(unsigned char x8data[]) {
351        return s3int32(x8data) == c3int32<C, 'A', 'N', 'Y'>::value;
352}
353
354template<CodeUnit_Base C>
355inline bool at_INCLUDE(unsigned char x8data[]) {
356        return s7int64(x8data) == c7int64<C, 'I', 'N', 'C', 'L', 'U', 'D', 'E'>::value;
357}
358
359template<CodeUnit_Base C>
360inline bool at_IGNORE(unsigned char x8data[]) {
361        return s6int64(x8data) == c6int64<C, 'I', 'G', 'N', 'O', 'R', 'E'>::value;
362}
363
364template<CodeUnit_Base C>
365inline bool at_condSect_start(unsigned char x8data[]) {
366        return s3int32(x8data) == c3int32<C, '<', '!', '['>::value;
367}
368template<CodeUnit_Base C>
369inline bool at_xml(unsigned char x8data[]) {
370  return (s4int32(x8data) == c4int32<C, '?', 'x', 'm', 'l'>::value);
371}
372#endif
Note: See TracBrowser for help on using the repository browser.