source: trunk/src/bitlex.c @ 36

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

Charset Architecture: Lexer Factory/bit streams

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