Changeset 36


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

Charset Architecture: Lexer Factory/bit streams

Location:
trunk/src
Files:
3 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
  • trunk/src/bitlex.h

    r15 r36  
    1 /*  bitlex.h - parabix lexical analysis
    2     Copyright (c) 2007, Robert D. Cameron.
     1/*  bitlex.h - parabix lexical analysis (bit streams)
     2    Copyright (c) 2007, 2008, Robert D. Cameron.
    33    Licensed to the public under the Open Software License 3.0.
    44    Licensed to International Characters, Inc., under the Academic
     
    99#define BITLEX_H
    1010
    11 #include "../lib/sse_simd.h"
    12 
    13 #if BYTE_ORDER == BIG_ENDIAN
    14 #define sisd_sfl(blk, n) sisd_srl(blk, n)
    15 #define sisd_sbl(blk, n) sisd_sll(blk, n)
    16 #define sisd_sfli(blk, n) sisd_srli(blk, n)
    17 #define sisd_sbli(blk, n) sisd_slli(blk, n)
    18 #define simd_sbli_64(blk, n) simd_slli_64(blk, n)
    19 #endif
    20 #if BYTE_ORDER == LITTLE_ENDIAN
    21 #define sisd_sfl(blk, n) sisd_sll(blk, n)
    22 #define sisd_sbl(blk, n) sisd_srl(blk, n)
    23 #define sisd_sfli(blk, n) sisd_slli(blk, n)
    24 #define sisd_sbli(blk, n) sisd_srli(blk, n)
    25 #define simd_sbli_64(blk, n) simd_srli_64(blk, n)
    26 #endif
    27 
    28 
    29 /* The BytePack and the BitBlock are the two fundamental
    30    types used by the parabix program for data held in
    31    SIMD registers, representing, respectively, the byte-oriented
    32    and bit-oriented views of character data.*/
    33 
    34 typedef SIMD_type BytePack;
    35 typedef SIMD_type BitBlock;
    36 const int PACKSIZE = sizeof(SIMD_type);
    37 const int BLOCKSIZE = sizeof(SIMD_type) * 8;
    38 
    39 /* Define the size of buffer used for lexical analysis/parsing. */
    40 const int BUFFER_BLOCKS = 16;
    41 const int BUFFER_PACKS = BUFFER_BLOCKS * (BLOCKSIZE/PACKSIZE);
    42 
     11#include "xmlparam.h"
     12#include "xmlbuffer.h"
    4313
    4414/* Lexical items are particular characters, character classes
     
    4616
    4717enum lexical_item {
    48   minLexicalItem = 0,
    49   MarkupStart = minLexicalItem, CD_End_check, Hyphen, QMark,
    50   DQuote, SQuote, NonWS, NameFollow,
    51   maxLexicalItem = NameFollow};
     18        minLexicalItem = 0,
     19        NonWS = minLexicalItem,
     20        MarkupStart, CD_End_check, Hyphen, QMark,
     21        Quote, NameFollow,
     22        maxLexicalItem = NameFollow};
    5223
    5324const int LexicalItemCount = maxLexicalItem + 1;
     25
     26
     27
    5428
    5529/* The principal role of the lexical analyzer is to prepare
     
    6539   items.
    6640
    67    The XML byte stream is sized to hold an additional number of bytes
    68    of lookahead data beyond the nominal buffer size.  The lexical
    69    item streams each comprise the number of BitBlocks required
    70    to hold one bit for each character code unit position in the
    71    buffer, plus an additional sentinel BitBlock at the end.
    72    
    73 */
    74 const int LOOKAHEAD_POSITIONS = 12;
    75 const int LOOKAHEAD_PACKS = (LOOKAHEAD_POSITIONS+PACKSIZE-1)/PACKSIZE;
    76 const int SENTINEL_BLOCKS = 1;
     41   A BitBlockBasis is a set of 8 parallel bit blocks for
     42   that represent a block of 8-bit code units in bit-parallel
     43   form. */
    7744
    78 struct ParallelStreamSet {
    79         BytePack x8data[BUFFER_PACKS+LOOKAHEAD_PACKS];
    80         BitBlock item_stream[LexicalItemCount][BUFFER_BLOCKS+SENTINEL_BLOCKS];
     45struct BitBlockBasis {
     46        BitBlock bit[8];
    8147};
    8248
    83 struct BitBlockGroup {
    84   BitBlock bit[8];
     49/* A BitStreamBuffer is a bit stream of BUFFER_BLOCKS consecutive
     50   blocks, followed by a sentinel block to terminate bit scans. */
     51
     52const int SENTINEL_BLOCKS = 1;
     53typedef BitBlock BitStreamBuffer[BUFFER_BLOCKS+SENTINEL_BLOCKS];
     54
     55struct LexicalStreamSet {
     56        BitStreamBuffer item_stream[LexicalItemCount];
    8557};
    8658
    87 #include "xmlbuffer.h"
    88 class Lexer {
     59
     60class Lexer_Interface {
    8961public:
    90    Lexer(XML_Buffer *b, ParallelStreamSet *p);
    91 
    92    /* Advance buffer and return number of code units available. */
    93    virtual int AdvanceBuffer(int new_code_unit_position) = 0;
    94    /* Detect a Byte Order Mark at the given position.  Return the
    95       number of code unit positions (0 => no BOM, 1 => UTF-16/32 families,
    96       3 => UTF-8. */
    97    virtual int BOM_size(int rel_pos) = 0;
     62        Lexer_Interface(XML_Buffer_Interface *b, LexicalStreamSet *l);
     63        void AdvanceBuffer(int& base_pos, int& rel_pos, int& limit_pos);
    9864
    9965protected:
    100    XML_Buffer *xml_buf;
    101    BitBlockGroup *(bit_group[BUFFER_BLOCKS+1]);
    102    ParallelStreamSet *parsing_engine_data;
    103    void ComputeLexicalItemStreams(int newblocks);
    104    void EstablishSentinels(int code_units);
     66        XML_Buffer_Interface *xml_buf;
     67        void TransposeToBitStreams();
     68        virtual void Do_XML_10_WS_Control() = 0;
     69        virtual void Do_MarkupStreams() = 0;
     70        virtual void Do_XML_11_WS_Control() = 0;
     71        virtual void Do_CharsetValidation() = 0;
     72        int lexer_base_pos;
     73        BitBlockBasis * x8basis;
     74        LexicalStreamSet * parsing_engine_data;
     75        int code_units;
     76        int data_blocks;
    10577};
     78
     79template <CodeUnit_Base C>
     80class Lexer : public Lexer_Interface {
     81public:
     82        static Lexer_Interface * LexerFactory(XML_Buffer_Interface *b, LexicalStreamSet *l);
     83
     84protected:
     85        Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     86        void Do_XML_10_WS_Control();
     87        void Do_MarkupStreams();
     88        virtual void Do_XML_11_WS_Control() = 0;
     89        virtual void Do_CharsetValidation() = 0;
     90};
     91
     92class UTF_8_Lexer : public Lexer<ASCII> {
     93public:
     94        UTF_8_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     95        void Do_XML_11_WS_Control();
     96        void Do_CharsetValidation();
     97};
     98
     99class ASCII_7_Lexer : public Lexer<ASCII> {
     100public:
     101        ASCII_7_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     102        void Do_XML_11_WS_Control();
     103        void Do_CharsetValidation();
     104};
     105
     106class EASCII_8_Lexer : public Lexer<ASCII> {
     107public:
     108        EASCII_8_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     109        void Do_XML_11_WS_Control();
     110        void Do_CharsetValidation();
     111};
     112
     113/* 16-bit ASCII-based character sets: UTF-16 and UCS-2 families.
     114   Whitespace and control processing is common to these families,
     115   but character set validation differs for codepoints D800-DFFF,
     116   used for surrogate pairs in UTF-16 and prohibitied in UCS-2. */
     117class U16_Lexer : public Lexer<ASCII> {
     118public:
     119        U16_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     120        void Do_XML_11_WS_Control();
     121        virtual void Do_CharsetValidation() = 0;
     122};
     123
     124class UTF_16_Lexer : public U16_Lexer {
     125public:
     126        UTF_16_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     127        void Do_CharsetValidation();
     128};
     129
     130class UCS_2_Lexer : public U16_Lexer {
     131public:
     132        UCS_2_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     133        void Do_CharsetValidation();
     134};
     135
     136class UTF_32_Lexer : public Lexer<ASCII> {
     137public:
     138        UTF_32_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     139        void Do_XML_11_WS_Control();
     140        void Do_CharsetValidation();
     141};
     142
     143class EBCDIC_Lexer: public Lexer<EBCDIC> {
     144public:
     145        EBCDIC_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     146        void Do_XML_11_WS_Control();
     147        void Do_CharsetValidation();
     148};
     149
    106150
    107151#ifdef BUFFER_PROFILING
  • trunk/src/transpose.h

    r4 r36  
    11/*  transpose.h - parabix transposition library
    2     Copyright (c) 2007, Robert D. Cameron. 
     2    Copyright (c) 2007, 2008 Robert D. Cameron. 
    33    Licensed to the public under the Open Software License 3.0.
    44    Licensed to International Characters, Inc., under the Academic
     
    66
    77*/
     8#ifndef TRANSPOSE_H
     9#define TRANSPOSE_H
    810
    911#define s2p_step(s0, s1, hi_mask, shift, p0, p1) \
     
    1719
    1820static inline void s2p_bytepack(BytePack s[], BitBlock p[]) {
    19 BitBlock mask_2 = simd_himask_2;
    20 BitBlock mask_4 = simd_himask_4;
    21 BitBlock mask_8 = simd_himask_8;
     21    BitBlock mask_2 = simd_himask_2;
     22    BitBlock mask_4 = simd_himask_4;
     23    BitBlock mask_8 = simd_himask_8;
    2224    BitBlock bit00224466_0, bit00224466_1, bit00224466_2, bit00224466_3;
    2325    BitBlock bit11335577_0, bit11335577_1, bit11335577_2, bit11335577_3;
     
    4648  }
    4749
     50#endif
Note: See TracChangeset for help on using the changeset viewer.