source: trunk/src/bitlex.c @ 179

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

Templated SIMD Library - initial version

File size: 38.7 KB
Line 
1/*  bitlex - Lexical Item Stream Module.
2    Copyright (c) 2007, 2008, Robert D. Cameron.
3    Licensed to the public under the Open Software License 3.0.
4    Licensed to International Characters, Inc., under the Academic
5    Free License 3.0.
6
7*/
8
9#include "bitlex.h"
10#include "../lib/lib_simd.h"
11#include "xml_error.h"
12
13#ifdef CODE_CLOCKING
14/*
15#include "../codeclocker/clocker/code_clocker_session.h"
16Code_Clocker * transpose_clocker;
17Code_Clocker * WS_Control_clocker;
18Code_Clocker * MarkupStreams_clocker;
19Code_Clocker * char_validation_clocker;
20*/
21#endif
22
23
24Lexer_Interface::Lexer_Interface(Entity_Info * e, LexicalStreamSet *l) {
25        entity_Info = e;
26        parsing_engine_data = l;
27
28        x8basis = (BitBlockBasis *) simd_new(BUFFER_SIZE/PACKSIZE);
29        validation_stream = (BitBlock *) simd_new(BUFFER_BLOCKS+SENTINEL_BLOCKS);
30#ifdef TEMPLATED_SIMD_LIB
31        validation_stream[BUFFER_BLOCKS] = simd_const<1,1>();
32#endif
33#ifndef TEMPLATED_SIMD_LIB
34        validation_stream[BUFFER_BLOCKS] = simd_const_1(1);
35#endif
36};
37
38
39Lexer_Interface::~Lexer_Interface() {
40        simd_delete((SIMD_type *) validation_stream);
41        simd_delete((SIMD_type *) x8basis);
42};
43
44
45template <>
46Lexer_Interface * Lexer<ASCII>::LexerFactory(Entity_Info * e, LexicalStreamSet *l) {
47#ifdef CODE_CLOCKING
48/*
49        WS_Control_clocker = register_Code_Clocker("WS", "WhiteSpace/Control\n");
50        MarkupStreams_clocker = register_Code_Clocker("bitlex", "Markup streams\n");
51        char_validation_clocker = register_Code_Clocker("charcheck", "Character validation\n");
52*/
53#endif
54        if (!(e->has_encoding_decl)) {
55                // Must be UTF-8 or UTF-16; UTF-16 requires a ByteOrderMark.
56                if (e->code_unit_size == SingleByte) return new UTF_8_Lexer(e, l);
57                else if ((e->code_unit_size == DoubleByte))
58                        if (e->BOM_units == 1) return new UTF_16_Lexer(e, l);
59                        else NoEncodingError("UTF-16 implied but no byte order found.");
60                else NoEncodingError("UTF-32 without an encoding declaration.\n");
61        }
62        else {
63                int lgth = strlen((const char *) e->encoding);
64                CodeUnit_ByteOrder order = e->byte_order;
65                switch (e->code_unit_size) {
66                case SingleByte:
67                        if ((lgth == 5) && at_UTF_8(e->encoding))
68                                return new UTF_8_Lexer(e, l);
69                        else if ((lgth == 5) && at_ASCII(e->encoding))
70                                return new ASCII_7_Lexer(e, l);
71                        else if ((lgth == 6)  && at_Latin1(e->encoding))
72                                return new EASCII_8_Lexer(e, l);
73                        /* Really need a table-based lookup here */
74                        else EncodingError("8-bit", e->encoding, lgth);
75                case DoubleByte:
76                        if (e->BOM_units == 1) 
77                                if ((lgth == 6) && at_UTF_16(e->encoding))
78                                        return new UTF_16_Lexer(e, l);
79                                else if ((lgth == 5) && at_UCS_2(e->encoding))
80                                        return new UCS_2_Lexer(e, l);
81                                else EncodingError("16-bit", e->encoding, lgth);
82                        else if (order == BigEndian)
83                                if ((lgth == 8) && at_UTF_16BE(e->encoding))
84                                        return new UTF_16_Lexer(e, l);
85                                else if ((lgth == 7) && at_UCS_2BE(e->encoding))
86                                        return new UCS_2_Lexer(e, l);
87                                else EncodingError("16BE", e->encoding, lgth);
88                        else /*if (order == LittleEndian)*/
89                                if ((lgth == 8) && at_UTF_16LE(e->encoding))
90                                        return new UTF_16_Lexer(e, l);
91                                else if ((lgth == 7) && at_UCS_2LE(e->encoding))
92                                        return new UCS_2_Lexer(e, l);
93                                else EncodingError("16LE", e->encoding, lgth);
94                case QuadByte:
95                        if (e->BOM_units == 1) 
96                                if ((lgth == 6) && at_UTF_32(e->encoding))
97                                        return new UTF_32_Lexer(e, l);
98                                else if ((lgth == 5) && at_UCS_4(e->encoding))
99                                        return new UTF_32_Lexer(e, l);
100                                else EncodingError("32-bit", e->encoding, lgth);
101                        else if (order == BigEndian)
102                                if ((lgth == 8) && at_UTF_32BE(e->encoding))
103                                        return new UTF_32_Lexer(e, l);
104                                else if ((lgth == 7) && at_UCS_4BE(e->encoding))
105                                        return new UTF_32_Lexer(e, l);
106                                else EncodingError("32BE", e->encoding, lgth);
107                        else if (order == LittleEndian)
108                                if ((lgth == 8) && at_UTF_32LE(e->encoding))
109                                        return new UTF_32_Lexer(e, l);
110                                else if ((lgth == 7) && at_UCS_4LE(e->encoding))
111                                        return new UTF_32_Lexer(e, l);
112                                else EncodingError("32LE", e->encoding, lgth);
113                        else EncodingError("32-bit", e->encoding, lgth);
114                }
115        }
116}
117
118template <>
119Lexer_Interface * Lexer<EBCDIC>::LexerFactory(Entity_Info * e, LexicalStreamSet *l) {
120        if (!(e->has_encoding_decl)) {
121                // Must be UTF-8 or UTF-16; UTF-16 requires a ByteOrderMark.
122                NoEncodingError("EBCDIC-family inferred, but no encoding declaration present.\n");
123        }
124        else {
125                int lgth = strlen((const char *) e->encoding);
126                /* Really need a table-based lookup here */
127                if ((lgth == 6) && at_EBCDIC(e->encoding))
128                        return new EBCDIC_Lexer(e, l);
129                else EncodingError("EBCDIC family", e->encoding, lgth);
130        }
131}
132
133template <CodeUnit_Base C>
134Lexer<C>::Lexer(Entity_Info * e, LexicalStreamSet *l) : Lexer_Interface::Lexer_Interface(e, l) {
135}
136
137UTF_8_Lexer::UTF_8_Lexer(Entity_Info * e, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(e, l) {
138}
139
140ASCII_7_Lexer::ASCII_7_Lexer(Entity_Info * e, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(e, l) {
141}
142
143EASCII_8_Lexer::EASCII_8_Lexer(Entity_Info * e, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(e, l) {
144}
145
146U16_Lexer::U16_Lexer(Entity_Info * e, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(e, l) {
147}
148
149UTF_16_Lexer::UTF_16_Lexer(Entity_Info * e, LexicalStreamSet *l) : U16_Lexer::U16_Lexer(e, l) {
150}
151
152UCS_2_Lexer::UCS_2_Lexer(Entity_Info * e, LexicalStreamSet *l) : U16_Lexer::U16_Lexer(e, l) {
153}
154
155UTF_32_Lexer::UTF_32_Lexer(Entity_Info * e, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(e, l) {
156}
157
158EBCDIC_Lexer::EBCDIC_Lexer(Entity_Info * e, LexicalStreamSet *l) : Lexer<EBCDIC>::Lexer(e, l) {
159}
160
161template <CodeUnit_Base C>
162static inline void WS_Control_Blocks(BitBlock bit[], BitBlock& WS, BitBlock& Control);
163
164template <>
165static inline void WS_Control_Blocks<ASCII>(BitBlock bit[], BitBlock& WS, BitBlock& Control) {
166        BitBlock temp1 = simd_or(bit[0], bit[1]);
167        BitBlock temp2 = simd_or(temp1, bit[2]);
168#ifdef TEMPLATED_SIMD_LIB
169        Control = simd_andc(simd_const<1,1>(), temp2);
170#endif
171#ifndef TEMPLATED_SIMD_LIB
172        Control = simd_andc(simd_const_1(1), temp2);
173#endif
174        BitBlock temp3 = simd_or(bit[2], bit[3]);
175        BitBlock temp4 = simd_or(temp1, temp3);
176        BitBlock temp5 = simd_and(bit[4], bit[5]);
177        BitBlock temp6 = simd_andc(bit[7], bit[6]);
178        BitBlock temp7 = simd_and(temp5, temp6);
179        BitBlock CR = simd_andc(temp7, temp4);
180        BitBlock temp8 = simd_andc(bit[4], bit[5]);
181        BitBlock temp9 = simd_andc(bit[6], bit[7]);
182        BitBlock temp10 = simd_and(temp8, temp9);
183        BitBlock LF = simd_andc(temp10, temp4);
184        BitBlock temp11 = simd_and(temp8, temp6);
185        BitBlock HT = simd_andc(temp11, temp4);
186        BitBlock temp12 = simd_andc(bit[2], bit[3]);
187        BitBlock temp13 = simd_andc(temp12, temp1);
188        BitBlock temp14 = simd_or(bit[4], bit[5]);
189        BitBlock temp15 = simd_or(bit[6], bit[7]);
190        BitBlock temp16 = simd_or(temp14, temp15);
191        BitBlock SP = simd_andc(temp13, temp16);
192        WS = simd_or(simd_or(CR, LF), simd_or(HT, SP));
193}
194
195template <>
196static inline void WS_Control_Blocks<EBCDIC>(BitBlock bit[], BitBlock& WS, BitBlock& Control) {
197        BitBlock temp1 = simd_or(bit[0], bit[1]);
198        BitBlock temp2 = simd_or(bit[2], bit[3]);
199        BitBlock temp3 = simd_or(temp1, temp2);
200        BitBlock temp4 = simd_or(bit[4], bit[5]);
201        BitBlock temp5 = simd_or(temp3, temp4);
202        BitBlock temp6 = simd_and(bit[2], bit[3]);
203        BitBlock temp7 = simd_andc(temp6, temp1);
204        BitBlock temp8 = simd_andc(bit[5], bit[4]);
205        BitBlock temp9 = simd_and(bit[6], bit[7]);
206        BitBlock temp10 = simd_and(temp8, temp9);
207        BitBlock temp11 = simd_and(temp7, temp10);
208        BitBlock temp12 = simd_andc(temp5, temp11);
209        BitBlock temp13 = simd_andc(bit[2], bit[3]);
210        BitBlock temp14 = simd_andc(temp13, temp1);
211        BitBlock temp15 = simd_and(bit[4], bit[5]);
212        BitBlock temp16 = simd_and(temp14, temp15);
213        BitBlock temp17 = simd_andc(bit[6], bit[7]);
214        BitBlock temp18 = simd_andc(temp16, temp17);
215        BitBlock temp19 = simd_andc(temp12, temp18);
216        BitBlock temp20 = simd_andc(bit[3], bit[2]);
217        BitBlock temp21 = simd_andc(temp20, temp1);
218        BitBlock temp22 = simd_and(temp8, temp17);
219        BitBlock temp23 = simd_and(temp21, temp22);
220        BitBlock temp24 = simd_andc(temp19, temp23);
221        BitBlock temp25 = simd_or(temp1, bit[2]);
222        BitBlock temp26 = simd_or(bit[5], temp9);
223        BitBlock temp27 = simd_and(bit[4], temp26);
224#ifdef TEMPLATED_SIMD_LIB
225        BitBlock temp28 = simd_andc(simd_const<1,1>(), temp4);
226#endif
227#ifndef TEMPLATED_SIMD_LIB
228        BitBlock temp28 = simd_andc(simd_const_1(1), temp4);
229#endif
230        BitBlock temp29 = simd_if(bit[3], temp27, temp28);
231        BitBlock temp30 = simd_andc(temp29, temp25);
232        BitBlock temp31 = simd_andc(temp24, temp30);
233        BitBlock temp32 = simd_andc(temp15, bit[6]);
234        BitBlock temp33 = simd_and(temp7, temp32);
235        BitBlock temp34 = simd_andc(temp31, temp33);
236        BitBlock temp35 = simd_andc(temp17, temp4);
237        BitBlock temp36 = simd_and(temp7, temp35);
238        BitBlock temp37 = simd_andc(temp34, temp36);
239        BitBlock temp38 = simd_and(temp8, bit[6]);
240        BitBlock temp39 = simd_and(temp14, temp38);
241        BitBlock temp40 = simd_andc(temp37, temp39);
242        BitBlock temp41 = simd_andc(bit[4], bit[5]);
243        BitBlock temp42 = simd_andc(temp41, bit[6]);
244        BitBlock temp43 = simd_and(temp21, temp42);
245        BitBlock temp44 = simd_andc(temp40, temp43);
246        BitBlock temp45 = simd_and(temp15, temp9);
247        BitBlock temp46 = simd_and(temp7, temp45);
248        BitBlock temp47 = simd_andc(temp44, temp46);
249        BitBlock temp48 = simd_and(temp21, temp15);
250        BitBlock temp49 = simd_andc(temp47, temp48);
251#ifdef TEMPLATED_SIMD_LIB
252        Control = simd_andc(simd_const<1,1>(), temp49);
253#endif
254#ifndef TEMPLATED_SIMD_LIB
255        Control = simd_andc(simd_const_1(1), temp49);
256#endif
257        BitBlock temp50 = simd_andc(bit[7], bit[6]);
258        BitBlock temp51 = simd_and(temp15, temp50);
259        BitBlock CR = simd_andc(temp51, temp3);
260        BitBlock temp52 = simd_and(temp8, temp50);
261        BitBlock LF = simd_and(temp14, temp52);
262        BitBlock HT = simd_andc(temp52, temp3);
263        BitBlock temp53 = simd_andc(bit[1], bit[0]);
264        BitBlock temp54 = simd_andc(temp53, temp2);
265        BitBlock temp55 = simd_or(bit[6], bit[7]);
266        BitBlock temp56 = simd_or(temp4, temp55);
267        BitBlock SP = simd_andc(temp54, temp56);
268        WS = simd_or(simd_or(CR, LF), simd_or(HT, SP));
269}
270
271
272
273template <CodeUnit_Base C>
274void Lexer<C>::Do_XML_10_WS_Control() {
275        BitBlock Control, WS;
276        for (int i = 0; i < buffer_blocks; i++) {
277                WS_Control_Blocks<C>(x8basis[i].bit, 
278                                     WS,
279                                     Control);
280                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
281                validation_stream[i] = simd_andc(Control, WS);
282        }
283};
284
285
286
287template <CodeUnit_Base C>
288static inline void ComputeLexicalItemBlocks(BitBlock bit[], BitBlock LexItem[]);
289
290/* Given the bit[] array of one BitBlock each for the 8 bits of
291   an ASCII-family character representation, compute the parallel
292   lexical item streams needed for XML parsing.
293
294   WARNING: the following is generated code by charset_compiler.py.
295   Do not edit.
296
297*/
298
299template <>
300static inline void ComputeLexicalItemBlocks<ASCII>(BitBlock bit[], BitBlock LexItem[]) {
301  BitBlock temp1 = simd_or(bit[0], bit[1]);
302  BitBlock temp2 = simd_and(bit[2], bit[3]);
303  BitBlock temp3 = simd_andc(temp2, temp1);
304  BitBlock temp4 = simd_and(bit[4], bit[5]);
305  BitBlock temp5 = simd_or(bit[6], bit[7]);
306  BitBlock temp6 = simd_andc(temp4, temp5);
307  BitBlock temp7 = simd_and(temp3, temp6);
308  BitBlock temp8 = simd_andc(bit[2], bit[3]);
309  BitBlock temp9 = simd_andc(temp8, temp1);
310  BitBlock temp10 = simd_andc(bit[5], bit[4]);
311  BitBlock temp11 = simd_andc(bit[6], bit[7]);
312  BitBlock temp12 = simd_and(temp10, temp11);
313  BitBlock temp13 = simd_and(temp9, temp12);
314  LexItem[MarkupStart] = simd_or(temp7, temp13);
315  BitBlock temp14 = simd_and(temp4, temp11);
316  BitBlock RAngle = simd_and(temp3, temp14);
317  BitBlock temp15 = simd_andc(bit[1], bit[0]);
318  BitBlock temp16 = simd_andc(bit[3], bit[2]);
319  BitBlock temp17 = simd_and(temp15, temp16);
320  BitBlock temp18 = simd_andc(bit[7], bit[6]);
321  BitBlock temp19 = simd_and(temp4, temp18);
322  BitBlock RBracket = simd_and(temp17, temp19);
323  LexItem[Hyphen] = simd_and(temp9, temp19);
324  BitBlock temp20 = simd_and(bit[6], bit[7]);
325  BitBlock temp21 = simd_and(temp4, temp20);
326  LexItem[QMark] = simd_and(temp3, temp21);
327  BitBlock temp22 = simd_or(bit[4], bit[5]);
328  BitBlock temp23 = simd_andc(temp11, temp22);
329  BitBlock temp24 = simd_and(temp10, temp20);
330  BitBlock temp25 = simd_or(temp23, temp24);
331  BitBlock temp26 = simd_and(temp9, temp25);
332  BitBlock temp27 = simd_or(temp26, temp7);
333  LexItem[Quote] = simd_or(temp27, temp13);
334  BitBlock temp28 = simd_and(bit[5], temp5);
335  BitBlock temp29 = simd_and(bit[4], temp28);
336  BitBlock temp30 = simd_andc(temp29, temp21);
337  BitBlock temp31 = simd_andc(temp9, temp30);
338  BitBlock temp32 = simd_and(temp3, bit[4]);
339  BitBlock temp33 = simd_or(bit[5], temp20);
340  BitBlock temp34 = simd_and(temp32, temp33);
341  BitBlock temp35 = simd_or(temp31, temp34);
342  BitBlock temp36 = simd_and(temp17, bit[4]);
343#ifdef TEMPLATED_SIMD_LIB
344  BitBlock temp37 = simd_andc(simd_const<1,1>(), temp20);
345#endif
346#ifndef TEMPLATED_SIMD_LIB
347  BitBlock temp37 = simd_andc(simd_const_1(1), temp20);
348#endif
349  BitBlock temp38 = simd_if(bit[5], temp37, temp20);
350  BitBlock temp39 = simd_and(temp36, temp38);
351  BitBlock temp40 = simd_or(temp35, temp39);
352  BitBlock temp41 = simd_and(temp15, temp2);
353  BitBlock temp42 = simd_and(temp41, bit[4]);
354  BitBlock temp43 = simd_and(temp42, temp38);
355  LexItem[NameFollow] = simd_or(temp40, temp43);
356#ifdef DIGIT_AND_HEX_ITEMS
357  BitBlock temp44 = simd_or(bit[5], bit[6]);
358  BitBlock temp45 = simd_and(bit[4], temp44);
359  BitBlock Digit = simd_andc(temp3, temp45);
360  BitBlock temp46 = simd_or(bit[2], bit[3]);
361  BitBlock temp47 = simd_andc(temp15, temp46);
362  BitBlock temp48 = simd_andc(temp47, bit[4]);
363  BitBlock temp49 = simd_if(bit[5], temp37, temp5);
364  BitBlock temp50 = simd_and(temp48, temp49);
365  BitBlock temp51 = simd_or(Digit, temp50);
366  BitBlock temp52 = simd_and(temp15, temp8);
367  BitBlock temp53 = simd_andc(temp52, bit[4]);
368  BitBlock temp54 = simd_and(temp53, temp49);
369  BitBlock Hex = simd_or(temp51, temp54);
370  LexItem[NonDigit] = simd_not(Digit);
371  LexItem[NonHex] = simd_not(Hex);
372#endif 
373        /* Mark potential occurrences of ']]>'  These are all actual
374        occurrences of ]]> as well as occurrences of ]] or ] at
375        the block end. Shifting the RBracket and RAngle streams in
376        negated forms ensures that a potential CD_End is not ruled
377        out at the block boundary. */
378        LexItem[CD_End_check] = simd_andc(RBracket, 
379                                          simd_or(sisd_sbli(simd_not(RBracket), 1),
380                                                  sisd_sbli(simd_not(RAngle), 2)));
381#ifndef OMIT_CD_End_check_In_Markup_Scan
382        LexItem[MarkupStart] = simd_or(LexItem[MarkupStart], LexItem[CD_End_check]);
383#endif
384}
385
386template <>
387static inline void ComputeLexicalItemBlocks<EBCDIC>(BitBlock bit[], BitBlock LexItem[]) {
388          BitBlock temp1 = simd_andc(bit[1], bit[0]);
389  BitBlock temp2 = simd_or(bit[2], bit[3]);
390  BitBlock temp3 = simd_andc(temp1, temp2);
391  BitBlock temp4 = simd_and(bit[4], bit[5]);
392  BitBlock temp5 = simd_or(bit[6], bit[7]);
393  BitBlock temp6 = simd_andc(temp4, temp5);
394  BitBlock temp7 = simd_and(temp3, temp6);
395  BitBlock temp8 = simd_andc(bit[3], bit[2]);
396  BitBlock temp9 = simd_and(temp1, temp8);
397  BitBlock temp10 = simd_or(bit[4], bit[5]);
398  BitBlock temp11 = simd_or(temp10, temp5);
399  BitBlock temp12 = simd_andc(temp9, temp11);
400  LexItem[MarkupStart] = simd_or(temp7, temp12);
401  BitBlock temp13 = simd_andc(bit[2], bit[3]);
402  BitBlock temp14 = simd_and(temp1, temp13);
403  BitBlock temp15 = simd_andc(bit[6], bit[7]);
404  BitBlock temp16 = simd_and(temp4, temp15);
405  BitBlock RAngle = simd_and(temp14, temp16);
406  BitBlock temp17 = simd_andc(bit[0], bit[1]);
407  BitBlock temp18 = simd_and(bit[2], bit[3]);
408  BitBlock temp19 = simd_and(temp17, temp18);
409  BitBlock temp20 = simd_andc(bit[4], bit[5]);
410  BitBlock temp21 = simd_and(bit[6], bit[7]);
411  BitBlock temp22 = simd_and(temp20, temp21);
412  BitBlock RBracket = simd_and(temp19, temp22);
413  LexItem[Hyphen] = simd_andc(temp14, temp11);
414  BitBlock temp23 = simd_and(temp4, temp21);
415  BitBlock QMark = simd_and(temp14, temp23);
416  BitBlock temp24 = simd_and(temp1, temp18);
417  BitBlock temp25 = simd_and(temp4, bit[7]);
418  BitBlock temp26 = simd_and(temp24, temp25);
419  BitBlock temp27 = simd_or(temp26, temp7);
420  LexItem[Quote] = simd_or(temp27, temp12);
421  BitBlock temp28 = simd_andc(temp3, temp11);
422  BitBlock temp29 = simd_and(temp20, temp15);
423  BitBlock temp30 = simd_and(temp9, temp29);
424  BitBlock temp31 = simd_or(temp28, temp30);
425  BitBlock temp32 = simd_and(temp24, temp23);
426  BitBlock temp33 = simd_or(temp31, temp32);
427  BitBlock temp34 = simd_and(temp24, temp22);
428  BitBlock temp35 = simd_or(temp33, temp34);
429  BitBlock temp36 = simd_and(temp9, temp22);
430  BitBlock temp37 = simd_or(temp35, temp36);
431  BitBlock temp38 = simd_and(temp14, temp6);
432  BitBlock temp39 = simd_or(temp37, temp38);
433  BitBlock temp40 = simd_or(temp39, temp12);
434  BitBlock temp41 = simd_andc(bit[7], bit[6]);
435  BitBlock temp42 = simd_and(temp4, temp41);
436  BitBlock temp43 = simd_and(temp24, temp42);
437  BitBlock temp44 = simd_or(temp40, temp43);
438  BitBlock temp45 = simd_and(temp3, temp42);
439  BitBlock temp46 = simd_or(temp44, temp45);
440  BitBlock temp47 = simd_and(temp9, temp42);
441  BitBlock temp48 = simd_or(temp46, temp47);
442  BitBlock temp49 = simd_and(temp9, temp6);
443  BitBlock temp50 = simd_or(temp48, temp49);
444  BitBlock temp51 = simd_and(temp3, temp16);
445  BitBlock temp52 = simd_or(temp50, temp51);
446  BitBlock temp53 = simd_and(temp14, temp22);
447  BitBlock temp54 = simd_or(temp52, temp53);
448  BitBlock temp55 = simd_andc(temp41, temp10);
449  BitBlock temp56 = simd_and(temp14, temp55);
450  BitBlock temp57 = simd_or(temp54, temp56);
451  BitBlock temp58 = simd_and(temp9, temp16);
452  BitBlock temp59 = simd_or(temp57, temp58);
453  BitBlock temp60 = simd_or(temp59, temp7);
454  BitBlock temp61 = simd_and(temp24, temp16);
455  BitBlock temp62 = simd_or(temp60, temp61);
456  BitBlock temp63 = simd_or(temp62, RAngle);
457  BitBlock temp64 = simd_or(temp63, QMark);
458  BitBlock temp65 = simd_and(temp19, temp29);
459  BitBlock temp66 = simd_or(temp64, temp65);
460  BitBlock temp67 = simd_and(bit[0], bit[1]);
461  BitBlock temp68 = simd_and(temp67, temp13);
462  BitBlock temp69 = simd_andc(temp68, temp11);
463  BitBlock temp70 = simd_or(temp66, temp69);
464  BitBlock temp71 = simd_or(temp70, RBracket);
465  BitBlock temp72 = simd_andc(temp19, temp11);
466  BitBlock temp73 = simd_or(temp71, temp72);
467  BitBlock temp74 = simd_andc(temp67, temp2);
468  BitBlock temp75 = simd_andc(temp74, temp11);
469  BitBlock temp76 = simd_or(temp73, temp75);
470  BitBlock temp77 = simd_and(temp3, temp23);
471  BitBlock temp78 = simd_or(temp76, temp77);
472  BitBlock temp79 = simd_and(temp67, temp8);
473  BitBlock temp80 = simd_andc(temp79, temp11);
474  BitBlock temp81 = simd_or(temp78, temp80);
475  BitBlock temp82 = simd_and(temp17, temp13);
476  BitBlock temp83 = simd_and(temp82, temp55);
477  LexItem[NameFollow] = simd_or(temp81, temp83);
478#ifdef DIGIT_AND_HEX_ITEMS
479  BitBlock temp84 = simd_and(temp67, temp18);
480  BitBlock temp85 = simd_andc(temp11, temp55);
481  BitBlock temp86 = simd_andc(temp15, temp10);
482  BitBlock temp87 = simd_andc(temp85, temp86);
483  BitBlock temp88 = simd_andc(temp21, temp10);
484  BitBlock temp89 = simd_andc(temp87, temp88);
485  BitBlock temp90 = simd_andc(bit[5], bit[4]);
486  BitBlock temp91 = simd_andc(temp90, temp5);
487  BitBlock temp92 = simd_andc(temp89, temp91);
488  BitBlock temp93 = simd_and(temp90, temp41);
489  BitBlock temp94 = simd_andc(temp92, temp93);
490  BitBlock temp95 = simd_and(temp90, temp15);
491  BitBlock temp96 = simd_andc(temp94, temp95);
492  BitBlock temp97 = simd_and(temp90, temp21);
493  BitBlock temp98 = simd_andc(temp96, temp97);
494  BitBlock temp99 = simd_andc(temp20, temp5);
495  BitBlock temp100 = simd_andc(temp98, temp99);
496  BitBlock temp101 = simd_and(temp20, temp41);
497  BitBlock temp102 = simd_andc(temp100, temp101);
498  BitBlock Digit = simd_andc(temp84, temp102);
499  BitBlock temp103 = simd_and(temp74, temp55);
500  BitBlock temp104 = simd_or(Digit, temp103);
501  BitBlock temp105 = simd_and(temp74, temp86);
502  BitBlock temp106 = simd_or(temp104, temp105);
503  BitBlock temp107 = simd_and(temp74, temp88);
504  BitBlock temp108 = simd_or(temp106, temp107);
505  BitBlock temp109 = simd_and(temp74, temp91);
506  BitBlock temp110 = simd_or(temp108, temp109);
507  BitBlock temp111 = simd_and(temp74, temp93);
508  BitBlock temp112 = simd_or(temp110, temp111);
509  BitBlock temp113 = simd_and(temp74, temp95);
510  BitBlock temp114 = simd_or(temp112, temp113);
511  BitBlock temp115 = simd_andc(temp17, temp2);
512  BitBlock temp116 = simd_and(temp115, temp55);
513  BitBlock temp117 = simd_or(temp114, temp116);
514  BitBlock temp118 = simd_and(temp115, temp86);
515  BitBlock temp119 = simd_or(temp117, temp118);
516  BitBlock temp120 = simd_and(temp115, temp88);
517  BitBlock temp121 = simd_or(temp119, temp120);
518  BitBlock temp122 = simd_and(temp115, temp91);
519  BitBlock temp123 = simd_or(temp121, temp122);
520  BitBlock temp124 = simd_and(temp115, temp93);
521  BitBlock temp125 = simd_or(temp123, temp124);
522  BitBlock temp126 = simd_and(temp115, temp95);
523  BitBlock Hex = simd_or(temp125, temp126);
524       
525  LexItem[NonDigit] = simd_not(Digit);
526  LexItem[NonHex] = simd_not(Hex);
527
528#endif 
529       
530        /* Mark potential occurrences of ']]>'  These are all actual
531        occurrences of ]]> as well as occurrences of ]] or ] at
532        the block end. Shifting the RBracket and RAngle streams in
533        negated forms ensures that a potential CD_End is not ruled
534        out at the block boundary. */
535        LexItem[CD_End_check] = simd_andc(RBracket, 
536                                          simd_or(sisd_sbli(simd_not(RBracket), 1),
537                                                  sisd_sbli(simd_not(RAngle), 2)));
538#ifndef OMIT_CD_End_check_In_Markup_Scan
539        LexItem[MarkupStart] = simd_or(LexItem[MarkupStart], LexItem[CD_End_check]);
540#endif
541}
542
543
544/* A temporary structure for internal use in ComputeLexicalItemStreams. */
545typedef struct {
546        BitBlock LexicalItems[LexicalItemCount];
547} LexicalItemBlock;
548
549
550
551
552template <CodeUnit_Base C>
553void Lexer<C>::Do_MarkupStreams() {
554        LexicalItemBlock lx_blk[BUFFER_BLOCKS];
555        for (int i = 0; i < buffer_blocks; i++) {
556                ComputeLexicalItemBlocks<C>(x8basis[i].bit, lx_blk[i].LexicalItems);
557        }
558        /* NonWS stream already completed by WS_Control method. */
559        for (int j = MarkupStart; j < LexicalItemCount; j++) {
560                for (int i = 0; i < buffer_blocks; i++) {
561                        parsing_engine_data->item_stream[j][i] = lx_blk[i].LexicalItems[j];
562                }
563        }
564        for (int i = 0; i < buffer_blocks; i++) {
565                parsing_engine_data->item_stream[NameFollow][i] = 
566                        simd_or(parsing_engine_data->item_stream[NameFollow][i],
567                                simd_not(parsing_engine_data->item_stream[NonWS][i]));
568        }
569};
570
571
572void UTF_8_Lexer::Do_CharsetValidation() {
573        BitBlock u8prefix, u8suffix, u8prefix2, u8prefix3or4, u8prefix3, u8prefix4;
574        BitBlock error_mask;
575        /*  UTF-8 sequences may cross block boundaries.  If a
576            prefix is found near the end of a block that requires
577            one or more suffixes in the next block, then
578            prefix_pending is set to mark the positions.
579            However, at the beginning of the buffer, no suffixes
580            are expected, so this value is initialized to zeroes. */
581#ifdef TEMPLATED_SIMD_LIB
582        BitBlock prefix_pending = simd_const<1,0>();
583        /*  If a suffix is pending, then it may involve one of
584            the special case prefixes E0, ED. F0, F4, or the
585            EF prefix or EF_BF combination for FFFF/FFFE detection.*/
586        BitBlock E0ED_pending = simd_const<1,0>();
587        BitBlock F0F4_pending = simd_const<1,0>();
588        BitBlock bit5_pending = simd_const<1,0>();
589        BitBlock EF_pending = simd_const<1,0>();
590        BitBlock EF_BF_pending = simd_const<1,0>();
591#endif
592#ifndef TEMPLATED_SIMD_LIB
593        BitBlock prefix_pending = simd_const_1(0);
594        /*  If a suffix is pending, then it may involve one of
595            the special case prefixes E0, ED. F0, F4, or the
596            EF prefix or EF_BF combination for FFFF/FFFE detection.*/
597        BitBlock E0ED_pending = simd_const_1(0);
598        BitBlock F0F4_pending = simd_const_1(0);
599        BitBlock bit5_pending = simd_const_1(0);
600        BitBlock EF_pending = simd_const_1(0);
601        BitBlock EF_BF_pending = simd_const_1(0);
602#endif
603        /* Temporary variables used within the block. */
604        BitBlock suffix_required_scope;
605        BitBlock prefix_E0ED, E0ED_scope, bit5_scope, E0ED_constraint; 
606        BitBlock prefix_F5FF, prefix_F0F4, F0F4_scope, F0F4_constraint; 
607        BitBlock X111x, B111x, prefix_EF, BF, EF_BF, EF_scope, EF_BF_scope;
608
609        for (int i = 0; i < buffer_blocks; i++) {
610#ifdef TEMPLATED_SIMD_LIB
611                validation_stream[i] = simd_const<1,0>();
612#endif
613#ifndef TEMPLATED_SIMD_LIB
614                validation_stream[i] = simd_const_1(0);
615#endif
616                /* If there is no pending suffix and no bit 0, then there
617                   are no possible validation issues for this block. */
618                if (!bitblock_has_bit(simd_or(prefix_pending, x8basis[i].bit[0])))
619                        continue;
620                /*  Compute classifications of UTF-8 bytes. */
621                u8prefix = simd_and(x8basis[i].bit[0], x8basis[i].bit[1]);
622                u8suffix = simd_andc(x8basis[i].bit[0], x8basis[i].bit[1]);
623                u8prefix3or4 = simd_and(u8prefix, x8basis[i].bit[2]);
624                u8prefix2 = simd_andc(u8prefix, x8basis[i].bit[2]);
625                u8prefix3 = simd_andc(u8prefix3or4, x8basis[i].bit[3]);
626                u8prefix4 = simd_and(u8prefix3or4, x8basis[i].bit[3]);
627
628                /*  Initiate validation for two-byte sequences. */
629                error_mask = simd_andc(u8prefix2, 
630                                        simd_or(simd_or(x8basis[i].bit[3], x8basis[i].bit[4]),
631                                                simd_or(x8basis[i].bit[5], x8basis[i].bit[6])));
632                suffix_required_scope = simd_or(prefix_pending, sisd_sfli(u8prefix, 1));
633
634                prefix_pending = sisd_sbli(u8prefix, BLOCKSIZE - 1);
635                E0ED_scope = E0ED_pending;
636                F0F4_scope = F0F4_pending;
637                bit5_scope = bit5_pending;
638                EF_scope = EF_pending;
639                EF_BF_scope = EF_BF_pending;
640
641                /* Default values of pending variables for next iteration. */
642#ifdef TEMPLATED_SIMD_LIB
643                E0ED_pending = simd_const<1,0>();
644                F0F4_pending = simd_const<1,0>();
645                bit5_pending = simd_const<1,0>();
646                EF_pending = simd_const<1,0>();
647                EF_BF_pending = simd_const<1,0>();
648#endif
649#ifndef TEMPLATED_SIMD_LIB
650                E0ED_pending = simd_const_1(0);
651                F0F4_pending = simd_const_1(0);
652                bit5_pending = simd_const_1(0);
653                EF_pending = simd_const_1(0);
654                EF_BF_pending = simd_const_1(0);
655#endif
656
657                X111x = simd_and(simd_and(x8basis[i].bit[4], x8basis[i].bit[5]), x8basis[i].bit[6]);
658                B111x = simd_and(simd_and(u8suffix, simd_and(x8basis[i].bit[2], x8basis[i].bit[3])),
659                                 X111x);
660                BF = simd_and(B111x, x8basis[i].bit[7]);
661                EF_BF = simd_and(EF_scope, BF);
662
663                if (bitblock_has_bit(u8prefix3or4)) {
664                        /*  Extend validation for errors in three-byte sequences. */
665                        suffix_required_scope = simd_or(suffix_required_scope, 
666                                                        sisd_sfli(u8prefix3or4, 2));
667                        bit5_scope = simd_or(bit5_scope, sisd_sfli(x8basis[i].bit[5], 1));
668                        prefix_E0ED = simd_andc(u8prefix3,
669                                                simd_or(simd_or(x8basis[i].bit[6], 
670                                                                simd_xor(x8basis[i].bit[4], x8basis[i].bit[7])),
671                                                        simd_xor(x8basis[i].bit[4], x8basis[i].bit[5])));
672                        E0ED_scope = simd_or(E0ED_scope, sisd_sfli(prefix_E0ED, 1));
673                        prefix_EF = simd_and(u8prefix3, simd_and(X111x, x8basis[i].bit[7]));
674                        EF_scope = simd_or(EF_scope, sisd_sfli(prefix_EF, 1));
675                        EF_BF = simd_and(EF_scope, BF);
676
677                        /* Values for next iteration. */
678                        prefix_pending = simd_or(prefix_pending,
679                                                 sisd_sbli(u8prefix3or4, BLOCKSIZE - 2));
680                        bit5_pending = sisd_sbli(x8basis[i].bit[5], BLOCKSIZE - 1); 
681                        E0ED_pending = sisd_sbli(prefix_E0ED, BLOCKSIZE - 1); 
682                        EF_pending = sisd_sbli(prefix_EF, BLOCKSIZE - 1);
683                        EF_BF_pending = sisd_sbli(EF_BF, BLOCKSIZE - 2);
684                        if (bitblock_has_bit(u8prefix4)) {
685                                /*  Extend validation for errors in four-byte sequences. */
686                                suffix_required_scope = simd_or(suffix_required_scope, 
687                                                                sisd_sfli(u8prefix4, 3));
688                                prefix_pending = simd_or(prefix_pending,
689                                                         sisd_sbli(u8prefix4, BLOCKSIZE - 3));
690                                prefix_F5FF = simd_and(u8prefix4, 
691                                                       simd_or(x8basis[i].bit[4],
692                                                                simd_and(x8basis[i].bit[5],
693                                                                        simd_or(x8basis[i].bit[6], x8basis[i].bit[7]))));
694                                error_mask = simd_or(error_mask, prefix_F5FF);
695                                prefix_F0F4 = simd_andc(u8prefix4, 
696                                                        simd_or(x8basis[i].bit[4], 
697                                                                simd_or(x8basis[i].bit[6], x8basis[i].bit[7])));
698                                F0F4_scope = simd_or(F0F4_scope, sisd_sfli(prefix_F0F4, 1));
699                                F0F4_pending = sisd_sbli(prefix_F0F4, BLOCKSIZE - 1);
700                        }
701                }
702                E0ED_constraint = simd_xor(bit5_scope, x8basis[i].bit[2]);
703                error_mask = simd_or(error_mask, simd_andc(E0ED_scope, E0ED_constraint));
704                F0F4_constraint = simd_xor(bit5_scope, 
705                                           simd_or(x8basis[i].bit[2], x8basis[i].bit[3]));
706                error_mask = simd_or(error_mask, simd_andc(F0F4_scope, F0F4_constraint));
707                /*  Complete validation by checking for prefix-suffix mismatches. */
708                error_mask = simd_or(error_mask, simd_xor(suffix_required_scope, u8suffix));
709
710                EF_BF_scope = simd_or(EF_BF_scope, sisd_sfli(EF_BF, 1));
711                error_mask = simd_or(error_mask, simd_and(EF_BF_scope, B111x));
712                validation_stream[i] = error_mask;
713#ifdef DEBUG_UTF8_VALIDATION
714//              if (bitblock_has_bit(error_mask)) {
715printf("-%i----------------------\n", i);
716print_bit_block("x8basis[i].bit[0]", x8basis[i].bit[0]);
717print_bit_block("x8basis[i].bit[1]", x8basis[i].bit[1]);
718print_bit_block("x8basis[i].bit[2]", x8basis[i].bit[2]);
719print_bit_block("x8basis[i].bit[3]", x8basis[i].bit[3]);
720        print_bit_block("u8prefix2", u8prefix2);
721        print_bit_block("u8prefix3", u8prefix3);
722        print_bit_block("u8prefix4", u8prefix4);
723        print_bit_block("suffix_required_scope", suffix_required_scope);
724        print_bit_block("prefix_pending", prefix_pending);
725        print_bit_block("E0ED_pending", E0ED_pending);
726        print_bit_block("F0F4_pending", F0F4_pending);
727        print_bit_block("bit5_pending", bit5_pending);
728                print_bit_block("error_mask", error_mask);
729
730//}
731#endif
732        }
733};
734
735
736void ASCII_7_Lexer::Do_CharsetValidation() {
737        for (int blk = 0; blk < buffer_blocks; blk++) {
738                validation_stream[blk] = x8basis[blk].bit[0];
739        }
740};
741
742
743void EASCII_8_Lexer::Do_CharsetValidation() {
744        /* Nothing required for most charsets - but perhaps should have tables. */
745        for (int i = 0; i < buffer_blocks; i++) {
746#ifdef TEMPLATED_SIMD_LIB
747                validation_stream[i] = simd_const<1,0>();
748#endif
749#ifndef TEMPLATED_SIMD_LIB
750                validation_stream[i] = simd_const_1(0);
751#endif
752        }
753};
754
755
756void UTF_16_Lexer::Do_CharsetValidation() {
757};
758
759
760void UCS_2_Lexer::Do_CharsetValidation() {
761};
762
763
764void UTF_32_Lexer::Do_CharsetValidation() {
765};
766
767
768void EBCDIC_Lexer::Do_CharsetValidation() {
769        /* Nothing required for most cases - but perhaps should have tables. */
770        for (int i = 0; i < buffer_blocks; i++) {
771#ifdef TEMPLATED_SIMD_LIB
772                validation_stream[i] = simd_const<1,0>();
773#endif
774#ifndef TEMPLATED_SIMD_LIB
775                validation_stream[i] = simd_const_1(0);
776#endif
777        }
778}
779
780
781
782/* Stub out XML 1.1 routines initially. */
783
784void UTF_8_Lexer::Do_XML_11_WS_Control() {
785        printf("UTF_8_Lexer::Do_XML_11_WS_Control not yet implemented; using XML 1.0 rules.\n");
786        Do_XML_10_WS_Control();
787};
788
789
790static inline void ASCII_7_WS_Control_Blocks_11(BitBlock bit[], BitBlock& WS, BitBlock& Control) {
791        BitBlock temp1 = simd_or(bit[0], bit[1]);
792        BitBlock temp2 = simd_or(temp1, bit[2]);
793        BitBlock temp3 = simd_andc(bit[1], bit[0]);
794        BitBlock temp4 = simd_and(bit[2], bit[3]);
795        BitBlock temp5 = simd_and(temp3, temp4);
796        BitBlock temp6 = simd_and(bit[4], bit[5]);
797        BitBlock temp7 = simd_and(bit[6], bit[7]);
798        BitBlock temp8 = simd_and(temp6, temp7);
799        BitBlock temp9 = simd_and(temp5, temp8);
800        BitBlock temp10 = simd_andc(temp2, temp9);
801        BitBlock temp11 = simd_andc(temp10, bit[0]);
802#ifdef TEMPLATED_SIMD_LIB
803        Control = simd_andc(simd_const<1,1>(), temp11);
804#endif
805#ifndef TEMPLATED_SIMD_LIB
806        Control = simd_andc(simd_const_1(1), temp11);
807#endif
808        BitBlock temp12 = simd_or(bit[2], bit[3]);
809        BitBlock temp13 = simd_or(temp1, temp12);
810        BitBlock temp14 = simd_andc(bit[7], bit[6]);
811        BitBlock temp15 = simd_and(temp6, temp14);
812        BitBlock CR = simd_andc(temp15, temp13);
813        BitBlock temp16 = simd_andc(bit[4], bit[5]);
814        BitBlock temp17 = simd_andc(bit[6], bit[7]);
815        BitBlock temp18 = simd_and(temp16, temp17);
816        BitBlock LF = simd_andc(temp18, temp13);
817        BitBlock temp19 = simd_and(temp16, temp14);
818        BitBlock HT = simd_andc(temp19, temp13);
819        BitBlock temp20 = simd_andc(bit[2], bit[3]);
820        BitBlock temp21 = simd_andc(temp20, temp1);
821        BitBlock temp22 = simd_or(bit[4], bit[5]);
822        BitBlock temp23 = simd_or(bit[6], bit[7]);
823        BitBlock temp24 = simd_or(temp22, temp23);
824        BitBlock SP = simd_andc(temp21, temp24);
825        WS = simd_or(simd_or(CR, LF), simd_or(HT, SP));
826}
827
828
829void ASCII_7_Lexer::Do_XML_11_WS_Control() {
830        BitBlock WS, Control;
831        for (int i = 0; i < buffer_blocks; i++) {
832                ASCII_7_WS_Control_Blocks_11(x8basis[i].bit, WS, Control);
833                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
834                validation_stream[i] = simd_andc(Control, WS);
835        }
836};
837
838static inline void EASCII_8_WS_Control_Blocks_11(BitBlock bit[], BitBlock& WS, BitBlock& Control) {
839        BitBlock temp1 = simd_or(bit[0], bit[1]);
840        BitBlock temp2 = simd_or(temp1, bit[2]);
841        BitBlock temp3 = simd_andc(bit[1], bit[0]);
842        BitBlock temp4 = simd_and(bit[2], bit[3]);
843        BitBlock temp5 = simd_and(temp3, temp4);
844        BitBlock temp6 = simd_and(bit[4], bit[5]);
845        BitBlock temp7 = simd_and(bit[6], bit[7]);
846        BitBlock temp8 = simd_and(temp6, temp7);
847        BitBlock temp9 = simd_and(temp5, temp8);
848        BitBlock temp10 = simd_andc(temp2, temp9);
849        BitBlock temp11 = simd_andc(bit[0], bit[1]);
850        BitBlock temp12 = simd_andc(temp11, bit[2]);
851        BitBlock temp13 = simd_andc(temp10, temp12);
852#ifdef TEMPLATED_SIMD_LIB
853        Control = simd_andc(simd_const<1,1>(), temp13);
854#endif
855#ifndef TEMPLATED_SIMD_LIB
856        Control = simd_andc(simd_const_1(1), temp13);
857#endif
858        BitBlock temp14 = simd_or(bit[2], bit[3]);
859        BitBlock temp15 = simd_or(temp1, temp14);
860        BitBlock temp16 = simd_andc(bit[7], bit[6]);
861        BitBlock temp17 = simd_and(temp6, temp16);
862        BitBlock CR = simd_andc(temp17, temp15);
863        BitBlock temp18 = simd_andc(bit[4], bit[5]);
864        BitBlock temp19 = simd_andc(bit[6], bit[7]);
865        BitBlock temp20 = simd_and(temp18, temp19);
866        BitBlock LF = simd_andc(temp20, temp15);
867        BitBlock temp21 = simd_and(temp18, temp16);
868        BitBlock HT = simd_andc(temp21, temp15);
869        BitBlock temp22 = simd_andc(bit[2], bit[3]);
870        BitBlock temp23 = simd_andc(temp22, temp1);
871        BitBlock temp24 = simd_or(bit[4], bit[5]);
872        BitBlock temp25 = simd_or(bit[6], bit[7]);
873        BitBlock temp26 = simd_or(temp24, temp25);
874        BitBlock SP = simd_andc(temp23, temp26);
875        BitBlock temp27 = simd_andc(temp11, temp14);
876        BitBlock temp28 = simd_andc(bit[5], bit[4]);
877        BitBlock temp29 = simd_and(temp28, temp16);
878        BitBlock NEL = simd_and(temp27, temp29);
879        WS = simd_or(simd_or(simd_or(CR, LF), simd_or(HT, SP)), NEL);
880}
881
882void EASCII_8_Lexer::Do_XML_11_WS_Control() {
883        BitBlock WS, Control;
884        for (int i = 0; i < buffer_blocks; i++) {
885                EASCII_8_WS_Control_Blocks_11(x8basis[i].bit, WS, Control);
886                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
887                validation_stream[i] = simd_andc(Control, WS);
888        }
889};
890
891
892void U16_Lexer::Do_XML_11_WS_Control() {
893        printf("U16_Lexer::Do_XML_11_WS_Control not yet implemented; using XML 1.0 rules.\n");
894        Do_XML_10_WS_Control();
895};
896
897
898void UTF_32_Lexer::Do_XML_11_WS_Control() {
899        printf("UTF_32_Lexer::Do_XML_11_WS_Control not yet implemented; using XML 1.0 rules.\n");
900        Do_XML_10_WS_Control();
901};
902
903static inline void EBCDIC_WS_Control_Blocks_11(BitBlock bit[], BitBlock& WS, BitBlock& Control) {
904        BitBlock temp1 = simd_or(bit[0], bit[1]);
905        BitBlock temp2 = simd_and(bit[0], bit[1]);
906        BitBlock temp3 = simd_and(bit[2], bit[3]);
907        BitBlock temp4 = simd_and(temp2, temp3);
908        BitBlock temp5 = simd_and(bit[4], bit[5]);
909        BitBlock temp6 = simd_and(bit[6], bit[7]);
910        BitBlock temp7 = simd_and(temp5, temp6);
911        BitBlock temp8 = simd_and(temp4, temp7);
912        BitBlock temp9 = simd_andc(temp1, temp8);
913#ifdef TEMPLATED_SIMD_LIB
914        Control = simd_andc(simd_const<1,1>(), temp9);
915#endif
916#ifndef TEMPLATED_SIMD_LIB
917        Control = simd_andc(simd_const_1(1), temp9);
918#endif
919        BitBlock temp10 = simd_or(bit[2], bit[3]);
920        BitBlock temp11 = simd_or(temp1, temp10);
921        BitBlock temp12 = simd_andc(bit[7], bit[6]);
922        BitBlock temp13 = simd_and(temp5, temp12);
923        BitBlock CR = simd_andc(temp13, temp11);
924        BitBlock temp14 = simd_andc(bit[2], bit[3]);
925        BitBlock temp15 = simd_andc(temp14, temp1);
926        BitBlock temp16 = simd_andc(bit[5], bit[4]);
927        BitBlock temp17 = simd_and(temp16, temp12);
928        BitBlock LF = simd_and(temp15, temp17);
929        BitBlock HT = simd_andc(temp17, temp11);
930        BitBlock temp18 = simd_andc(bit[1], bit[0]);
931        BitBlock temp19 = simd_andc(temp18, temp10);
932        BitBlock temp20 = simd_or(bit[4], bit[5]);
933        BitBlock temp21 = simd_or(bit[6], bit[7]);
934        BitBlock temp22 = simd_or(temp20, temp21);
935        BitBlock SP = simd_andc(temp19, temp22);
936        BitBlock temp23 = simd_andc(bit[3], bit[2]);
937        BitBlock temp24 = simd_andc(temp23, temp1);
938        BitBlock NEL = simd_and(temp24, temp17);
939        WS = simd_or(simd_or(simd_or(CR, LF), simd_or(HT, SP)), NEL);
940}
941
942void EBCDIC_Lexer::Do_XML_11_WS_Control() {
943        BitBlock WS, Control;
944        for (int i = 0; i < buffer_blocks; i++) {
945                EBCDIC_WS_Control_Blocks_11(x8basis[i].bit, WS, Control);
946                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
947                validation_stream[i] = simd_andc(Control, WS);
948        }
949};
950
951
952
953void Lexer_Interface::AnalyzeBuffer(BitBlockBasis * basis, int base_pos, int start_pos, int buffer_limit_pos) {
954#ifdef DEBUG
955        printf("Entered AnalyzeBuffer, buffer_limit_pos = %i\n", buffer_limit_pos);
956#endif
957#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == BITLEX_ALL)
958        code_clocker->cc_start_interval();
959#endif
960        x8basis = basis;
961        lexer_base_pos = base_pos; /* for error reporting. */
962        int err_pos;
963        buffer_blocks = (buffer_limit_pos + BLOCKSIZE - 1)/BLOCKSIZE;
964        buffer_units = buffer_limit_pos;
965#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == CHARSET_VALIDATION)
966        code_clocker->cc_start_interval();
967#endif
968
969        Do_CharsetValidation();
970        /* Ignore error bits before start_pos which only arise
971           due to UTF8 pending scope streams at buffer boundaries.*/
972        err_pos = bitstream_scan(validation_stream, start_pos);
973        /* Detect validation errors up to the end of file plus one more
974           position in case there is an incomplete code unit at EOF. */
975        if ((err_pos <= buffer_units) && (err_pos < BUFFER_SIZE)) {
976//              printf("start_pos =%i\n, err_pos = %i\n", start_pos, err_pos);
977//              print_bit_block("validation_stream[0]", validation_stream[0]);
978
979//              print_bit_block("validation_stream[err_pos/128]", validation_stream[err_pos/128]);
980
981                CharSetValidationError((char *) entity_Info->encoding, lexer_base_pos + err_pos);
982        }
983#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == CHARSET_VALIDATION)
984                code_clocker->cc_end_interval(buffer_units);
985#endif
986#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == WS_CONTROL)
987        code_clocker->cc_start_interval();
988#endif
989
990        if (entity_Info->version == XML_1_1) Do_XML_11_WS_Control();
991        else Do_XML_10_WS_Control();
992#ifdef DEBUG
993        printf("Do_WS_Control() complete.\n");
994#endif
995        err_pos = bitstream_scan0(validation_stream);
996        if (err_pos < buffer_units) XMLCharacterError(lexer_base_pos + err_pos);
997#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == WS_CONTROL)
998        code_clocker->cc_end_interval(buffer_units);
999#endif
1000#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == MARKUP_STREAMS)
1001        code_clocker->cc_start_interval();
1002#endif
1003        Do_MarkupStreams();
1004#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == MARKUP_STREAMS)
1005        code_clocker->cc_end_interval(buffer_units);
1006#endif
1007#ifdef DEBUG
1008        printf("Do_MarkupStreams() complete.\n");
1009#endif
1010
1011        if (buffer_units < BUFFER_SIZE) {
1012#ifdef TEMPLATED_SIMD_LIB
1013                BitBlock final_block_mask = 
1014                        sisd_sfl(simd_const<1,1>(), sisd_from_int(buffer_units % BLOCKSIZE));
1015#endif
1016#ifndef TEMPLATED_SIMD_LIB
1017                BitBlock final_block_mask = 
1018                        sisd_sfl(simd_const_1(1), sisd_from_int(buffer_units % BLOCKSIZE));
1019#endif
1020                int lastblk = buffer_units/BLOCKSIZE;
1021                for (int j = minLexicalItem; j < LexicalItemCount; j++) {
1022                        parsing_engine_data->item_stream[j][lastblk] =
1023                                simd_or(parsing_engine_data->item_stream[j][lastblk],
1024                                        final_block_mask);
1025                }
1026        }
1027#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == BITLEX_ALL)
1028                code_clocker->cc_end_interval(buffer_units);
1029#endif
1030
1031}
1032
Note: See TracBrowser for help on using the repository browser.