source: trunk/src/bitlex.c @ 111

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

Consolidation of error handling: xml_error.c

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