source: trunk/src/bitlex.c @ 78

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

Update NameFollow? for DTDs.

File size: 34.8 KB
Line 
1/*  bitlex - Lexical Item Stream Module.
2    Copyright (c) 2007, 2008, Robert D. Cameron.
3    Licensed to the public under the Open Software License 3.0.
4    Licensed to International Characters, Inc., under the Academic
5    Free License 3.0.
6
7*/
8
9#include "bitlex.h"
10#include "../lib/lib_simd.h"
11
12#ifdef CODE_CLOCKING
13#include "../codeclocker/clocker/code_clocker_session.h"
14Code_Clocker * transpose_clocker;
15Code_Clocker * WS_Control_clocker;
16Code_Clocker * MarkupStreams_clocker;
17Code_Clocker * char_validation_clocker;
18#endif
19
20
21Lexer_Interface::Lexer_Interface(Model_Info * m, LexicalStreamSet *l) {
22        model_info = m;
23        parsing_engine_data = l;
24
25        x8basis = (BitBlockBasis *) simd_new(BUFFER_SIZE/PACKSIZE);
26        validation_stream = (BitBlock *) simd_new(BUFFER_BLOCKS+SENTINEL_BLOCKS);
27};
28
29
30Lexer_Interface::~Lexer_Interface() {
31        simd_delete((SIMD_type *) validation_stream);
32        simd_delete((SIMD_type *) x8basis);
33};
34
35
36
37void NoEncodingError(char * msg) {
38        printf("Error : %s\n", msg);
39        exit(-1);
40}
41
42void EncodingError(char * msg, unsigned char * encoding, int lgth) {
43        printf("Error : Illegal/unsupported %s encoding of length %i: \"", msg, lgth);
44        for (int i = 0; i < lgth; i++) printf("%c", encoding[i]);
45        printf("\"\n"); 
46        exit(-1);
47}
48
49template <>
50Lexer_Interface * Lexer<ASCII>::LexerFactory(Model_Info * m, LexicalStreamSet *l) {
51#ifdef CODE_CLOCKING
52        WS_Control_clocker = register_Code_Clocker("WS", "WhiteSpace/Control\n");
53        MarkupStreams_clocker = register_Code_Clocker("bitlex", "Markup streams\n");
54        char_validation_clocker = register_Code_Clocker("charcheck", "Character validation\n");
55#endif
56        if (!(m->has_encoding_decl)) {
57                // Must be UTF-8 or UTF-16; UTF-16 requires a ByteOrderMark.
58                if (m->code_unit_size == SingleByte) return new UTF_8_Lexer(m, l);
59                else if ((m->code_unit_size == DoubleByte))
60                        if (m->BOM_units == 1) return new UTF_16_Lexer(m, l);
61                        else NoEncodingError("UTF-16 implied but no byte order found.");
62                else NoEncodingError("UTF-32 without an encoding declaration.\n");
63        }
64        else {
65                int lgth = strlen((const char *) m->encoding);
66                CodeUnit_ByteOrder order = m->byte_order;
67                switch (m->code_unit_size) {
68                case SingleByte:
69                        if ((lgth == 5) && at_UTF_8(m->encoding))
70                                return new UTF_8_Lexer(m, l);
71                        else if ((lgth == 5) && at_ASCII(m->encoding))
72                                return new ASCII_7_Lexer(m, l);
73                        else if ((lgth == 6)  && at_Latin1(m->encoding))
74                                return new EASCII_8_Lexer(m, l);
75                        /* Really need a table-based lookup here */
76                        else EncodingError("8-bit", m->encoding, lgth);
77                case DoubleByte:
78                        if (m->BOM_units == 1) 
79                                if ((lgth == 6) && at_UTF_16(m->encoding))
80                                        return new UTF_16_Lexer(m, l);
81                                else if ((lgth == 5) && at_UCS_2(m->encoding))
82                                        return new UCS_2_Lexer(m, l);
83                                else EncodingError("16-bit", m->encoding, lgth);
84                        else if (order == BigEndian)
85                                if ((lgth == 8) && at_UTF_16BE(m->encoding))
86                                        return new UTF_16_Lexer(m, l);
87                                else if ((lgth == 7) && at_UCS_2BE(m->encoding))
88                                        return new UCS_2_Lexer(m, l);
89                                else EncodingError("16BE", m->encoding, lgth);
90                        else /*if (order == LittleEndian)*/
91                                if ((lgth == 8) && at_UTF_16LE(m->encoding))
92                                        return new UTF_16_Lexer(m, l);
93                                else if ((lgth == 7) && at_UCS_2LE(m->encoding))
94                                        return new UCS_2_Lexer(m, l);
95                                else EncodingError("16LE", m->encoding, lgth);
96                case QuadByte:
97                        if (m->BOM_units == 1) 
98                                if ((lgth == 6) && at_UTF_32(m->encoding))
99                                        return new UTF_32_Lexer(m, l);
100                                else if ((lgth == 5) && at_UCS_4(m->encoding))
101                                        return new UTF_32_Lexer(m, l);
102                                else EncodingError("32-bit", m->encoding, lgth);
103                        else if (order == BigEndian)
104                                if ((lgth == 8) && at_UTF_32BE(m->encoding))
105                                        return new UTF_32_Lexer(m, l);
106                                else if ((lgth == 7) && at_UCS_4BE(m->encoding))
107                                        return new UTF_32_Lexer(m, l);
108                                else EncodingError("32BE", m->encoding, lgth);
109                        else if (order == LittleEndian)
110                                if ((lgth == 8) && at_UTF_32LE(m->encoding))
111                                        return new UTF_32_Lexer(m, l);
112                                else if ((lgth == 7) && at_UCS_4LE(m->encoding))
113                                        return new UTF_32_Lexer(m, l);
114                                else EncodingError("32LE", m->encoding, lgth);
115                        else EncodingError("32-bit", m->encoding, lgth);
116                }
117        }
118}
119
120template <>
121Lexer_Interface * Lexer<EBCDIC>::LexerFactory(Model_Info * m, LexicalStreamSet *l) {
122        if (!(m->has_encoding_decl)) {
123                // Must be UTF-8 or UTF-16; UTF-16 requires a ByteOrderMark.
124                NoEncodingError("EBCDIC-family inferred, but no encoding declaration present.\n");
125        }
126        else {
127                int lgth = strlen((const char *) m->encoding);
128                /* Really need a table-based lookup here */
129                if ((lgth == 6) && at_EBCDIC(m->encoding))
130                        return new EBCDIC_Lexer(m, l);
131                else EncodingError("EBCDIC family", m->encoding, lgth);
132        }
133}
134
135template <CodeUnit_Base C>
136Lexer<C>::Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer_Interface::Lexer_Interface(m, l) {
137}
138
139UTF_8_Lexer::UTF_8_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(m, l) {
140}
141
142ASCII_7_Lexer::ASCII_7_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(m, l) {
143}
144
145EASCII_8_Lexer::EASCII_8_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(m, l) {
146}
147
148U16_Lexer::U16_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(m, l) {
149}
150
151UTF_16_Lexer::UTF_16_Lexer(Model_Info * m, LexicalStreamSet *l) : U16_Lexer::U16_Lexer(m, l) {
152}
153
154UCS_2_Lexer::UCS_2_Lexer(Model_Info * m, LexicalStreamSet *l) : U16_Lexer::U16_Lexer(m, l) {
155}
156
157UTF_32_Lexer::UTF_32_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(m, l) {
158}
159
160EBCDIC_Lexer::EBCDIC_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<EBCDIC>::Lexer(m, l) {
161}
162
163template <CodeUnit_Base C>
164static inline void WS_Control_Blocks(BitBlock bit[], BitBlock& WS, BitBlock& Control);
165
166template <>
167static inline void WS_Control_Blocks<ASCII>(BitBlock bit[], BitBlock& WS, BitBlock& Control) {
168        BitBlock temp1 = simd_or(bit[0], bit[1]);
169        BitBlock temp2 = simd_or(temp1, bit[2]);
170        Control = simd_andc(simd_const_1(1), temp2);
171        BitBlock temp3 = simd_or(bit[2], bit[3]);
172        BitBlock temp4 = simd_or(temp1, temp3);
173        BitBlock temp5 = simd_and(bit[4], bit[5]);
174        BitBlock temp6 = simd_andc(bit[7], bit[6]);
175        BitBlock temp7 = simd_and(temp5, temp6);
176        BitBlock CR = simd_andc(temp7, temp4);
177        BitBlock temp8 = simd_andc(bit[4], bit[5]);
178        BitBlock temp9 = simd_andc(bit[6], bit[7]);
179        BitBlock temp10 = simd_and(temp8, temp9);
180        BitBlock LF = simd_andc(temp10, temp4);
181        BitBlock temp11 = simd_and(temp8, temp6);
182        BitBlock HT = simd_andc(temp11, temp4);
183        BitBlock temp12 = simd_andc(bit[2], bit[3]);
184        BitBlock temp13 = simd_andc(temp12, temp1);
185        BitBlock temp14 = simd_or(bit[4], bit[5]);
186        BitBlock temp15 = simd_or(bit[6], bit[7]);
187        BitBlock temp16 = simd_or(temp14, temp15);
188        BitBlock SP = simd_andc(temp13, temp16);
189        WS = simd_or(simd_or(CR, LF), simd_or(HT, SP));
190}
191
192template <>
193static inline void WS_Control_Blocks<EBCDIC>(BitBlock bit[], BitBlock& WS, BitBlock& Control) {
194        BitBlock temp1 = simd_or(bit[0], bit[1]);
195        BitBlock temp2 = simd_or(bit[2], bit[3]);
196        BitBlock temp3 = simd_or(temp1, temp2);
197        BitBlock temp4 = simd_or(bit[4], bit[5]);
198        BitBlock temp5 = simd_or(temp3, temp4);
199        BitBlock temp6 = simd_and(bit[2], bit[3]);
200        BitBlock temp7 = simd_andc(temp6, temp1);
201        BitBlock temp8 = simd_andc(bit[5], bit[4]);
202        BitBlock temp9 = simd_and(bit[6], bit[7]);
203        BitBlock temp10 = simd_and(temp8, temp9);
204        BitBlock temp11 = simd_and(temp7, temp10);
205        BitBlock temp12 = simd_andc(temp5, temp11);
206        BitBlock temp13 = simd_andc(bit[2], bit[3]);
207        BitBlock temp14 = simd_andc(temp13, temp1);
208        BitBlock temp15 = simd_and(bit[4], bit[5]);
209        BitBlock temp16 = simd_and(temp14, temp15);
210        BitBlock temp17 = simd_andc(bit[6], bit[7]);
211        BitBlock temp18 = simd_andc(temp16, temp17);
212        BitBlock temp19 = simd_andc(temp12, temp18);
213        BitBlock temp20 = simd_andc(bit[3], bit[2]);
214        BitBlock temp21 = simd_andc(temp20, temp1);
215        BitBlock temp22 = simd_and(temp8, temp17);
216        BitBlock temp23 = simd_and(temp21, temp22);
217        BitBlock temp24 = simd_andc(temp19, temp23);
218        BitBlock temp25 = simd_or(temp1, bit[2]);
219        BitBlock temp26 = simd_or(bit[5], temp9);
220        BitBlock temp27 = simd_and(bit[4], temp26);
221        BitBlock temp28 = simd_andc(simd_const_1(1), temp4);
222        BitBlock temp29 = simd_if(bit[3], temp27, temp28);
223        BitBlock temp30 = simd_andc(temp29, temp25);
224        BitBlock temp31 = simd_andc(temp24, temp30);
225        BitBlock temp32 = simd_andc(temp15, bit[6]);
226        BitBlock temp33 = simd_and(temp7, temp32);
227        BitBlock temp34 = simd_andc(temp31, temp33);
228        BitBlock temp35 = simd_andc(temp17, temp4);
229        BitBlock temp36 = simd_and(temp7, temp35);
230        BitBlock temp37 = simd_andc(temp34, temp36);
231        BitBlock temp38 = simd_and(temp8, bit[6]);
232        BitBlock temp39 = simd_and(temp14, temp38);
233        BitBlock temp40 = simd_andc(temp37, temp39);
234        BitBlock temp41 = simd_andc(bit[4], bit[5]);
235        BitBlock temp42 = simd_andc(temp41, bit[6]);
236        BitBlock temp43 = simd_and(temp21, temp42);
237        BitBlock temp44 = simd_andc(temp40, temp43);
238        BitBlock temp45 = simd_and(temp15, temp9);
239        BitBlock temp46 = simd_and(temp7, temp45);
240        BitBlock temp47 = simd_andc(temp44, temp46);
241        BitBlock temp48 = simd_and(temp21, temp15);
242        BitBlock temp49 = simd_andc(temp47, temp48);
243        Control = simd_andc(simd_const_1(1), temp49);
244        BitBlock temp50 = simd_andc(bit[7], bit[6]);
245        BitBlock temp51 = simd_and(temp15, temp50);
246        BitBlock CR = simd_andc(temp51, temp3);
247        BitBlock temp52 = simd_and(temp8, temp50);
248        BitBlock LF = simd_and(temp14, temp52);
249        BitBlock HT = simd_andc(temp52, temp3);
250        BitBlock temp53 = simd_andc(bit[1], bit[0]);
251        BitBlock temp54 = simd_andc(temp53, temp2);
252        BitBlock temp55 = simd_or(bit[6], bit[7]);
253        BitBlock temp56 = simd_or(temp4, temp55);
254        BitBlock SP = simd_andc(temp54, temp56);
255        WS = simd_or(simd_or(CR, LF), simd_or(HT, SP));
256}
257
258
259
260template <CodeUnit_Base C>
261void Lexer<C>::Do_XML_10_WS_Control() {
262        BitBlock Control, WS;
263        for (int i = 0; i < buffer_blocks; i++) {
264                WS_Control_Blocks<C>(x8basis[i].bit, 
265                                     WS,
266                                     Control);
267                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
268                validation_stream[i] = simd_andc(Control, WS);
269        }
270};
271
272
273
274template <CodeUnit_Base C>
275static inline void ComputeLexicalItemBlocks(BitBlock bit[], BitBlock LexItem[]);
276
277/* Given the bit[] array of one BitBlock each for the 8 bits of
278   an ASCII-family character representation, compute the parallel
279   lexical item streams needed for XML parsing.
280
281   WARNING: the following is generated code by charset_compiler.py.
282   Do not edit.
283
284*/
285
286template <>
287static inline void ComputeLexicalItemBlocks<ASCII>(BitBlock bit[], BitBlock LexItem[]) {
288  BitBlock temp1 = simd_or(bit[0], bit[1]);
289  BitBlock temp2 = simd_and(bit[2], bit[3]);
290  BitBlock temp3 = simd_andc(temp2, temp1);
291  BitBlock temp4 = simd_and(bit[4], bit[5]);
292  BitBlock temp5 = simd_or(bit[6], bit[7]);
293  BitBlock temp6 = simd_andc(temp4, temp5);
294  BitBlock temp7 = simd_and(temp3, temp6);
295  BitBlock temp8 = simd_andc(bit[2], bit[3]);
296  BitBlock temp9 = simd_andc(temp8, temp1);
297  BitBlock temp10 = simd_andc(bit[5], bit[4]);
298  BitBlock temp11 = simd_andc(bit[6], bit[7]);
299  BitBlock temp12 = simd_and(temp10, temp11);
300  BitBlock temp13 = simd_and(temp9, temp12);
301  LexItem[MarkupStart] = simd_or(temp7, temp13);
302  BitBlock temp14 = simd_and(temp4, temp11);
303  BitBlock RAngle = simd_and(temp3, temp14);
304  BitBlock temp15 = simd_andc(bit[1], bit[0]);
305  BitBlock temp16 = simd_andc(bit[3], bit[2]);
306  BitBlock temp17 = simd_and(temp15, temp16);
307  BitBlock temp18 = simd_andc(bit[7], bit[6]);
308  BitBlock temp19 = simd_and(temp4, temp18);
309  BitBlock RBracket = simd_and(temp17, temp19);
310  LexItem[Hyphen] = simd_and(temp9, temp19);
311  BitBlock temp20 = simd_and(bit[6], bit[7]);
312  BitBlock temp21 = simd_and(temp4, temp20);
313  LexItem[QMark] = simd_and(temp3, temp21);
314  BitBlock temp22 = simd_or(bit[4], bit[5]);
315  BitBlock temp23 = simd_andc(temp11, temp22);
316  BitBlock temp24 = simd_and(temp10, temp20);
317  BitBlock temp25 = simd_or(temp23, temp24);
318  BitBlock temp26 = simd_and(temp9, temp25);
319  BitBlock temp27 = simd_or(temp26, temp7);
320  LexItem[Quote] = simd_or(temp27, temp13);
321  BitBlock temp28 = simd_and(bit[5], temp5);
322  BitBlock temp29 = simd_and(bit[4], temp28);
323  BitBlock temp30 = simd_andc(temp29, temp21);
324  BitBlock temp31 = simd_andc(temp9, temp30);
325  BitBlock temp32 = simd_and(temp3, bit[4]);
326  BitBlock temp33 = simd_or(bit[5], temp20);
327  BitBlock temp34 = simd_and(temp32, temp33);
328  BitBlock temp35 = simd_or(temp31, temp34);
329  BitBlock temp36 = simd_and(temp17, bit[4]);
330  BitBlock temp37 = simd_andc(simd_const_1(1), temp20);
331  BitBlock temp38 = simd_if(bit[5], temp37, temp20);
332  BitBlock temp39 = simd_and(temp36, temp38);
333  BitBlock temp40 = simd_or(temp35, temp39);
334  BitBlock temp41 = simd_and(temp15, temp2);
335  BitBlock temp42 = simd_and(temp41, bit[4]);
336  BitBlock temp43 = simd_and(temp42, temp38);
337  LexItem[NameFollow] = simd_or(temp40, temp43);
338#ifdef DIGIT_AND_HEX_ITEMS
339  BitBlock temp44 = simd_or(bit[5], bit[6]);
340  BitBlock temp45 = simd_and(bit[4], temp44);
341  BitBlock Digit = simd_andc(temp3, temp45);
342  BitBlock temp46 = simd_or(bit[2], bit[3]);
343  BitBlock temp47 = simd_andc(temp15, temp46);
344  BitBlock temp48 = simd_andc(temp47, bit[4]);
345  BitBlock temp49 = simd_if(bit[5], temp37, temp5);
346  BitBlock temp50 = simd_and(temp48, temp49);
347  BitBlock temp51 = simd_or(Digit, temp50);
348  BitBlock temp52 = simd_and(temp15, temp8);
349  BitBlock temp53 = simd_andc(temp52, bit[4]);
350  BitBlock temp54 = simd_and(temp53, temp49);
351  BitBlock Hex = simd_or(temp51, temp54);
352  LexItem[NonDigit] = simd_not(Digit);
353  LexItem[NonHex] = simd_not(Hex);
354#endif 
355        /* Mark potential occurrences of ']]>'  These are all actual
356        occurrences of ]]> as well as occurrences of ]] or ] at
357        the block end. Shifting the RBracket and RAngle streams in
358        negated forms ensures that a potential CD_End is not ruled
359        out at the block boundary. */
360        LexItem[CD_End_check] = simd_andc(RBracket, 
361                                          simd_or(sisd_sbli(simd_not(RBracket), 1),
362                                                  sisd_sbli(simd_not(RAngle), 2)));
363#ifndef OMIT_CD_End_check_In_Markup_Scan
364        LexItem[MarkupStart] = simd_or(LexItem[MarkupStart], LexItem[CD_End_check]);
365#endif
366}
367
368template <>
369static inline void ComputeLexicalItemBlocks<EBCDIC>(BitBlock bit[], BitBlock LexItem[]) {
370          BitBlock temp1 = simd_andc(bit[1], bit[0]);
371  BitBlock temp2 = simd_or(bit[2], bit[3]);
372  BitBlock temp3 = simd_andc(temp1, temp2);
373  BitBlock temp4 = simd_and(bit[4], bit[5]);
374  BitBlock temp5 = simd_or(bit[6], bit[7]);
375  BitBlock temp6 = simd_andc(temp4, temp5);
376  BitBlock temp7 = simd_and(temp3, temp6);
377  BitBlock temp8 = simd_andc(bit[3], bit[2]);
378  BitBlock temp9 = simd_and(temp1, temp8);
379  BitBlock temp10 = simd_or(bit[4], bit[5]);
380  BitBlock temp11 = simd_or(temp10, temp5);
381  BitBlock temp12 = simd_andc(temp9, temp11);
382  LexItem[MarkupStart] = simd_or(temp7, temp12);
383  BitBlock temp13 = simd_andc(bit[2], bit[3]);
384  BitBlock temp14 = simd_and(temp1, temp13);
385  BitBlock temp15 = simd_andc(bit[6], bit[7]);
386  BitBlock temp16 = simd_and(temp4, temp15);
387  BitBlock RAngle = simd_and(temp14, temp16);
388  BitBlock temp17 = simd_andc(bit[0], bit[1]);
389  BitBlock temp18 = simd_and(bit[2], bit[3]);
390  BitBlock temp19 = simd_and(temp17, temp18);
391  BitBlock temp20 = simd_andc(bit[4], bit[5]);
392  BitBlock temp21 = simd_and(bit[6], bit[7]);
393  BitBlock temp22 = simd_and(temp20, temp21);
394  BitBlock RBracket = simd_and(temp19, temp22);
395  LexItem[Hyphen] = simd_andc(temp14, temp11);
396  BitBlock temp23 = simd_and(temp4, temp21);
397  BitBlock QMark = simd_and(temp14, temp23);
398  BitBlock temp24 = simd_and(temp1, temp18);
399  BitBlock temp25 = simd_and(temp4, bit[7]);
400  BitBlock temp26 = simd_and(temp24, temp25);
401  BitBlock temp27 = simd_or(temp26, temp7);
402  LexItem[Quote] = simd_or(temp27, temp12);
403  BitBlock temp28 = simd_andc(temp3, temp11);
404  BitBlock temp29 = simd_and(temp20, temp15);
405  BitBlock temp30 = simd_and(temp9, temp29);
406  BitBlock temp31 = simd_or(temp28, temp30);
407  BitBlock temp32 = simd_and(temp24, temp23);
408  BitBlock temp33 = simd_or(temp31, temp32);
409  BitBlock temp34 = simd_and(temp24, temp22);
410  BitBlock temp35 = simd_or(temp33, temp34);
411  BitBlock temp36 = simd_and(temp9, temp22);
412  BitBlock temp37 = simd_or(temp35, temp36);
413  BitBlock temp38 = simd_and(temp14, temp6);
414  BitBlock temp39 = simd_or(temp37, temp38);
415  BitBlock temp40 = simd_or(temp39, temp12);
416  BitBlock temp41 = simd_andc(bit[7], bit[6]);
417  BitBlock temp42 = simd_and(temp4, temp41);
418  BitBlock temp43 = simd_and(temp24, temp42);
419  BitBlock temp44 = simd_or(temp40, temp43);
420  BitBlock temp45 = simd_and(temp3, temp42);
421  BitBlock temp46 = simd_or(temp44, temp45);
422  BitBlock temp47 = simd_and(temp9, temp42);
423  BitBlock temp48 = simd_or(temp46, temp47);
424  BitBlock temp49 = simd_and(temp9, temp6);
425  BitBlock temp50 = simd_or(temp48, temp49);
426  BitBlock temp51 = simd_and(temp3, temp16);
427  BitBlock temp52 = simd_or(temp50, temp51);
428  BitBlock temp53 = simd_and(temp14, temp22);
429  BitBlock temp54 = simd_or(temp52, temp53);
430  BitBlock temp55 = simd_andc(temp41, temp10);
431  BitBlock temp56 = simd_and(temp14, temp55);
432  BitBlock temp57 = simd_or(temp54, temp56);
433  BitBlock temp58 = simd_and(temp9, temp16);
434  BitBlock temp59 = simd_or(temp57, temp58);
435  BitBlock temp60 = simd_or(temp59, temp7);
436  BitBlock temp61 = simd_and(temp24, temp16);
437  BitBlock temp62 = simd_or(temp60, temp61);
438  BitBlock temp63 = simd_or(temp62, RAngle);
439  BitBlock temp64 = simd_or(temp63, QMark);
440  BitBlock temp65 = simd_and(temp19, temp29);
441  BitBlock temp66 = simd_or(temp64, temp65);
442  BitBlock temp67 = simd_and(bit[0], bit[1]);
443  BitBlock temp68 = simd_and(temp67, temp13);
444  BitBlock temp69 = simd_andc(temp68, temp11);
445  BitBlock temp70 = simd_or(temp66, temp69);
446  BitBlock temp71 = simd_or(temp70, RBracket);
447  BitBlock temp72 = simd_andc(temp19, temp11);
448  BitBlock temp73 = simd_or(temp71, temp72);
449  BitBlock temp74 = simd_andc(temp67, temp2);
450  BitBlock temp75 = simd_andc(temp74, temp11);
451  BitBlock temp76 = simd_or(temp73, temp75);
452  BitBlock temp77 = simd_and(temp3, temp23);
453  BitBlock temp78 = simd_or(temp76, temp77);
454  BitBlock temp79 = simd_and(temp67, temp8);
455  BitBlock temp80 = simd_andc(temp79, temp11);
456  BitBlock temp81 = simd_or(temp78, temp80);
457  BitBlock temp82 = simd_and(temp17, temp13);
458  BitBlock temp83 = simd_and(temp82, temp55);
459  LexItem[NameFollow] = simd_or(temp81, temp83);
460#ifdef DIGIT_AND_HEX_ITEMS
461  BitBlock temp84 = simd_and(temp67, temp18);
462  BitBlock temp85 = simd_andc(temp11, temp55);
463  BitBlock temp86 = simd_andc(temp15, temp10);
464  BitBlock temp87 = simd_andc(temp85, temp86);
465  BitBlock temp88 = simd_andc(temp21, temp10);
466  BitBlock temp89 = simd_andc(temp87, temp88);
467  BitBlock temp90 = simd_andc(bit[5], bit[4]);
468  BitBlock temp91 = simd_andc(temp90, temp5);
469  BitBlock temp92 = simd_andc(temp89, temp91);
470  BitBlock temp93 = simd_and(temp90, temp41);
471  BitBlock temp94 = simd_andc(temp92, temp93);
472  BitBlock temp95 = simd_and(temp90, temp15);
473  BitBlock temp96 = simd_andc(temp94, temp95);
474  BitBlock temp97 = simd_and(temp90, temp21);
475  BitBlock temp98 = simd_andc(temp96, temp97);
476  BitBlock temp99 = simd_andc(temp20, temp5);
477  BitBlock temp100 = simd_andc(temp98, temp99);
478  BitBlock temp101 = simd_and(temp20, temp41);
479  BitBlock temp102 = simd_andc(temp100, temp101);
480  BitBlock Digit = simd_andc(temp84, temp102);
481  BitBlock temp103 = simd_and(temp74, temp55);
482  BitBlock temp104 = simd_or(Digit, temp103);
483  BitBlock temp105 = simd_and(temp74, temp86);
484  BitBlock temp106 = simd_or(temp104, temp105);
485  BitBlock temp107 = simd_and(temp74, temp88);
486  BitBlock temp108 = simd_or(temp106, temp107);
487  BitBlock temp109 = simd_and(temp74, temp91);
488  BitBlock temp110 = simd_or(temp108, temp109);
489  BitBlock temp111 = simd_and(temp74, temp93);
490  BitBlock temp112 = simd_or(temp110, temp111);
491  BitBlock temp113 = simd_and(temp74, temp95);
492  BitBlock temp114 = simd_or(temp112, temp113);
493  BitBlock temp115 = simd_andc(temp17, temp2);
494  BitBlock temp116 = simd_and(temp115, temp55);
495  BitBlock temp117 = simd_or(temp114, temp116);
496  BitBlock temp118 = simd_and(temp115, temp86);
497  BitBlock temp119 = simd_or(temp117, temp118);
498  BitBlock temp120 = simd_and(temp115, temp88);
499  BitBlock temp121 = simd_or(temp119, temp120);
500  BitBlock temp122 = simd_and(temp115, temp91);
501  BitBlock temp123 = simd_or(temp121, temp122);
502  BitBlock temp124 = simd_and(temp115, temp93);
503  BitBlock temp125 = simd_or(temp123, temp124);
504  BitBlock temp126 = simd_and(temp115, temp95);
505  BitBlock Hex = simd_or(temp125, temp126);
506       
507  LexItem[NonDigit] = simd_not(Digit);
508  LexItem[NonHex] = simd_not(Hex);
509
510#endif 
511       
512        /* Mark potential occurrences of ']]>'  These are all actual
513        occurrences of ]]> as well as occurrences of ]] or ] at
514        the block end. Shifting the RBracket and RAngle streams in
515        negated forms ensures that a potential CD_End is not ruled
516        out at the block boundary. */
517        LexItem[CD_End_check] = simd_andc(RBracket, 
518                                          simd_or(sisd_sbli(simd_not(RBracket), 1),
519                                                  sisd_sbli(simd_not(RAngle), 2)));
520#ifndef OMIT_CD_End_check_In_Markup_Scan
521        LexItem[MarkupStart] = simd_or(LexItem[MarkupStart], LexItem[CD_End_check]);
522#endif
523}
524
525
526/* A temporary structure for internal use in ComputeLexicalItemStreams. */
527typedef struct {
528        BitBlock LexicalItems[LexicalItemCount];
529} LexicalItemBlock;
530
531
532
533
534template <CodeUnit_Base C>
535void Lexer<C>::Do_MarkupStreams() {
536        LexicalItemBlock lx_blk[BUFFER_BLOCKS];
537        for (int i = 0; i < buffer_blocks; i++) {
538                ComputeLexicalItemBlocks<C>(x8basis[i].bit, lx_blk[i].LexicalItems);
539        }
540        /* NonWS stream already completed by WS_Control method. */
541        for (int j = MarkupStart; j < LexicalItemCount; j++) {
542                for (int i = 0; i < buffer_blocks; i++) {
543                        parsing_engine_data->item_stream[j][i] = lx_blk[i].LexicalItems[j];
544                }
545        }
546        for (int i = 0; i < buffer_blocks; i++) {
547                parsing_engine_data->item_stream[NameFollow][i] = 
548                        simd_or(parsing_engine_data->item_stream[NameFollow][i],
549                                simd_not(parsing_engine_data->item_stream[NonWS][i]));
550        }
551};
552
553
554/* Stub out Charset Validation initially. */
555
556void UTF_8_Lexer::Do_CharsetValidation() {
557        //printf("UTF_8_Lexer::Do_CharsetValidation not yet implemented; assuming OK.\n");
558        for (int i = 0; i < buffer_blocks; i++) {
559                validation_stream[i] = simd_const_1(0);
560        }
561};
562
563
564void ASCII_7_Lexer::Do_CharsetValidation() {
565        for (int blk = 0; blk < buffer_blocks; blk++) {
566                validation_stream[blk] = x8basis[blk].bit[0];
567        }
568};
569
570
571void EASCII_8_Lexer::Do_CharsetValidation() {
572        /* Nothing required for most charsets - but perhaps should have tables. */
573        for (int i = 0; i < buffer_blocks; i++) {
574                validation_stream[i] = simd_const_1(0);
575        }
576};
577
578
579void UTF_16_Lexer::Do_CharsetValidation() {
580#ifdef X16HILO_ACCESS
581        int packs = (buffer_units - 1)/PACKSIZE + 1;
582        BytePack surrogate_select;
583        BytePack hi_surrogate;
584        BytePack lo_surrogate;
585        BytePack hi_surrogate_pending = simd_const_8(0);
586        BytePack surrogate_scope;
587        BytePack u16_surrogate_accum = simd_const_8(0);
588        BytePack u16_FFFE_FFFF_accum = simd_const_8(0);
589        BytePack u16_FFFE_FFFF;
590        for (int pk = 0; pk < packs; pk++) {
591                /* UTF-16 code units in the range D800-DBFF and DC00-DFFF are
592                   reserved for the first and second elements, respectively
593                   of surrogate pairs.  Validation requires that these values
594                   only occur in well-formed pairs. */
595                surrogate_select = simd_and(x16hi[pk], simd_const_8(0xDC));
596                hi_surrogate = simd_eq_8(surrogate_select, simd_const_8(0xD8));
597                lo_surrogate = simd_eq_8(surrogate_select, simd_const_8(0xDC));
598                surrogate_scope = simd_or(hi_surrogate_pending,
599                                          sisd_sfli(hi_surrogate, 8));
600                u16_surrogate_accum = simd_or(u16_surrogate_accum,
601                                              simd_xor(surrogate_scope, lo_surrogate));
602                hi_surrogate_pending = sisd_sbli(hi_surrogate, 8 * (PACKSIZE-1));
603                /* The values FFFE and FFFF are excluded. */
604                u16_FFFE_FFFF = simd_eq_8(simd_and(x16hi[pk],
605                                                   simd_or(x16lo[pk], simd_const_8(1))),
606                                          simd_const_8(0xFF));
607                u16_FFFE_FFFF_accum = simd_or(u16_FFFE_FFFF_accum, u16_FFFE_FFFF);
608        }
609        u16_surrogate_accum = simd_or(u16_surrogate_accum, hi_surrogate_pending);
610        if (bitblock_has_bit(simd_or(u16_surrogate_accum, u16_FFFE_FFFF_accum)))
611                printf("UTF-16 validation error.\n");
612                exit(-1);
613        }
614#endif
615#ifndef X16HILO_ACCESS
616        printf("UTF_16_Lexer::Do_CharsetValidation not yet complete; assuming OK.\n");
617#endif
618};
619
620
621void UCS_2_Lexer::Do_CharsetValidation() {
622#ifdef X16HILO_ACCESS
623        int packs = (buffer_units - 1)/PACKSIZE + 1;
624        BytePack u16_surrogate_accum = simd_const_8(0);
625        BytePack u16_FFFE_FFFF_accum = simd_const_8(0);
626        BytePack u16_FFFE_FFFF;
627        for (int pk = 0; pk < packs; pk++) {
628                /* The high byte of UCS-2 code units cannot be in the range D8-DF.
629                   This corresponds to the D800-DFFF range of illegal codepoints
630                   reserved for UTF-16 surrogate pairs. Accumulate the results.
631                   To check, 0x20 is added to each such octet, mapping the D8-DF
632                   range to F8-FF and wrapping E0-FF values around.  The max value
633                   is then accumulated.  */
634                u16_surrogate_accum =
635                        simd_max_8(u16_surrogate_accum, 
636                                   simd_add_8(x16hi[pk], simd_const_8(0x20)));
637                /* The values FFFE and FFFF are excluded. */
638                u16_FFFE_FFFF = simd_eq_8(simd_and(x16hi[pk],
639                                                   simd_or(x16lo[pk], simd_const_8(1))),
640                                          simd_const_8(0xFF));
641                u16_FFFE_FFFF_accum = simd_or(u16_FFFE_FFFF_accum, u16_FFFE_FFFF);
642        }
643        u16_surrogate_accum = simd_eq_8(simd_or(u16_surrogate_accum, simd_const_8(0x07)),
644                                        simd_const_8(0xFF));
645        if (bitblock_has_bit(simd_or(u16_surrogate_accum, u16_FFFE_FFFF_accum)))
646                printf("UCS-2 validation error.\n");
647                exit(-1);
648        }
649#endif
650#ifndef X16HILO_ACCESS
651        printf("UCS_2_Lexer::Do_CharsetValidation not yet complete; assuming OK.\n");
652#endif
653};
654
655
656void UTF_32_Lexer::Do_CharsetValidation() {
657#ifdef X32BYTEPLEX_ACCESS
658        int packs = (buffer_units - 1)/PACKSIZE + 1;
659        BytePack u32hh_accum = simd_const_8(0);
660        BytePack u32hl_accum = simd_const_8(0);
661        BytePack u32_surrogate_accum = simd_const_8(0);
662        BytePack u32_FFFE_FFFF_accum = simd_const_8(0);
663        BytePack u32_BMP_select;
664        BytePack u32l_FFFE_FFFF;
665        for (int pk = 0; pk < packs; pk++) {
666                /* There can be no bits set in the high octet; "or" together
667                   all octet values to check for any bit set. */
668                u32hh_accum = simd_or(u32hh_accum, x32hh[pk]);
669                /* The second octet has a max value of 0x10, corresponding to the
670                   maximum Unicode code point value of 0x10FFFF.  Accumulate the
671                   maximum of all u32hl values observed. */ 
672                u32hl_accum = simd_max_8(u32hl_accum, x32hl[pk]);
673                /* The third octet cannot be in the range D8-DF if the second octet
674                   is 0.  This corresponds to the D800-DFFF range of illegal codepoints
675                   reserved for UTF-16 surrogate pairs. Accumulate the results.
676                   To check, 0x20 is added to each such octet, mapping the D8-DF
677                   range to F8-FF and wrapping E0-FF values around.  The max value
678                   is then accumulated.  */
679                u32_BMP_select = simd_eq_8(x32hl[pk], simd_const_8(0));
680                u32_surrogate_accum = 
681                        simd_max_8(u32_surrogate_accum, 
682                                   simd_and(u32_BMP_select,
683                                            simd_add_8(x32lh[pk], simd_const_8(0x20))));
684                /* The low two octets cannot have the value FFFE or FFFF if
685                   we're in the BMP (second octet is 0). */
686                u32l_FFFE_FFFF = simd_eq_8(simd_and(x32lh[pk],
687                                                    simd_or(x32ll[pk], simd_const_8(1))),
688                                           simd_const_8(0xFF));
689                u32_FFFE_FFFF_accum = simd_or(u32_FFFE_FFFF_accum,
690                                              simd_and(u32_BMP_select, u32l_FFFE_FFFF));
691        }
692        u32hl_accum = simd_gt_8(u32hl_accum, simd_const_8(0x10));
693        u32_surrogate_accum = simd_eq_8(simd_or(u32_surrogate_accum, simd_const_8(0x07)),
694                                        simd_const_8(0xFF));
695        if (bitblock_has_bit(simd_or(simd_or(u32hh_accum, u32hl_accum),
696                                         simd_or(u32_surrogate_accum, u32_FFFE_FFFF_accum)))) {
697                printf("UTF-32 validation error.\n");
698                exit(-1);
699        }
700#endif
701#ifndef X32BYTEPLEX_ACCESS
702        printf("UTF_32_Lexer::Do_CharsetValidation not yet complete; assuming OK.\n");
703#endif
704};
705
706
707void EBCDIC_Lexer::Do_CharsetValidation() {
708        /* Nothing required for most cases - but perhaps should have tables. */
709        for (int i = 0; i < buffer_blocks; i++) {
710                validation_stream[i] = simd_const_1(0);
711        }
712}
713
714
715
716/* Stub out XML 1.1 routines initially. */
717
718void UTF_8_Lexer::Do_XML_11_WS_Control() {
719        printf("UTF_8_Lexer::Do_XML_11_WS_Control not yet implemented; using XML 1.0 rules.\n");
720        Do_XML_10_WS_Control();
721};
722
723
724static inline void ASCII_7_WS_Control_Blocks_11(BitBlock bit[], BitBlock& WS, BitBlock& Control) {
725        BitBlock temp1 = simd_or(bit[0], bit[1]);
726        BitBlock temp2 = simd_or(temp1, bit[2]);
727        BitBlock temp3 = simd_andc(bit[1], bit[0]);
728        BitBlock temp4 = simd_and(bit[2], bit[3]);
729        BitBlock temp5 = simd_and(temp3, temp4);
730        BitBlock temp6 = simd_and(bit[4], bit[5]);
731        BitBlock temp7 = simd_and(bit[6], bit[7]);
732        BitBlock temp8 = simd_and(temp6, temp7);
733        BitBlock temp9 = simd_and(temp5, temp8);
734        BitBlock temp10 = simd_andc(temp2, temp9);
735        BitBlock temp11 = simd_andc(temp10, bit[0]);
736        Control = simd_andc(simd_const_1(1), temp11);
737        BitBlock temp12 = simd_or(bit[2], bit[3]);
738        BitBlock temp13 = simd_or(temp1, temp12);
739        BitBlock temp14 = simd_andc(bit[7], bit[6]);
740        BitBlock temp15 = simd_and(temp6, temp14);
741        BitBlock CR = simd_andc(temp15, temp13);
742        BitBlock temp16 = simd_andc(bit[4], bit[5]);
743        BitBlock temp17 = simd_andc(bit[6], bit[7]);
744        BitBlock temp18 = simd_and(temp16, temp17);
745        BitBlock LF = simd_andc(temp18, temp13);
746        BitBlock temp19 = simd_and(temp16, temp14);
747        BitBlock HT = simd_andc(temp19, temp13);
748        BitBlock temp20 = simd_andc(bit[2], bit[3]);
749        BitBlock temp21 = simd_andc(temp20, temp1);
750        BitBlock temp22 = simd_or(bit[4], bit[5]);
751        BitBlock temp23 = simd_or(bit[6], bit[7]);
752        BitBlock temp24 = simd_or(temp22, temp23);
753        BitBlock SP = simd_andc(temp21, temp24);
754        WS = simd_or(simd_or(CR, LF), simd_or(HT, SP));
755}
756
757
758void ASCII_7_Lexer::Do_XML_11_WS_Control() {
759        BitBlock WS, Control;
760        for (int i = 0; i < buffer_blocks; i++) {
761                ASCII_7_WS_Control_Blocks_11(x8basis[i].bit, WS, Control);
762                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
763                validation_stream[i] = simd_andc(Control, WS);
764        }
765};
766
767static inline void EASCII_8_WS_Control_Blocks_11(BitBlock bit[], BitBlock& WS, BitBlock& Control) {
768        BitBlock temp1 = simd_or(bit[0], bit[1]);
769        BitBlock temp2 = simd_or(temp1, bit[2]);
770        BitBlock temp3 = simd_andc(bit[1], bit[0]);
771        BitBlock temp4 = simd_and(bit[2], bit[3]);
772        BitBlock temp5 = simd_and(temp3, temp4);
773        BitBlock temp6 = simd_and(bit[4], bit[5]);
774        BitBlock temp7 = simd_and(bit[6], bit[7]);
775        BitBlock temp8 = simd_and(temp6, temp7);
776        BitBlock temp9 = simd_and(temp5, temp8);
777        BitBlock temp10 = simd_andc(temp2, temp9);
778        BitBlock temp11 = simd_andc(bit[0], bit[1]);
779        BitBlock temp12 = simd_andc(temp11, bit[2]);
780        BitBlock temp13 = simd_andc(temp10, temp12);
781        Control = simd_andc(simd_const_1(1), temp13);
782        BitBlock temp14 = simd_or(bit[2], bit[3]);
783        BitBlock temp15 = simd_or(temp1, temp14);
784        BitBlock temp16 = simd_andc(bit[7], bit[6]);
785        BitBlock temp17 = simd_and(temp6, temp16);
786        BitBlock CR = simd_andc(temp17, temp15);
787        BitBlock temp18 = simd_andc(bit[4], bit[5]);
788        BitBlock temp19 = simd_andc(bit[6], bit[7]);
789        BitBlock temp20 = simd_and(temp18, temp19);
790        BitBlock LF = simd_andc(temp20, temp15);
791        BitBlock temp21 = simd_and(temp18, temp16);
792        BitBlock HT = simd_andc(temp21, temp15);
793        BitBlock temp22 = simd_andc(bit[2], bit[3]);
794        BitBlock temp23 = simd_andc(temp22, temp1);
795        BitBlock temp24 = simd_or(bit[4], bit[5]);
796        BitBlock temp25 = simd_or(bit[6], bit[7]);
797        BitBlock temp26 = simd_or(temp24, temp25);
798        BitBlock SP = simd_andc(temp23, temp26);
799        BitBlock temp27 = simd_andc(temp11, temp14);
800        BitBlock temp28 = simd_andc(bit[5], bit[4]);
801        BitBlock temp29 = simd_and(temp28, temp16);
802        BitBlock NEL = simd_and(temp27, temp29);
803        WS = simd_or(simd_or(simd_or(CR, LF), simd_or(HT, SP)), NEL);
804}
805
806void EASCII_8_Lexer::Do_XML_11_WS_Control() {
807        BitBlock WS, Control;
808        for (int i = 0; i < buffer_blocks; i++) {
809                EASCII_8_WS_Control_Blocks_11(x8basis[i].bit, WS, Control);
810                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
811                validation_stream[i] = simd_andc(Control, WS);
812        }
813};
814
815
816void U16_Lexer::Do_XML_11_WS_Control() {
817        printf("U16_Lexer::Do_XML_11_WS_Control not yet implemented; using XML 1.0 rules.\n");
818        Do_XML_10_WS_Control();
819};
820
821
822void UTF_32_Lexer::Do_XML_11_WS_Control() {
823        printf("UTF_32_Lexer::Do_XML_11_WS_Control not yet implemented; using XML 1.0 rules.\n");
824        Do_XML_10_WS_Control();
825};
826
827static inline void EBCDIC_WS_Control_Blocks_11(BitBlock bit[], BitBlock& WS, BitBlock& Control) {
828        BitBlock temp1 = simd_or(bit[0], bit[1]);
829        BitBlock temp2 = simd_and(bit[0], bit[1]);
830        BitBlock temp3 = simd_and(bit[2], bit[3]);
831        BitBlock temp4 = simd_and(temp2, temp3);
832        BitBlock temp5 = simd_and(bit[4], bit[5]);
833        BitBlock temp6 = simd_and(bit[6], bit[7]);
834        BitBlock temp7 = simd_and(temp5, temp6);
835        BitBlock temp8 = simd_and(temp4, temp7);
836        BitBlock temp9 = simd_andc(temp1, temp8);
837        Control = simd_andc(simd_const_1(1), temp9);
838        BitBlock temp10 = simd_or(bit[2], bit[3]);
839        BitBlock temp11 = simd_or(temp1, temp10);
840        BitBlock temp12 = simd_andc(bit[7], bit[6]);
841        BitBlock temp13 = simd_and(temp5, temp12);
842        BitBlock CR = simd_andc(temp13, temp11);
843        BitBlock temp14 = simd_andc(bit[2], bit[3]);
844        BitBlock temp15 = simd_andc(temp14, temp1);
845        BitBlock temp16 = simd_andc(bit[5], bit[4]);
846        BitBlock temp17 = simd_and(temp16, temp12);
847        BitBlock LF = simd_and(temp15, temp17);
848        BitBlock HT = simd_andc(temp17, temp11);
849        BitBlock temp18 = simd_andc(bit[1], bit[0]);
850        BitBlock temp19 = simd_andc(temp18, temp10);
851        BitBlock temp20 = simd_or(bit[4], bit[5]);
852        BitBlock temp21 = simd_or(bit[6], bit[7]);
853        BitBlock temp22 = simd_or(temp20, temp21);
854        BitBlock SP = simd_andc(temp19, temp22);
855        BitBlock temp23 = simd_andc(bit[3], bit[2]);
856        BitBlock temp24 = simd_andc(temp23, temp1);
857        BitBlock NEL = simd_and(temp24, temp17);
858        WS = simd_or(simd_or(simd_or(CR, LF), simd_or(HT, SP)), NEL);
859}
860
861void EBCDIC_Lexer::Do_XML_11_WS_Control() {
862        BitBlock WS, Control;
863        for (int i = 0; i < buffer_blocks; i++) {
864                EBCDIC_WS_Control_Blocks_11(x8basis[i].bit, WS, Control);
865                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
866                validation_stream[i] = simd_andc(Control, WS);
867        }
868};
869
870
871
872void Lexer_Interface::AnalyzeBuffer(BitBlockBasis * basis, int buffer_limit_pos) {
873#ifdef DEBUG
874        printf("Entered AnalyzeBuffer, buffer_limit_pos = %i\n", buffer_limit_pos);
875#endif
876        x8basis = basis;
877        int err_pos;
878#ifdef CODE_CLOCKING
879        start_Interval(WS_Control_clocker);
880#endif
881        buffer_blocks = (buffer_limit_pos + BLOCKSIZE - 1)/BLOCKSIZE;
882        buffer_units = buffer_limit_pos;
883
884        if (model_info->version == XML_1_1) Do_XML_11_WS_Control();
885        else Do_XML_10_WS_Control();
886        err_pos = bitstream_scan0(validation_stream);
887        if (err_pos < buffer_units) {
888                printf("Illegal control character in XML input stream at position %i\n",
889                        lexer_base_pos + err_pos);
890                exit(-1);
891        }
892#ifdef CODE_CLOCKING
893        end_Interval(WS_Control_clocker, BUFFER_SIZE);
894#endif
895#ifdef CODE_CLOCKING
896        start_Interval(MarkupStreams_clocker);
897#endif
898        Do_MarkupStreams();
899#ifdef CODE_CLOCKING
900        end_Interval(MarkupStreams_clocker, BUFFER_SIZE);
901#endif
902#ifdef CODE_CLOCKING
903        start_Interval(char_validation_clocker);
904#endif
905        Do_CharsetValidation();
906        err_pos = bitstream_scan0(validation_stream);
907        if (err_pos < buffer_units) {
908                printf("Invalid %s character in input stream at position %i\n",
909                        model_info->encoding,
910                        lexer_base_pos + err_pos);
911                exit(-1);
912        }
913#ifdef CODE_CLOCKING
914        end_Interval(char_validation_clocker, buffer_blocks * BLOCKSIZE);
915#endif
916        if (buffer_units < BUFFER_SIZE) {
917                BitBlock final_block_mask = 
918                        sisd_sfl(simd_const_1(1), sisd_from_int(buffer_units % BLOCKSIZE));
919                int lastblk = buffer_units/BLOCKSIZE;
920                for (int j = minLexicalItem; j < LexicalItemCount; j++) {
921                        parsing_engine_data->item_stream[j][lastblk] =
922                                simd_or(parsing_engine_data->item_stream[j][lastblk],
923                                        final_block_mask);
924                }
925        }
926
927}
928
Note: See TracBrowser for help on using the repository browser.