source: trunk/src/bitlex.c @ 100

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

Parsers for internal and external entities.

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