source: trunk/src/bytelex.h @ 27

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

parabix-0.39

File size: 7.1 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 "xmlparam.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
19// Whitespace recognition.  This varies between XML 1.0 and
20// XML 1.1, but only the XML 1.0 version is needed.
21// Specific ASCII/EBCDIC versions are hard-coded here, because
22// the Ord metafunction currently only works for printable characters.
23// Could be improved. 
24template<XML_version, CodeUnit_Base C>
25inline bool at_WhiteSpace(unsigned char x8data[]);
26
27template<>
28inline bool at_WhiteSpace<XML_1_0, ASCII>(unsigned char x8data[]) {
29  unsigned char ch = x8data[0];
30  return (ch == Ord<ASCII, ' '>::value) || 
31         (ch == 0x0A) || (ch == 0x0D) || (ch == 0x09);
32}
33
34template<>
35inline bool at_WhiteSpace<XML_1_0, EBCDIC>(unsigned char x8data[]) {
36  unsigned char ch = x8data[0];
37  return (ch == Ord<EBCDIC, ' '>::value) || 
38         (ch == 0x25) || (ch == 0x0D) || (ch == 0x05);
39}
40
41
42
43template<CodeUnit_Base C>
44inline bool at_EndTag_Start(unsigned char x8data[]) {
45  return s2int16(x8data) == c2int16<C, '<', '/'>::value;
46}
47
48template<CodeUnit_Base C>
49inline bool at_Comment_Start(unsigned char x8data[]) {
50  return s4int32(x8data) == c4int32<C, '<', '!', '-', '-'>::value;
51}
52
53template<CodeUnit_Base C>
54inline bool at_DoubleHyphen(unsigned char x8data[]) {
55  return s2int16(x8data) == c2int16<C, '-', '-'>::value;
56}
57
58template<CodeUnit_Base C>
59inline bool at_Comment_End(unsigned char x8data[]) {
60  return s3int32(x8data) == c3int32<C, '-', '-', '>'>::value;
61}
62
63template<CodeUnit_Base C>
64inline bool at_CDATA_Start(unsigned char x8data[]) {
65  return s8int64(x8data) == 
66         c8int64<C, '<', '!', '[', 'C', 'D', 'A', 'T', 'A'>::value;
67}
68
69template<CodeUnit_Base C>
70inline bool at_CDATA_End(unsigned char x8data[]) {
71  return s3int32(x8data) == c3int32<C, ']', ']', '>'>::value;
72}
73
74template<CodeUnit_Base C>
75inline bool at_PI_Start(unsigned char x8data[]) {
76  return s2int16(x8data) == c2int16<C, '<', '?'>::value;
77}
78
79template<CodeUnit_Base C>
80inline bool at_PI_End(unsigned char x8data[]) {
81  return s2int16(x8data) == c2int16<C, '?', '>'>::value;
82}
83
84template<CodeUnit_Base C>
85inline bool at_EqualsDQuote(unsigned char x8data[]) {
86  return s2int16(x8data) == c2int16<C, '=', '"'>::value;
87}
88
89template<CodeUnit_Base C>
90inline bool at_EqualsSQuote(unsigned char x8data[]) {
91  return s2int16(x8data) == c2int16<C, '=', '\''>::value;
92}
93
94template<CodeUnit_Base C>
95inline bool at_xmlns(unsigned char x8data[]) {
96  return s5int64(x8data) == c5int64<C, 'x', 'm', 'l', 'n', 's'>::value; 
97}
98
99template<CodeUnit_Base C>
100inline bool at_EmptyElementDelim(unsigned char x8data[]) {
101  return s2int16(x8data) == c2int16<C, '/', '>'>::value;
102}
103
104template<CodeUnit_Base C>
105inline bool at_XmlDecl_start(unsigned char x8data[]) {
106  return (s5int64(x8data) == c5int64<C, '<', '?', 'x', 'm', 'l'>::value) &&
107         at_WhiteSpace<XML_1_0, C>(&x8data[5]);
108}
109
110template<CodeUnit_Base C>
111inline bool at_version(unsigned char x8data[]) {
112  return s7int64(x8data) == c7int64<C, 'v', 'e', 'r', 's', 'i', 'o', 'n'>::value;
113}
114
115template<CodeUnit_Base C>
116inline bool at_1_0(unsigned char x8data[]) {
117  return (s5int64(x8data) == c5int64<C, '"', '1', '.', '0', '"'>::value) ||
118         (s5int64(x8data) == c5int64<C, '\'', '1', '.', '0', '\''>::value);
119}
120
121template<CodeUnit_Base C>
122inline bool at_1_1(unsigned char x8data[]) {
123  return (s5int64(x8data) == c5int64<C, '"', '1', '.', '1', '"'>::value) ||
124         (s5int64(x8data) == c5int64<C, '\'', '1', '.', '1', '\''>::value);
125}
126
127template<CodeUnit_Base C>
128inline bool at_encoding(unsigned char x8data[]) {
129  return s8int64(x8data) == c8int64<C, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g'>::value;
130}
131
132template<CodeUnit_Base C>
133inline bool at_standalone(unsigned char x8data[]) {
134  return (s8int64(x8data) == c8int64<C, 's', 't', 'a', 'n', 'd', 'a', 'l', 'o'>::value) &
135         (s2int16(&x8data[8]) == c2int16<C, 'n', 'e'>::value);
136}
137
138template<CodeUnit_Base C>
139inline bool at_yes(unsigned char x8data[]) {
140  return (s5int64(x8data) == c5int64<C, '"', 'y', 'e', 's', '"'>::value) |
141         (s5int64(x8data) == c5int64<C, '\'', 'y', 'e', 's', '\''>::value);
142}
143
144template<CodeUnit_Base C>
145inline bool at_no(unsigned char x8data[]) {
146  return (s4int32(x8data) == c4int32<C, '"', 'n', 'o', '"'>::value) |
147         (s4int32(x8data) == c4int32<C, '\'', 'n', 'o', '\''>::value);
148}
149
150template<CodeUnit_Base C>
151inline bool at_XxMmLll_WS(unsigned char x8data[]) {
152  return caseless_comp<C, 'x', 'm', 'l'>(x8data) &&
153         at_WhiteSpace<XML_1_0, C>(&x8data[3]);
154}
155
156
157/* The at_ElementTag_Start recognizer rules out '<!', '<?', '</'
158   combinations while returning true for '<' followed by any NameStrt
159   character.
160
161   The following is ugly and works only for ASCII.
162*/
163template<CodeUnit_Base C>
164inline bool at_ElementTag_Start(unsigned char x8data[]);
165
166template<>
167inline bool at_ElementTag_Start<ASCII>(unsigned char x8data[]) {
168  return (x8data[0] == Ord<ASCII, '<'>::value) &
169         ((x8data[1] & 0xE1) != 0x21);
170}
171
172template<CodeUnit_Base C>
173inline bool at_UTF_8(unsigned char x8data[]) {
174  return caseless_comp<C, 'u', 't', 'f', '-', '8'>(x8data);
175}
176
177template<CodeUnit_Base C>
178inline bool at_UCS_2(unsigned char x8data[]) {
179  return caseless_comp<C, 'u', 'c', 's', '-', '2'>(x8data);
180}
181
182template<CodeUnit_Base C>
183inline bool at_UCS_4(unsigned char x8data[]) {
184  return caseless_comp<C, 'u', 'c', 's', '-', '4'>(x8data);
185}
186
187template<CodeUnit_Base C>
188inline bool at_UCS_2LE(unsigned char x8data[]) {
189  return caseless_comp<C, 'u', 'c', 's', '-', '2', 'l', 'e'>(x8data);
190}
191
192template<CodeUnit_Base C>
193inline bool at_UCS_2BE(unsigned char x8data[]) {
194  return caseless_comp<C, 'u', 'c', 's', '-', '2', 'b', 'e'>(x8data);
195}
196
197template<CodeUnit_Base C>
198inline bool at_UCS_4LE(unsigned char x8data[]) {
199  return caseless_comp<C, 'u', 'c', 's', '-', '4', 'l', 'e'>(x8data);
200}
201
202template<CodeUnit_Base C>
203inline bool at_UCS_4BE(unsigned char x8data[]) {
204  return caseless_comp<C, 'u', 'c', 's', '-', '4', 'b', 'e'>(x8data);
205}
206
207template<CodeUnit_Base C>
208inline bool at_UTF_16(unsigned char x8data[]) {
209  return caseless_comp<C, 'u', 't', 'f', '-', '1', '6'>(x8data);
210}
211
212template<CodeUnit_Base C>
213inline bool at_UTF_32(unsigned char x8data[]) {
214  return caseless_comp<C, 'u', 't', 'f', '-', '3', '2'>(x8data);
215}
216
217template<CodeUnit_Base C>
218inline bool at_UTF_16LE(unsigned char x8data[]) {
219  return caseless_comp<C, 'u', 't', 'f', '-', '1', '6', 'l', 'e'>(x8data);
220}
221
222template<CodeUnit_Base C>
223inline bool at_UTF_32LE(unsigned char x8data[]) {
224  return caseless_comp<C, 'u', 't', 'f', '-', '3', '2', 'l', 'e'>(x8data);
225}
226
227template<CodeUnit_Base C>
228inline bool at_UTF_16BE(unsigned char x8data[]) {
229  return caseless_comp<C, 'u', 't', 'f', '-', '1', '6', 'b', 'e'>(x8data);
230}
231
232template<CodeUnit_Base C>
233inline bool at_UTF_32BE(unsigned char x8data[]) {
234  return caseless_comp<C, 'u', 't', 'f', '-', '3', '2', 'b', 'e'>(x8data);
235}
236
237
238
239#endif
Note: See TracBrowser for help on using the repository browser.