source: trunk/src/bitlex.c @ 59

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

DIGIT_AND_HEX_ITEMS option; ilax.h superceded in engine.h

File size: 34.0 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}
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 Restricted = simd_const_1(0);
252        BitBlock Control = simd_const_1(0);
253        BitBlock WS = simd_const_1(0);
254        BitBlock final_block_mask;
255        for (int i = 0; i < buffer_blocks; i++) {
256                Restricted = simd_or(Restricted, simd_andc(Control, WS));
257                WS_Control_Blocks<C>(x8basis[i].bit, 
258                                     WS,
259                                     Control);
260                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
261        }
262        if ((buffer_units % BLOCKSIZE) != 0) {
263                final_block_mask = sisd_sfl(simd_const_1(1),
264                                            sisd_from_int(buffer_units % BLOCKSIZE));
265                Control = simd_andc(Control, final_block_mask);
266        }
267        Restricted = simd_or(Restricted, simd_andc(Control, WS));
268        if (bitblock_has_bit(Restricted)) {
269                printf("Restricted control character in input.\n");
270                exit(-1);
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_andc(bit[4], bit[5]);
323        BitBlock temp29 = simd_and(temp28, temp20);
324        BitBlock temp30 = simd_or(temp29, temp19);
325        BitBlock temp31 = simd_and(temp3, temp30);
326        BitBlock temp32 = simd_and(temp9, temp21);
327        BitBlock temp33 = simd_or(temp31, temp32);
328        BitBlock temp34 = simd_or(temp33, RAngle);
329        LexItem[NameFollow] = simd_or(temp34, LexItem[QMark]);
330#ifdef DIGIT_AND_HEX_ITEMS
331        BitBlock temp35 = simd_or(bit[5], bit[6]);
332        BitBlock temp36 = simd_andc(temp35, bit[4]);
333        BitBlock Digit = simd_andc(temp3, temp36);
334        BitBlock temp37 = simd_or(bit[2], bit[3]);
335        BitBlock temp38 = simd_andc(temp15, temp37);
336        BitBlock temp39 = simd_andc(temp38, bit[4]);
337        BitBlock temp40 = simd_andc(simd_const_1(1), temp20);
338        BitBlock temp41 = simd_if(bit[5], temp5, temp40);
339        BitBlock temp42 = simd_and(temp39, temp41);
340        BitBlock temp43 = simd_or(Digit, temp42);
341        BitBlock temp44 = simd_and(temp15, temp8);
342        BitBlock temp45 = simd_andc(temp44, bit[4]);
343        BitBlock temp46 = simd_and(temp45, temp41);
344        BitBlock Hex = simd_or(temp43, temp46);
345        LexItem[NonDigit] = simd_not(Digit);
346        LexItem[NonHex] = simd_not(Hex);
347#endif 
348        /* Mark potential occurrences of ']]>'  These are all actual
349        occurrences of ]]> as well as occurrences of ]] or ] at
350        the block end. Shifting the RBracket and RAngle streams in
351        negated forms ensures that a potential CD_End is not ruled
352        out at the block boundary. */
353        LexItem[CD_End_check] = simd_andc(RBracket, 
354                                          simd_or(sisd_sbli(simd_not(RBracket), 1),
355                                                  sisd_sbli(simd_not(RAngle), 2)));
356#ifndef OMIT_CD_End_check_In_Markup_Scan
357        LexItem[MarkupStart] = simd_or(LexItem[MarkupStart], LexItem[CD_End_check]);
358#endif
359}
360
361template <>
362static inline void ComputeLexicalItemBlocks<EBCDIC>(BitBlock bit[], BitBlock LexItem[]) {
363        BitBlock temp1 = simd_andc(bit[1], bit[0]);
364        BitBlock temp2 = simd_or(bit[2], bit[3]);
365        BitBlock temp3 = simd_andc(temp1, temp2);
366        BitBlock temp4 = simd_and(bit[4], bit[5]);
367        BitBlock temp5 = simd_or(bit[6], bit[7]);
368        BitBlock temp6 = simd_andc(temp4, temp5);
369        BitBlock temp7 = simd_and(temp3, temp6);
370        BitBlock temp8 = simd_andc(bit[3], bit[2]);
371        BitBlock temp9 = simd_and(temp1, temp8);
372        BitBlock temp10 = simd_or(bit[4], bit[5]);
373        BitBlock temp11 = simd_or(temp10, temp5);
374        BitBlock temp12 = simd_andc(temp9, temp11);
375        LexItem[MarkupStart] = simd_or(temp7, temp12);
376        BitBlock temp13 = simd_andc(bit[2], bit[3]);
377        BitBlock temp14 = simd_and(temp1, temp13);
378        BitBlock temp15 = simd_andc(bit[6], bit[7]);
379        BitBlock temp16 = simd_and(temp4, temp15);
380        BitBlock RAngle = simd_and(temp14, temp16);
381        BitBlock temp17 = simd_andc(bit[0], bit[1]);
382        BitBlock temp18 = simd_and(bit[2], bit[3]);
383        BitBlock temp19 = simd_and(temp17, temp18);
384        BitBlock temp20 = simd_andc(bit[4], bit[5]);
385        BitBlock temp21 = simd_and(bit[6], bit[7]);
386        BitBlock temp22 = simd_and(temp20, temp21);
387        BitBlock RBracket = simd_and(temp19, temp22);
388        LexItem[Hyphen] = simd_andc(temp14, temp11);
389        BitBlock temp23 = simd_and(temp4, temp21);
390        LexItem[QMark] = simd_and(temp14, temp23);
391        BitBlock temp24 = simd_and(temp1, temp18);
392        BitBlock temp25 = simd_and(temp4, bit[7]);
393        BitBlock temp26 = simd_and(temp24, temp25);
394        BitBlock temp27 = simd_or(temp26, temp7);
395        LexItem[Quote] = simd_or(temp27, temp12);
396        BitBlock temp28 = simd_and(temp1, bit[3]);
397        BitBlock temp29 = simd_and(temp16, temp28);
398        BitBlock temp30 = simd_andc(bit[7], bit[6]);
399        BitBlock temp31 = simd_andc(temp30, temp10);
400        BitBlock temp32 = simd_and(temp14, temp31);
401        BitBlock temp33 = simd_or(temp29, temp32);
402        BitBlock temp34 = simd_or(temp33, RAngle);
403        LexItem[NameFollow] = simd_or(temp34, LexItem[QMark]);
404#ifdef DIGIT_AND_HEX_ITEMS
405        /* Need to improve the compiler's EBCDIC translation for ranges. */
406        BitBlock temp35 = simd_and(bit[0], bit[1]);
407        BitBlock temp36 = simd_and(temp35, temp18);
408        BitBlock temp37 = simd_andc(temp11, temp31);
409        BitBlock temp38 = simd_andc(temp15, temp10);
410        BitBlock temp39 = simd_andc(temp37, temp38);
411        BitBlock temp40 = simd_andc(temp21, temp10);
412        BitBlock temp41 = simd_andc(temp39, temp40);
413        BitBlock temp42 = simd_andc(bit[5], bit[4]);
414        BitBlock temp43 = simd_andc(temp42, temp5);
415        BitBlock temp44 = simd_andc(temp41, temp43);
416        BitBlock temp45 = simd_and(temp42, temp30);
417        BitBlock temp46 = simd_andc(temp44, temp45);
418        BitBlock temp47 = simd_and(temp42, temp15);
419        BitBlock temp48 = simd_andc(temp46, temp47);
420        BitBlock temp49 = simd_and(temp42, temp21);
421        BitBlock temp50 = simd_andc(temp48, temp49);
422        BitBlock temp51 = simd_andc(temp20, temp5);
423        BitBlock temp52 = simd_andc(temp50, temp51);
424        BitBlock temp53 = simd_and(temp20, temp30);
425        BitBlock temp54 = simd_andc(temp52, temp53);
426        BitBlock Digit = simd_andc(temp36, temp54);
427        BitBlock temp55 = simd_andc(temp35, temp2);
428        BitBlock temp56 = simd_and(temp55, temp31);
429        BitBlock temp57 = simd_or(Digit, temp56);
430        BitBlock temp58 = simd_and(temp55, temp38);
431        BitBlock temp59 = simd_or(temp57, temp58);
432        BitBlock temp60 = simd_and(temp55, temp40);
433        BitBlock temp61 = simd_or(temp59, temp60);
434        BitBlock temp62 = simd_and(temp55, temp43);
435        BitBlock temp63 = simd_or(temp61, temp62);
436        BitBlock temp64 = simd_and(temp55, temp45);
437        BitBlock temp65 = simd_or(temp63, temp64);
438        BitBlock temp66 = simd_and(temp55, temp47);
439        BitBlock temp67 = simd_or(temp65, temp66);
440        BitBlock temp68 = simd_andc(temp17, temp2);
441        BitBlock temp69 = simd_and(temp68, temp31);
442        BitBlock temp70 = simd_or(temp67, temp69);
443        BitBlock temp71 = simd_and(temp68, temp38);
444        BitBlock temp72 = simd_or(temp70, temp71);
445        BitBlock temp73 = simd_and(temp68, temp40);
446        BitBlock temp74 = simd_or(temp72, temp73);
447        BitBlock temp75 = simd_and(temp68, temp43);
448        BitBlock temp76 = simd_or(temp74, temp75);
449        BitBlock temp77 = simd_and(temp68, temp45);
450        BitBlock temp78 = simd_or(temp76, temp77);
451        BitBlock temp79 = simd_and(temp68, temp47);
452        BitBlock Hex = simd_or(temp78, temp79);
453        LexItem[NonDigit] = simd_not(Digit);
454        LexItem[NonHex] = simd_not(Hex);
455#endif 
456       
457        /* Mark potential occurrences of ']]>'  These are all actual
458        occurrences of ]]> as well as occurrences of ]] or ] at
459        the block end. Shifting the RBracket and RAngle streams in
460        negated forms ensures that a potential CD_End is not ruled
461        out at the block boundary. */
462        LexItem[CD_End_check] = simd_andc(RBracket, 
463                                          simd_or(sisd_sbli(simd_not(RBracket), 1),
464                                                  sisd_sbli(simd_not(RAngle), 2)));
465#ifndef OMIT_CD_End_check_In_Markup_Scan
466        LexItem[MarkupStart] = simd_or(LexItem[MarkupStart], LexItem[CD_End_check]);
467#endif
468}
469
470
471/* A temporary structure for internal use in ComputeLexicalItemStreams. */
472typedef struct {
473        BitBlock LexicalItems[LexicalItemCount];
474} LexicalItemBlock;
475
476
477
478
479template <CodeUnit_Base C>
480void Lexer<C>::Do_MarkupStreams() {
481        LexicalItemBlock lx_blk[BUFFER_BLOCKS];
482        for (int i = 0; i < buffer_blocks; i++) {
483                ComputeLexicalItemBlocks<C>(x8basis[i].bit, lx_blk[i].LexicalItems);
484        }
485#ifdef BUFFER_PROFILING
486        end_BOM_interval(bitstream_timer);
487        start_BOM_interval(lextranspose_timer);
488#endif
489        /* NonWS stream already completed by WS_Control method. */
490        for (int j = MarkupStart; j < LexicalItemCount; j++) {
491                for (int i = 0; i < buffer_blocks; i++) {
492                        parsing_engine_data->item_stream[j][i] = lx_blk[i].LexicalItems[j];
493                }
494        }
495        for (int i = 0; i < buffer_blocks; i++) {
496                parsing_engine_data->item_stream[NameFollow][i] = 
497                        simd_or(parsing_engine_data->item_stream[NameFollow][i],
498                                simd_not(parsing_engine_data->item_stream[NonWS][i]));
499        }
500#ifdef BUFFER_PROFILING
501        end_BOM_interval(lextranspose_timer);
502        start_BOM_interval(scanner_timer);
503#endif
504};
505
506
507/* Stub out Charset Validation initially. */
508
509void UTF_8_Lexer::Do_CharsetValidation() {
510        //printf("UTF_8_Lexer::Do_CharsetValidation not yet implemented; assuming OK.\n");
511};
512
513
514void ASCII_7_Lexer::Do_CharsetValidation() {
515        BitBlock Restricted = simd_const_1(0);
516        for (int blk = 0; blk < buffer_blocks; blk++) {
517                Restricted = simd_or(Restricted, x8basis[blk].bit[0]);
518        }
519        if (bitblock_has_bit(Restricted)) {
520                printf("Illegal non-ASCII character in input for ASCII document.\n");
521                exit(-1);
522        }
523};
524
525
526void EASCII_8_Lexer::Do_CharsetValidation() {
527        /* Nothing required for most charsets - but perhaps should have tables. */
528};
529
530
531void UTF_16_Lexer::Do_CharsetValidation() {
532#ifdef X16HILO_ACCESS
533        int packs = (buffer_units - 1)/PACKSIZE + 1;
534        BytePack surrogate_select;
535        BytePack hi_surrogate;
536        BytePack lo_surrogate;
537        BytePack hi_surrogate_pending = simd_const_8(0);
538        BytePack surrogate_scope;
539        BytePack u16_surrogate_accum = simd_const_8(0);
540        BytePack u16_FFFE_FFFF_accum = simd_const_8(0);
541        BytePack u16_FFFE_FFFF;
542        for (int pk = 0; pk < packs; pk++) {
543                /* UTF-16 code units in the range D800-DBFF and DC00-DFFF are
544                   reserved for the first and second elements, respectively
545                   of surrogate pairs.  Validation requires that these values
546                   only occur in well-formed pairs. */
547                surrogate_select = simd_and(x16hi[pk], simd_const_8(0xDC));
548                hi_surrogate = simd_eq_8(surrogate_select, simd_const_8(0xD8));
549                lo_surrogate = simd_eq_8(surrogate_select, simd_const_8(0xDC));
550                surrogate_scope = simd_or(hi_surrogate_pending,
551                                          sisd_sfli(hi_surrogate, 8));
552                u16_surrogate_accum = simd_or(u16_surrogate_accum,
553                                              simd_xor(surrogate_scope, lo_surrogate));
554                hi_surrogate_pending = sisd_sbli(hi_surrogate, 8 * (PACKSIZE-1));
555                /* The values FFFE and FFFF are excluded. */
556                u16_FFFE_FFFF = simd_eq_8(simd_and(x16hi[pk],
557                                                   simd_or(x16lo[pk], simd_const_8(1))),
558                                          simd_const_8(0xFF));
559                u16_FFFE_FFFF_accum = simd_or(u16_FFFE_FFFF_accum, u16_FFFE_FFFF);
560        }
561        u16_surrogate_accum = simd_or(u16_surrogate_accum, hi_surrogate_pending);
562        if (bitblock_has_bit(simd_or(u16_surrogate_accum, u16_FFFE_FFFF_accum)))
563                printf("UTF-16 validation error.\n");
564                exit(-1);
565        }
566#endif
567#ifndef X16HILO_ACCESS
568        printf("UTF_16_Lexer::Do_CharsetValidation not yet complete; assuming OK.\n");
569#endif
570};
571
572
573void UCS_2_Lexer::Do_CharsetValidation() {
574#ifdef X16HILO_ACCESS
575        int packs = (buffer_units - 1)/PACKSIZE + 1;
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                /* The high byte of UCS-2 code units cannot be in the range D8-DF.
581                   This corresponds to the D800-DFFF range of illegal codepoints
582                   reserved for UTF-16 surrogate pairs. Accumulate the results.
583                   To check, 0x20 is added to each such octet, mapping the D8-DF
584                   range to F8-FF and wrapping E0-FF values around.  The max value
585                   is then accumulated.  */
586                u16_surrogate_accum =
587                        simd_max_8(u16_surrogate_accum, 
588                                   simd_add_8(x16hi[pk], simd_const_8(0x20)));
589                /* The values FFFE and FFFF are excluded. */
590                u16_FFFE_FFFF = simd_eq_8(simd_and(x16hi[pk],
591                                                   simd_or(x16lo[pk], simd_const_8(1))),
592                                          simd_const_8(0xFF));
593                u16_FFFE_FFFF_accum = simd_or(u16_FFFE_FFFF_accum, u16_FFFE_FFFF);
594        }
595        u16_surrogate_accum = simd_eq_8(simd_or(u16_surrogate_accum, simd_const_8(0x07)),
596                                        simd_const_8(0xFF));
597        if (bitblock_has_bit(simd_or(u16_surrogate_accum, u16_FFFE_FFFF_accum)))
598                printf("UCS-2 validation error.\n");
599                exit(-1);
600        }
601#endif
602#ifndef X16HILO_ACCESS
603        printf("UCS_2_Lexer::Do_CharsetValidation not yet complete; assuming OK.\n");
604#endif
605};
606
607
608void UTF_32_Lexer::Do_CharsetValidation() {
609#ifdef X32BYTEPLEX_ACCESS
610        int packs = (buffer_units - 1)/PACKSIZE + 1;
611        BytePack u32hh_accum = simd_const_8(0);
612        BytePack u32hl_accum = simd_const_8(0);
613        BytePack u32_surrogate_accum = simd_const_8(0);
614        BytePack u32_FFFE_FFFF_accum = simd_const_8(0);
615        BytePack u32_BMP_select;
616        BytePack u32l_FFFE_FFFF;
617        for (int pk = 0; pk < packs; pk++) {
618                /* There can be no bits set in the high octet; "or" together
619                   all octet values to check for any bit set. */
620                u32hh_accum = simd_or(u32hh_accum, x32hh[pk]);
621                /* The second octet has a max value of 0x10, corresponding to the
622                   maximum Unicode code point value of 0x10FFFF.  Accumulate the
623                   maximum of all u32hl values observed. */ 
624                u32hl_accum = simd_max_8(u32hl_accum, x32hl[pk]);
625                /* The third octet cannot be in the range D8-DF if the second octet
626                   is 0.  This corresponds to the D800-DFFF range of illegal codepoints
627                   reserved for UTF-16 surrogate pairs. Accumulate the results.
628                   To check, 0x20 is added to each such octet, mapping the D8-DF
629                   range to F8-FF and wrapping E0-FF values around.  The max value
630                   is then accumulated.  */
631                u32_BMP_select = simd_eq_8(x32hl[pk], simd_const_8(0));
632                u32_surrogate_accum = 
633                        simd_max_8(u32_surrogate_accum, 
634                                   simd_and(u32_BMP_select,
635                                            simd_add_8(x32lh[pk], simd_const_8(0x20))));
636                /* The low two octets cannot have the value FFFE or FFFF if
637                   we're in the BMP (second octet is 0). */
638                u32l_FFFE_FFFF = simd_eq_8(simd_and(x32lh[pk],
639                                                    simd_or(x32ll[pk], simd_const_8(1))),
640                                           simd_const_8(0xFF));
641                u32_FFFE_FFFF_accum = simd_or(u32_FFFE_FFFF_accum,
642                                              simd_and(u32_BMP_select, u32l_FFFE_FFFF));
643        }
644        u32hl_accum = simd_gt_8(u32hl_accum, simd_const_8(0x10));
645        u32_surrogate_accum = simd_eq_8(simd_or(u32_surrogate_accum, simd_const_8(0x07)),
646                                        simd_const_8(0xFF));
647        if (bitblock_has_bit(simd_or(simd_or(u32hh_accum, u32hl_accum),
648                                         simd_or(u32_surrogate_accum, u32_FFFE_FFFF_accum)))) {
649                printf("UTF-32 validation error.\n");
650                exit(-1);
651        }
652#endif
653#ifndef X32BYTEPLEX_ACCESS
654        printf("UTF_32_Lexer::Do_CharsetValidation not yet complete; assuming OK.\n");
655#endif
656};
657
658
659void EBCDIC_Lexer::Do_CharsetValidation() {
660        /* Nothing required for most cases - but perhaps should have tables. */
661};
662
663
664
665
666/* Stub out XML 1.1 routines initially. */
667
668void UTF_8_Lexer::Do_XML_11_WS_Control() {
669        printf("UTF_8_Lexer::Do_XML_11_WS_Control not yet implemented; using XML 1.0 rules.\n");
670        Do_XML_10_WS_Control();
671};
672
673
674static inline void ASCII_7_WS_Control_Blocks_11(BitBlock bit[], BitBlock& WS, BitBlock& Control) {
675        BitBlock temp1 = simd_or(bit[0], bit[1]);
676        BitBlock temp2 = simd_or(temp1, bit[2]);
677        BitBlock temp3 = simd_andc(bit[1], bit[0]);
678        BitBlock temp4 = simd_and(bit[2], bit[3]);
679        BitBlock temp5 = simd_and(temp3, temp4);
680        BitBlock temp6 = simd_and(bit[4], bit[5]);
681        BitBlock temp7 = simd_and(bit[6], bit[7]);
682        BitBlock temp8 = simd_and(temp6, temp7);
683        BitBlock temp9 = simd_and(temp5, temp8);
684        BitBlock temp10 = simd_andc(temp2, temp9);
685        BitBlock temp11 = simd_andc(temp10, bit[0]);
686        Control = simd_andc(simd_const_1(1), temp11);
687        BitBlock temp12 = simd_or(bit[2], bit[3]);
688        BitBlock temp13 = simd_or(temp1, temp12);
689        BitBlock temp14 = simd_andc(bit[7], bit[6]);
690        BitBlock temp15 = simd_and(temp6, temp14);
691        BitBlock CR = simd_andc(temp15, temp13);
692        BitBlock temp16 = simd_andc(bit[4], bit[5]);
693        BitBlock temp17 = simd_andc(bit[6], bit[7]);
694        BitBlock temp18 = simd_and(temp16, temp17);
695        BitBlock LF = simd_andc(temp18, temp13);
696        BitBlock temp19 = simd_and(temp16, temp14);
697        BitBlock HT = simd_andc(temp19, temp13);
698        BitBlock temp20 = simd_andc(bit[2], bit[3]);
699        BitBlock temp21 = simd_andc(temp20, temp1);
700        BitBlock temp22 = simd_or(bit[4], bit[5]);
701        BitBlock temp23 = simd_or(bit[6], bit[7]);
702        BitBlock temp24 = simd_or(temp22, temp23);
703        BitBlock SP = simd_andc(temp21, temp24);
704        WS = simd_or(simd_or(CR, LF), simd_or(HT, SP));
705}
706
707
708void ASCII_7_Lexer::Do_XML_11_WS_Control() {
709        BitBlock Restricted = simd_const_1(0);
710        BitBlock Control = simd_const_1(0);
711        BitBlock WS = simd_const_1(0);
712        for (int i = 0; i < buffer_blocks; i++) {
713                Restricted = simd_or(Restricted, simd_andc(Control, WS));
714                ASCII_7_WS_Control_Blocks_11(x8basis[i].bit, WS, Control);
715                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
716        }
717        if ((buffer_units % BLOCKSIZE) != 0) 
718                Control = simd_andc(Control,
719                                    sisd_sfl(simd_const_1(1), 
720                                             sisd_from_int(buffer_units % BLOCKSIZE)));
721        Restricted = simd_or(Restricted, simd_andc(Control, WS));
722        if (bitblock_has_bit(Restricted)) {
723                printf("***Restricted control character in input.\n");
724                exit(-1);
725        }
726};
727
728static inline void EASCII_8_WS_Control_Blocks_11(BitBlock bit[], BitBlock& WS, BitBlock& Control) {
729        BitBlock temp1 = simd_or(bit[0], bit[1]);
730        BitBlock temp2 = simd_or(temp1, bit[2]);
731        BitBlock temp3 = simd_andc(bit[1], bit[0]);
732        BitBlock temp4 = simd_and(bit[2], bit[3]);
733        BitBlock temp5 = simd_and(temp3, temp4);
734        BitBlock temp6 = simd_and(bit[4], bit[5]);
735        BitBlock temp7 = simd_and(bit[6], bit[7]);
736        BitBlock temp8 = simd_and(temp6, temp7);
737        BitBlock temp9 = simd_and(temp5, temp8);
738        BitBlock temp10 = simd_andc(temp2, temp9);
739        BitBlock temp11 = simd_andc(bit[0], bit[1]);
740        BitBlock temp12 = simd_andc(temp11, bit[2]);
741        BitBlock temp13 = simd_andc(temp10, temp12);
742        Control = simd_andc(simd_const_1(1), temp13);
743        BitBlock temp14 = simd_or(bit[2], bit[3]);
744        BitBlock temp15 = simd_or(temp1, temp14);
745        BitBlock temp16 = simd_andc(bit[7], bit[6]);
746        BitBlock temp17 = simd_and(temp6, temp16);
747        BitBlock CR = simd_andc(temp17, temp15);
748        BitBlock temp18 = simd_andc(bit[4], bit[5]);
749        BitBlock temp19 = simd_andc(bit[6], bit[7]);
750        BitBlock temp20 = simd_and(temp18, temp19);
751        BitBlock LF = simd_andc(temp20, temp15);
752        BitBlock temp21 = simd_and(temp18, temp16);
753        BitBlock HT = simd_andc(temp21, temp15);
754        BitBlock temp22 = simd_andc(bit[2], bit[3]);
755        BitBlock temp23 = simd_andc(temp22, temp1);
756        BitBlock temp24 = simd_or(bit[4], bit[5]);
757        BitBlock temp25 = simd_or(bit[6], bit[7]);
758        BitBlock temp26 = simd_or(temp24, temp25);
759        BitBlock SP = simd_andc(temp23, temp26);
760        BitBlock temp27 = simd_andc(temp11, temp14);
761        BitBlock temp28 = simd_andc(bit[5], bit[4]);
762        BitBlock temp29 = simd_and(temp28, temp16);
763        BitBlock NEL = simd_and(temp27, temp29);
764        WS = simd_or(simd_or(simd_or(CR, LF), simd_or(HT, SP)), NEL);
765}
766
767void EASCII_8_Lexer::Do_XML_11_WS_Control() {
768        BitBlock Restricted = simd_const_1(0);
769        BitBlock Control = simd_const_1(0);
770        BitBlock WS = simd_const_1(0);
771        for (int i = 0; i < buffer_blocks; i++) {
772                Restricted = simd_or(Restricted, simd_andc(Control, WS));
773                EASCII_8_WS_Control_Blocks_11(x8basis[i].bit, WS, Control);
774                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
775        }
776        if ((buffer_units % BLOCKSIZE) != 0) 
777                Control = simd_andc(Control,
778                                    sisd_sfl(simd_const_1(1), 
779                                             sisd_from_int(buffer_units % BLOCKSIZE)));
780        Restricted = simd_or(Restricted, simd_andc(Control, WS));
781        if (bitblock_has_bit(Restricted)) {
782                printf("***Restricted control character in input.\n");
783                exit(-1);
784        }
785};
786
787
788void U16_Lexer::Do_XML_11_WS_Control() {
789        printf("U16_Lexer::Do_XML_11_WS_Control not yet implemented; using XML 1.0 rules.\n");
790        Do_XML_10_WS_Control();
791};
792
793
794void UTF_32_Lexer::Do_XML_11_WS_Control() {
795        printf("UTF_32_Lexer::Do_XML_11_WS_Control not yet implemented; using XML 1.0 rules.\n");
796        Do_XML_10_WS_Control();
797};
798
799static inline void EBCDIC_WS_Control_Blocks_11(BitBlock bit[], BitBlock& WS, BitBlock& Control) {
800        BitBlock temp1 = simd_or(bit[0], bit[1]);
801        BitBlock temp2 = simd_and(bit[0], bit[1]);
802        BitBlock temp3 = simd_and(bit[2], bit[3]);
803        BitBlock temp4 = simd_and(temp2, temp3);
804        BitBlock temp5 = simd_and(bit[4], bit[5]);
805        BitBlock temp6 = simd_and(bit[6], bit[7]);
806        BitBlock temp7 = simd_and(temp5, temp6);
807        BitBlock temp8 = simd_and(temp4, temp7);
808        BitBlock temp9 = simd_andc(temp1, temp8);
809        Control = simd_andc(simd_const_1(1), temp9);
810        BitBlock temp10 = simd_or(bit[2], bit[3]);
811        BitBlock temp11 = simd_or(temp1, temp10);
812        BitBlock temp12 = simd_andc(bit[7], bit[6]);
813        BitBlock temp13 = simd_and(temp5, temp12);
814        BitBlock CR = simd_andc(temp13, temp11);
815        BitBlock temp14 = simd_andc(bit[2], bit[3]);
816        BitBlock temp15 = simd_andc(temp14, temp1);
817        BitBlock temp16 = simd_andc(bit[5], bit[4]);
818        BitBlock temp17 = simd_and(temp16, temp12);
819        BitBlock LF = simd_and(temp15, temp17);
820        BitBlock HT = simd_andc(temp17, temp11);
821        BitBlock temp18 = simd_andc(bit[1], bit[0]);
822        BitBlock temp19 = simd_andc(temp18, temp10);
823        BitBlock temp20 = simd_or(bit[4], bit[5]);
824        BitBlock temp21 = simd_or(bit[6], bit[7]);
825        BitBlock temp22 = simd_or(temp20, temp21);
826        BitBlock SP = simd_andc(temp19, temp22);
827        BitBlock temp23 = simd_andc(bit[3], bit[2]);
828        BitBlock temp24 = simd_andc(temp23, temp1);
829        BitBlock NEL = simd_and(temp24, temp17);
830        WS = simd_or(simd_or(simd_or(CR, LF), simd_or(HT, SP)), NEL);
831}
832
833void EBCDIC_Lexer::Do_XML_11_WS_Control() {
834        BitBlock Restricted = simd_const_1(0);
835        BitBlock Control = simd_const_1(0);
836        BitBlock WS = simd_const_1(0);
837        for (int i = 0; i < buffer_blocks; i++) {
838                Restricted = simd_or(Restricted, simd_andc(Control, WS));
839                EBCDIC_WS_Control_Blocks_11(x8basis[i].bit, WS, Control);
840                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
841        }
842        if ((buffer_units % BLOCKSIZE) != 0) 
843                Control = simd_andc(Control,
844                                    sisd_sfl(simd_const_1(1), 
845                                             sisd_from_int(buffer_units % BLOCKSIZE)));
846        Restricted = simd_or(Restricted, simd_andc(Control, WS));
847        if (bitblock_has_bit(Restricted)) {
848                printf("***Restricted control character in input.\n");
849                exit(-1);
850        }
851};
852
853
854
855#include "transpose.h"
856
857void Lexer_Interface::TransposeToBitStreams() {
858        BytePack * pseudoASCII_src = &(xml_buf->x8data[lexer_base_pos/PACKSIZE]);
859        for (int blk = 0; blk < buffer_blocks; blk++) {
860                s2p_bytepack(&pseudoASCII_src[blk*8], x8basis[blk].bit);
861        }
862}
863
864void Lexer_Interface::AdvanceBuffer(int& base_pos, int& rel_pos, int& limit_pos) {
865        BitBlock final_block_mask;
866#ifdef BUFFER_PROFILING
867        start_BOM_interval(bitstream_timer);
868#endif
869#ifdef DEBUG
870        printf("AdvanceBuffer entry.\n");
871#endif
872        int abspos = base_pos + rel_pos;
873        lexer_base_pos = abspos & (-PACKSIZE); /* align the base_position for lexer*/
874        buffer_units = xml_buf->AvailableUnits(lexer_base_pos);
875#ifdef DEBUG
876        printf("buffer_units = %i.\n", buffer_units);
877#endif
878        if (buffer_units >= BUFFER_SIZE) {
879                buffer_units = BUFFER_SIZE;
880                final_block_mask = simd_const_1(0);
881        }
882        else {
883                final_block_mask = 
884                        sisd_sfl(simd_const_1(1), sisd_from_int(buffer_units % BLOCKSIZE));
885        }
886        buffer_blocks = (buffer_units -1)/BLOCKSIZE + 1;
887#ifdef DEBUG
888        printf("Transpose for abspos = %i, lexer_base_pos= %i, buffer_blocks = %i.\n", abspos, lexer_base_pos, buffer_blocks);
889#endif
890
891        TransposeToBitStreams();
892#ifdef DEBUG
893        printf("Transposition to bit streams complete.\n");
894#endif
895        if (xml_buf->version == XML_1_1) Do_XML_11_WS_Control();
896        else Do_XML_10_WS_Control();
897        Do_MarkupStreams();
898#ifdef DEBUG
899        printf("Markup streams complete.\n");
900#endif
901        Do_CharsetValidation();
902#ifdef DEBUG
903        printf("Validation complete.\n");
904#endif
905        if (buffer_units < BUFFER_SIZE) {
906#ifdef DEBUG
907                printf("SENTINELS at %i of length %i\n", lexer_base_pos + buffer_units,
908                                                buffer_units % BLOCKSIZE);
909#endif
910                int lastblk = buffer_units/BLOCKSIZE;
911                for (int j = minLexicalItem; j < LexicalItemCount; j++) {
912                        parsing_engine_data->item_stream[j][lastblk] =
913                                simd_or(parsing_engine_data->item_stream[j][lastblk],
914                                        final_block_mask);
915                }
916        }
917        /* Update parser control variables. */
918        base_pos = lexer_base_pos;
919        rel_pos = abspos - lexer_base_pos;
920        limit_pos = buffer_units;
921}
922
Note: See TracBrowser for help on using the repository browser.