source: trunk/src/bitlex.c @ 63

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

Bug fix - buffer_blocks

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