/xmlbench/trunk

To get this branch, use:
bzr branch http://darksoft.org/webbzr/xmlbench/trunk

« back to all changes in this revision

Viewing changes to parse/parabix.20090211/src/bytelex.h

  • Committer: Suren A. Chilingaryan
  • Date: 2009-09-23 17:13:04 UTC
  • Revision ID: csa@dside.dyndns.org-20090923171304-osvtr4zqb29h11kd
Intel, Tango, Phobos, and RapidXML parsers; Memory benchmark scripts

Show diffs side-by-side

added added

removed removed

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