source: trunk/src/bitlex.c @ 40

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

fixes

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