source: trunk/src/bitlex.c @ 65

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

Add CODE_CLOCKING instrumentation.

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