Changeset 36 for trunk/src/bitlex.c


Ignore:
Timestamp:
Feb 10, 2008, 6:12:06 AM (11 years ago)
Author:
cameron
Message:

Charset Architecture: Lexer Factory/bit streams

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/bitlex.c

    r15 r36  
    99    found in the charsets directory.
    1010*/
     11
    1112#include "bitlex.h"
    1213
    13 #include "transpose.h"
    14 
    15 #include "stdlib.h"
    16 
    17 Lexer::Lexer(XML_Buffer *b, ParallelStreamSet *p) {
    18   xml_buf = b;
    19   if (posix_memalign((void **) &bit_group, sizeof(BitBlock), sizeof(BitBlockGroup)) != 0) {
    20     printf("Allocation failure for local BitBlockGroup in Lexer\n");
    21     exit(-1);
    22   }
    23   for (int i = 0; i < 8; i++) (*bit_group)[0].bit[i] = simd_const_1(0);
    24   parsing_engine_data = p;
    25 };
     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[]);
    26330
    27331/* Given the bit[] array of one BitBlock each for the 8 bits of
     
    33337
    34338*/
    35 static inline void ComputeLexicalItemBlocks(BitBlock bit[], BitBlock LexItem[]) {
    36   BitBlock temp1 = simd_or(bit[0], bit[1]);
    37   BitBlock temp2 = simd_andc(bit[2], bit[3]);
    38   BitBlock temp3 = simd_andc(temp2, temp1);
    39   BitBlock temp4 = simd_andc(bit[5], bit[4]);
    40   BitBlock temp5 = simd_andc(bit[6], bit[7]);
    41   BitBlock temp6 = simd_and(temp4, temp5);
    42   BitBlock RefStart = simd_and(temp3, temp6);
    43   BitBlock temp7 = simd_and(bit[2], bit[3]);
    44   BitBlock temp8 = simd_andc(temp7, temp1);
    45   BitBlock temp9 = simd_andc(bit[4], bit[5]);
    46   BitBlock temp10 = simd_and(bit[6], bit[7]);
    47   BitBlock temp11 = simd_and(temp9, temp10);
    48   BitBlock Semicolon = simd_and(temp8, temp11);
    49   BitBlock temp12 = simd_and(bit[4], bit[5]);
    50   BitBlock temp13 = simd_or(bit[6], bit[7]);
    51   BitBlock temp14 = simd_andc(temp12, temp13);
    52   BitBlock LAngle = simd_and(temp8, temp14);
    53   BitBlock temp15 = simd_and(temp12, temp5);
    54   BitBlock RAngle = simd_and(temp8, temp15);
    55   BitBlock temp16 = simd_andc(bit[1], bit[0]);
    56   BitBlock temp17 = simd_andc(bit[3], bit[2]);
    57   BitBlock temp18 = simd_and(temp16, temp17);
    58   BitBlock temp19 = simd_andc(bit[7], bit[6]);
    59   BitBlock temp20 = simd_and(temp12, temp19);
    60   BitBlock RBracket = simd_and(temp18, temp20);
    61   LexItem[Hyphen] = simd_and(temp3, temp20);
    62   BitBlock temp21 = simd_and(temp12, temp10);
    63   LexItem[QMark] = simd_and(temp8, temp21);
    64   BitBlock Equals = simd_and(temp8, temp20);
    65   BitBlock temp22 = simd_and(temp4, temp10);
    66   LexItem[SQuote] = simd_and(temp3, temp22);
    67   BitBlock temp23 = simd_or(bit[4], bit[5]);
    68   BitBlock temp24 = simd_andc(temp5, temp23);
    69   LexItem[DQuote] = simd_and(temp3, temp24);
    70   BitBlock temp25 = simd_or(temp1, bit[2]);
    71   BitBlock Control = simd_andc(simd_const_1(1), temp25);
    72   BitBlock temp26 = simd_or(temp23, temp13);
    73   BitBlock temp27 = simd_andc(temp3, temp26);
    74   BitBlock temp28 = simd_or(bit[2], bit[3]);
    75   BitBlock temp29 = simd_or(temp1, temp28);
    76   BitBlock temp30 = simd_andc(temp20, temp29);
    77   BitBlock temp31 = simd_or(temp27, temp30);
    78   BitBlock temp32 = simd_and(temp9, temp19);
    79   BitBlock temp33 = simd_andc(temp32, temp29);
    80   BitBlock temp34 = simd_or(temp31, temp33);
    81   BitBlock temp35 = simd_and(temp9, temp5);
    82   BitBlock temp36 = simd_andc(temp35, temp29);
    83   BitBlock WhiteSpace = simd_or(temp34, temp36);
    84   BitBlock Slash = simd_and(temp3, temp21);
    85   BitBlock AttScan = simd_or(LAngle, RefStart);
    86   LexItem[SQuote] = simd_or(LexItem[SQuote], AttScan);
    87   LexItem[DQuote] = simd_or(LexItem[DQuote], AttScan);
    88 
    89   /* Mark potential occurrences of ']]>'  These are all actual
    90      occurrences of ]]> as well as occurrences of ]] or ] at
    91      the block end. Shifting the RBracket and RAngle streams in
    92      negated forms ensures that a potential CD_End is not ruled
    93      out at the block boundary. */
    94   LexItem[CD_End_check] = simd_andc(RBracket,
    95                                 simd_or(simd_sbli_64(simd_not(RBracket), 1),
    96                                         simd_sbli_64(simd_not(RAngle), 2)));
    97 #ifdef OMIT_CD_End_check_In_Markup_Scan
    98 LexItem[MarkupStart] = simd_or(LAngle, RefStart);
    99 #endif
     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)));
    100392#ifndef OMIT_CD_End_check_In_Markup_Scan
    101   LexItem[MarkupStart] = simd_or(simd_or(LAngle, RefStart), LexItem[CD_End_check]);
    102 #endif
    103   LexItem[NonWS] = simd_not(WhiteSpace);
    104   LexItem[NameFollow] = simd_or(simd_or(simd_or(WhiteSpace, Semicolon),
    105                                         simd_or(Slash, RAngle)),
    106                                 simd_or(Equals, LexItem[QMark]));
     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
    107452}
    108453
     
    110455/* A temporary structure for internal use in ComputeLexicalItemStreams. */
    111456typedef struct {
    112   BitBlock LexicalItems[LexicalItemCount];
     457        BitBlock LexicalItems[LexicalItemCount];
    113458} LexicalItemBlock;
    114459
    115460
    116 void Lexer::ComputeLexicalItemStreams(int new_blocks) {
    117   LexicalItemBlock lx_blk[BUFFER_BLOCKS];
    118   for (int i = 0; i < new_blocks; i++) {
    119     s2p_bytepack(&(parsing_engine_data->x8data[i * 8]), (*bit_group)[i+1].bit);
    120     ComputeLexicalItemBlocks((*bit_group)[i+1].bit, lx_blk[i].LexicalItems);
    121   }
     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        }
    122469#ifdef BUFFER_PROFILING
    123   end_BOM_interval(bitstream_timer);
    124   start_BOM_interval(lextranspose_timer);
    125 #endif
    126   for (int j = MarkupStart; j < LexicalItemCount; j++) {
    127     for (int i = 0; i < BUFFER_BLOCKS; i++) {
    128       parsing_engine_data->item_stream[j][i] = lx_blk[i].LexicalItems[j];
    129     }
    130   }
     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        }
    131483#ifdef BUFFER_PROFILING
    132   end_BOM_interval(lextranspose_timer);
    133   start_BOM_interval(scanner_timer);
    134 #endif
    135 }
    136 
    137 
    138 void Lexer::EstablishSentinels(int code_units) {
    139   if (code_units < BUFFER_BLOCKS * BLOCKSIZE + LOOKAHEAD_POSITIONS) {
    140     ((unsigned char *) parsing_engine_data->x8data)[code_units] = '\0';
    141     if (code_units < BUFFER_BLOCKS * BLOCKSIZE) {
    142       BitBlock bitstream_sentinel =
    143         sisd_sfl(simd_const_1(1), sisd_from_int(code_units % BLOCKSIZE));
    144       int lastblk = code_units/BLOCKSIZE;
    145       for (int j = MarkupStart; j < LexicalItemCount; j++) {
    146         parsing_engine_data->item_stream[j][lastblk] =
    147           simd_or(parsing_engine_data->item_stream[j][lastblk], bitstream_sentinel);
    148       }
    149     }
    150   }
    151 }
     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 TracChangeset for help on using the changeset viewer.