source: trunk/src/bitlex.c @ 130

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

Add FFFF/FFFE detection to UTF-8 validation.

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