source: trunk/src/bytelex.h @ 59

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

Caseless comparison fix; encoding names (prelim)

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