Changeset 72


Ignore:
Timestamp:
Mar 27, 2008, 9:26:16 AM (11 years ago)
Author:
cameron
Message:

Refactored Lexer and friends

Location:
trunk/src
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/bitlex.c

    r65 r72  
    1 /*  bitlex - Parabix lexical analysis common routines.
     1/*  bitlex - Lexical Item Stream Module.
    22    Copyright (c) 2007, 2008, Robert D. Cameron.
    33    Licensed to the public under the Open Software License 3.0.
     
    99#include "bitlex.h"
    1010#include "../lib/lib_simd.h"
    11 
    1211
    1312#ifdef CODE_CLOCKING
     
    2019
    2120
    22 Lexer_Interface::Lexer_Interface(XML_Buffer_Interface *b, LexicalStreamSet *l) {
    23         xml_buf = b;
     21Lexer_Interface::Lexer_Interface(Model_Info * m, LexicalStreamSet *l) {
     22        model_info = m;
    2423        parsing_engine_data = l;
     24
    2525        x8basis = (BitBlockBasis *) simd_new(BUFFER_SIZE/PACKSIZE);
     26        validation_stream = (BitBlock *) simd_new(BUFFER_BLOCKS+SENTINEL_BLOCKS);
    2627};
    2728
    2829
    2930Lexer_Interface::~Lexer_Interface() {
     31        simd_delete((SIMD_type *) validation_stream);
    3032        simd_delete((SIMD_type *) x8basis);
    3133};
     
    3840}
    3941
    40 void EncodingError(char * msg, unsigned char * enc_ptr, int lgth) {
     42void EncodingError(char * msg, unsigned char * encoding, int lgth) {
    4143        printf("Error : Illegal/unsupported %s encoding of length %i: \"", msg, lgth);
    42         for (int i = 0; i < lgth; i++) printf("%c", enc_ptr[i]);
     44        for (int i = 0; i < lgth; i++) printf("%c", encoding[i]);
    4345        printf("\"\n");
    4446        exit(-1);
     
    4648
    4749template <>
    48 Lexer_Interface * Lexer<ASCII>::LexerFactory(XML_Buffer_Interface *b, LexicalStreamSet *l) {
     50Lexer_Interface * Lexer<ASCII>::LexerFactory(Model_Info * m, LexicalStreamSet *l) {
    4951#ifdef CODE_CLOCKING
    50 transpose_clocker = register_Code_Clocker("s2p", "transposition to parallel bit streams\n");
    51 WS_Control_clocker = register_Code_Clocker("WS", "WhiteSpace/Control\n");
    52 MarkupStreams_clocker = register_Code_Clocker("bitlex", "Markup streams\n");
    53 char_validation_clocker = register_Code_Clocker("charcheck", "Character validation\n");
    54 
    55 #endif
    56         if (!(b->has_encoding_decl)) {
     52        WS_Control_clocker = register_Code_Clocker("WS", "WhiteSpace/Control\n");
     53        MarkupStreams_clocker = register_Code_Clocker("bitlex", "Markup streams\n");
     54        char_validation_clocker = register_Code_Clocker("charcheck", "Character validation\n");
     55#endif
     56        if (!(m->has_encoding_decl)) {
    5757                // Must be UTF-8 or UTF-16; UTF-16 requires a ByteOrderMark.
    58                 if (b->code_unit_size == SingleByte) return new UTF_8_Lexer(b, l);
    59                 else if ((b->code_unit_size == DoubleByte))
    60                         if (b->BOM_units == 1) return new UTF_16_Lexer(b, l);
     58                if (m->code_unit_size == SingleByte) return new UTF_8_Lexer(m, l);
     59                else if ((m->code_unit_size == DoubleByte))
     60                        if (m->BOM_units == 1) return new UTF_16_Lexer(m, l);
    6161                        else NoEncodingError("UTF-16 implied but no byte order found.");
    6262                else NoEncodingError("UTF-32 without an encoding declaration.\n");
    6363        }
    6464        else {
    65                 unsigned char * enc_ptr =
    66                         &(((unsigned char *)(b->x8data))[b->encoding_start_pos]);
    67                 int lgth = b->encoding_lgth;
    68                 CodeUnit_ByteOrder order = b->byte_order;
    69                 switch (b->code_unit_size) {
     65                int lgth = strlen((const char *) m->encoding);
     66                CodeUnit_ByteOrder order = m->byte_order;
     67                switch (m->code_unit_size) {
    7068                case SingleByte:
    71                         if ((lgth == 5) && at_UTF_8(enc_ptr))
    72                                 return new UTF_8_Lexer(b, l);
    73                         else if ((lgth == 5) && at_ASCII(enc_ptr))
    74                                 return new ASCII_7_Lexer(b, l);
    75                         else if ((lgth == 6)  && at_Latin1(enc_ptr))
    76                                 return new EASCII_8_Lexer(b, l);
     69                        if ((lgth == 5) && at_UTF_8(m->encoding))
     70                                return new UTF_8_Lexer(m, l);
     71                        else if ((lgth == 5) && at_ASCII(m->encoding))
     72                                return new ASCII_7_Lexer(m, l);
     73                        else if ((lgth == 6)  && at_Latin1(m->encoding))
     74                                return new EASCII_8_Lexer(m, l);
    7775                        /* Really need a table-based lookup here */
    78                         else EncodingError("8-bit", enc_ptr, lgth);
     76                        else EncodingError("8-bit", m->encoding, lgth);
    7977                case DoubleByte:
    80                         if (b->BOM_units == 1)
    81                                 if ((lgth == 6) && at_UTF_16(enc_ptr))
    82                                         return new UTF_16_Lexer(b, l);
    83                                 else if ((lgth == 5) && at_UCS_2(enc_ptr))
    84                                         return new UCS_2_Lexer(b, l);
    85                                 else EncodingError("16-bit", enc_ptr, lgth);
     78                        if (m->BOM_units == 1)
     79                                if ((lgth == 6) && at_UTF_16(m->encoding))
     80                                        return new UTF_16_Lexer(m, l);
     81                                else if ((lgth == 5) && at_UCS_2(m->encoding))
     82                                        return new UCS_2_Lexer(m, l);
     83                                else EncodingError("16-bit", m->encoding, lgth);
    8684                        else if (order == BigEndian)
    87                                 if ((lgth == 8) && at_UTF_16BE(enc_ptr))
    88                                         return new UTF_16_Lexer(b, l);
    89                                 else if ((lgth == 7) && at_UCS_2BE(enc_ptr))
    90                                         return new UCS_2_Lexer(b, l);
    91                                 else EncodingError("16BE", enc_ptr, lgth);
     85                                if ((lgth == 8) && at_UTF_16BE(m->encoding))
     86                                        return new UTF_16_Lexer(m, l);
     87                                else if ((lgth == 7) && at_UCS_2BE(m->encoding))
     88                                        return new UCS_2_Lexer(m, l);
     89                                else EncodingError("16BE", m->encoding, lgth);
    9290                        else /*if (order == LittleEndian)*/
    93                                 if ((lgth == 8) && at_UTF_16LE(enc_ptr))
    94                                         return new UTF_16_Lexer(b, l);
    95                                 else if ((lgth == 7) && at_UCS_2LE(enc_ptr))
    96                                         return new UCS_2_Lexer(b, l);
    97                                 else EncodingError("16LE", enc_ptr, lgth);
     91                                if ((lgth == 8) && at_UTF_16LE(m->encoding))
     92                                        return new UTF_16_Lexer(m, l);
     93                                else if ((lgth == 7) && at_UCS_2LE(m->encoding))
     94                                        return new UCS_2_Lexer(m, l);
     95                                else EncodingError("16LE", m->encoding, lgth);
    9896                case QuadByte:
    99                         if (b->BOM_units == 1)
    100                                 if ((lgth == 6) && at_UTF_32(enc_ptr))
    101                                         return new UTF_32_Lexer(b, l);
    102                                 else if ((lgth == 5) && at_UCS_4(enc_ptr))
    103                                         return new UTF_32_Lexer(b, l);
    104                                 else EncodingError("32-bit", enc_ptr, lgth);
     97                        if (m->BOM_units == 1)
     98                                if ((lgth == 6) && at_UTF_32(m->encoding))
     99                                        return new UTF_32_Lexer(m, l);
     100                                else if ((lgth == 5) && at_UCS_4(m->encoding))
     101                                        return new UTF_32_Lexer(m, l);
     102                                else EncodingError("32-bit", m->encoding, lgth);
    105103                        else if (order == BigEndian)
    106                                 if ((lgth == 8) && at_UTF_32BE(enc_ptr))
    107                                         return new UTF_32_Lexer(b, l);
    108                                 else if ((lgth == 7) && at_UCS_4BE(enc_ptr))
    109                                         return new UTF_32_Lexer(b, l);
    110                                 else EncodingError("32BE", enc_ptr, lgth);
     104                                if ((lgth == 8) && at_UTF_32BE(m->encoding))
     105                                        return new UTF_32_Lexer(m, l);
     106                                else if ((lgth == 7) && at_UCS_4BE(m->encoding))
     107                                        return new UTF_32_Lexer(m, l);
     108                                else EncodingError("32BE", m->encoding, lgth);
    111109                        else if (order == LittleEndian)
    112                                 if ((lgth == 8) && at_UTF_32LE(enc_ptr))
    113                                         return new UTF_32_Lexer(b, l);
    114                                 else if ((lgth == 7) && at_UCS_4LE(enc_ptr))
    115                                         return new UTF_32_Lexer(b, l);
    116                                 else EncodingError("32LE", enc_ptr, lgth);
    117                         else EncodingError("32-bit", enc_ptr, lgth);
     110                                if ((lgth == 8) && at_UTF_32LE(m->encoding))
     111                                        return new UTF_32_Lexer(m, l);
     112                                else if ((lgth == 7) && at_UCS_4LE(m->encoding))
     113                                        return new UTF_32_Lexer(m, l);
     114                                else EncodingError("32LE", m->encoding, lgth);
     115                        else EncodingError("32-bit", m->encoding, lgth);
    118116                }
    119117        }
     
    121119
    122120template <>
    123 Lexer_Interface * Lexer<EBCDIC>::LexerFactory(XML_Buffer_Interface *b, LexicalStreamSet *l) {
    124         if (!(b->has_encoding_decl)) {
     121Lexer_Interface * Lexer<EBCDIC>::LexerFactory(Model_Info * m, LexicalStreamSet *l) {
     122        if (!(m->has_encoding_decl)) {
    125123                // Must be UTF-8 or UTF-16; UTF-16 requires a ByteOrderMark.
    126124                NoEncodingError("EBCDIC-family inferred, but no encoding declaration present.\n");
    127125        }
    128126        else {
    129                 unsigned char * enc_ptr =
    130                         &(((unsigned char *)(b->x8data))[b->encoding_start_pos]);
    131                 int lgth = b->encoding_lgth;
    132 
     127                int lgth = strlen((const char *) m->encoding);
    133128                /* Really need a table-based lookup here */
    134                 if ((lgth == 6) && at_EBCDIC(enc_ptr))
    135                         return new EBCDIC_Lexer(b, l);
    136                 else EncodingError("EBCDIC family", enc_ptr, lgth);
     129                if ((lgth == 6) && at_EBCDIC(m->encoding))
     130                        return new EBCDIC_Lexer(m, l);
     131                else EncodingError("EBCDIC family", m->encoding, lgth);
    137132        }
    138133}
    139134
    140135template <CodeUnit_Base C>
    141 Lexer<C>::Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l) : Lexer_Interface::Lexer_Interface(b, l) {
    142 }
    143 
    144 UTF_8_Lexer::UTF_8_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(b, l) {
    145 }
    146 
    147 ASCII_7_Lexer::ASCII_7_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(b, l) {
    148 }
    149 
    150 EASCII_8_Lexer::EASCII_8_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(b, l) {
    151 }
    152 
    153 U16_Lexer::U16_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(b, l) {
    154 }
    155 
    156 UTF_16_Lexer::UTF_16_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l) : U16_Lexer::U16_Lexer(b, l) {
    157 }
    158 
    159 UCS_2_Lexer::UCS_2_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l) : U16_Lexer::U16_Lexer(b, l) {
    160 }
    161 
    162 UTF_32_Lexer::UTF_32_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(b, l) {
    163 }
    164 
    165 EBCDIC_Lexer::EBCDIC_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l) : Lexer<EBCDIC>::Lexer(b, l) {
     136Lexer<C>::Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer_Interface::Lexer_Interface(m, l) {
     137}
     138
     139UTF_8_Lexer::UTF_8_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(m, l) {
     140}
     141
     142ASCII_7_Lexer::ASCII_7_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(m, l) {
     143}
     144
     145EASCII_8_Lexer::EASCII_8_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(m, l) {
     146}
     147
     148U16_Lexer::U16_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(m, l) {
     149}
     150
     151UTF_16_Lexer::UTF_16_Lexer(Model_Info * m, LexicalStreamSet *l) : U16_Lexer::U16_Lexer(m, l) {
     152}
     153
     154UCS_2_Lexer::UCS_2_Lexer(Model_Info * m, LexicalStreamSet *l) : U16_Lexer::U16_Lexer(m, l) {
     155}
     156
     157UTF_32_Lexer::UTF_32_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(m, l) {
     158}
     159
     160EBCDIC_Lexer::EBCDIC_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<EBCDIC>::Lexer(m, l) {
    166161}
    167162
     
    193188        BitBlock SP = simd_andc(temp13, temp16);
    194189        WS = simd_or(simd_or(CR, LF), simd_or(HT, SP));
    195 #ifdef DEBUG_BITSTREAMS
    196 print_bit_block("bit[0]", bit[0]);
    197 print_bit_block("bit[1]", bit[1]);
    198 print_bit_block("bit[2]", bit[2]);
    199 print_bit_block("bit[3]", bit[3]);
    200 print_bit_block("bit[4]", bit[4]);
    201 print_bit_block("bit[5]", bit[5]);
    202 print_bit_block("bit[6]", bit[6]);
    203 print_bit_block("bit[7]", bit[7]);
    204 print_bit_block("LF", LF);
    205 print_bit_block("HT", HT);
    206 print_bit_block("CR", CR);
    207 print_bit_block("Control", Control);
    208 #endif
    209190}
    210191
     
    279260template <CodeUnit_Base C>
    280261void Lexer<C>::Do_XML_10_WS_Control() {
    281         BitBlock Restricted = simd_const_1(0);
    282         BitBlock Control = simd_const_1(0);
    283         BitBlock WS = simd_const_1(0);
    284         BitBlock final_block_mask;
     262        BitBlock Control, WS;
    285263        for (int i = 0; i < buffer_blocks; i++) {
    286 #ifdef DEBUG_BITSTREAMS
    287 printf("i=%i, buffer_blocks = %i\n", i, buffer_blocks);
    288 #endif
    289                 Restricted = simd_or(Restricted, simd_andc(Control, WS));
    290264                WS_Control_Blocks<C>(x8basis[i].bit,
    291265                                     WS,
    292266                                     Control);
    293267                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
    294         }
    295         if ((buffer_units % BLOCKSIZE) != 0) {
    296                 final_block_mask = sisd_sfl(simd_const_1(1),
    297                                             sisd_from_int(buffer_units % BLOCKSIZE));
    298                 Control = simd_andc(Control, final_block_mask);
    299         }
    300         Restricted = simd_or(Restricted, simd_andc(Control, WS));
    301         if (bitblock_has_bit(Restricted)) {
    302                 printf("Restricted control character in input.\n");
    303                 exit(-1);
    304         }
    305 };
     268                validation_stream[i] = simd_andc(Control, WS);
     269        }
     270};
     271
    306272
    307273
     
    376342        BitBlock temp46 = simd_and(temp45, temp41);
    377343        BitBlock Hex = simd_or(temp43, temp46);
    378 #ifdef DEBUG_BITSTREAMS
    379 print_bit_block("bit[0]", bit[0]);
    380 print_bit_block("bit[1]", bit[1]);
    381 print_bit_block("bit[2]", bit[2]);
    382 print_bit_block("bit[3]", bit[3]);
    383 print_bit_block("bit[4]", bit[4]);
    384 print_bit_block("bit[5]", bit[5]);
    385 print_bit_block("bit[6]", bit[6]);
    386 print_bit_block("bit[7]", bit[7]);
    387 #endif
    388344        LexItem[NonDigit] = simd_not(Digit);
    389345        LexItem[NonHex] = simd_not(Hex);
     
    527483                ComputeLexicalItemBlocks<C>(x8basis[i].bit, lx_blk[i].LexicalItems);
    528484        }
    529 #ifdef BUFFER_PROFILING
    530         end_BOM_interval(bitstream_timer);
    531         start_BOM_interval(lextranspose_timer);
    532 #endif
    533485        /* NonWS stream already completed by WS_Control method. */
    534486        for (int j = MarkupStart; j < LexicalItemCount; j++) {
     
    542494                                simd_not(parsing_engine_data->item_stream[NonWS][i]));
    543495        }
    544 #ifdef BUFFER_PROFILING
    545         end_BOM_interval(lextranspose_timer);
    546         start_BOM_interval(scanner_timer);
    547 #endif
    548496};
    549497
     
    553501void UTF_8_Lexer::Do_CharsetValidation() {
    554502        //printf("UTF_8_Lexer::Do_CharsetValidation not yet implemented; assuming OK.\n");
     503        for (int i = 0; i < buffer_blocks; i++) {
     504                validation_stream[i] = simd_const_1(0);
     505        }
    555506};
    556507
    557508
    558509void ASCII_7_Lexer::Do_CharsetValidation() {
    559         BitBlock Restricted = simd_const_1(0);
    560510        for (int blk = 0; blk < buffer_blocks; blk++) {
    561                 Restricted = simd_or(Restricted, x8basis[blk].bit[0]);
    562         }
    563         if (bitblock_has_bit(Restricted)) {
    564                 printf("Illegal non-ASCII character in input for ASCII document.\n");
    565                 exit(-1);
     511                validation_stream[blk] = x8basis[blk].bit[0];
    566512        }
    567513};
     
    570516void EASCII_8_Lexer::Do_CharsetValidation() {
    571517        /* Nothing required for most charsets - but perhaps should have tables. */
     518        for (int i = 0; i < buffer_blocks; i++) {
     519                validation_stream[i] = simd_const_1(0);
     520        }
    572521};
    573522
     
    703652void EBCDIC_Lexer::Do_CharsetValidation() {
    704653        /* Nothing required for most cases - but perhaps should have tables. */
    705 };
    706 
     654        for (int i = 0; i < buffer_blocks; i++) {
     655                validation_stream[i] = simd_const_1(0);
     656        }
     657}
    707658
    708659
     
    751702
    752703void ASCII_7_Lexer::Do_XML_11_WS_Control() {
    753         BitBlock Restricted = simd_const_1(0);
    754         BitBlock Control = simd_const_1(0);
    755         BitBlock WS = simd_const_1(0);
     704        BitBlock WS, Control;
    756705        for (int i = 0; i < buffer_blocks; i++) {
    757                 Restricted = simd_or(Restricted, simd_andc(Control, WS));
    758706                ASCII_7_WS_Control_Blocks_11(x8basis[i].bit, WS, Control);
    759707                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
    760         }
    761         if ((buffer_units % BLOCKSIZE) != 0)
    762                 Control = simd_andc(Control,
    763                                     sisd_sfl(simd_const_1(1),
    764                                              sisd_from_int(buffer_units % BLOCKSIZE)));
    765         Restricted = simd_or(Restricted, simd_andc(Control, WS));
    766         if (bitblock_has_bit(Restricted)) {
    767                 printf("***Restricted control character in input.\n");
    768                 exit(-1);
     708                validation_stream[i] = simd_andc(Control, WS);
    769709        }
    770710};
     
    810750
    811751void EASCII_8_Lexer::Do_XML_11_WS_Control() {
    812         BitBlock Restricted = simd_const_1(0);
    813         BitBlock Control = simd_const_1(0);
    814         BitBlock WS = simd_const_1(0);
     752        BitBlock WS, Control;
    815753        for (int i = 0; i < buffer_blocks; i++) {
    816                 Restricted = simd_or(Restricted, simd_andc(Control, WS));
    817754                EASCII_8_WS_Control_Blocks_11(x8basis[i].bit, WS, Control);
    818755                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
    819         }
    820         if ((buffer_units % BLOCKSIZE) != 0)
    821                 Control = simd_andc(Control,
    822                                     sisd_sfl(simd_const_1(1),
    823                                              sisd_from_int(buffer_units % BLOCKSIZE)));
    824         Restricted = simd_or(Restricted, simd_andc(Control, WS));
    825         if (bitblock_has_bit(Restricted)) {
    826                 printf("***Restricted control character in input.\n");
    827                 exit(-1);
     756                validation_stream[i] = simd_andc(Control, WS);
    828757        }
    829758};
     
    876805
    877806void EBCDIC_Lexer::Do_XML_11_WS_Control() {
    878         BitBlock Restricted = simd_const_1(0);
    879         BitBlock Control = simd_const_1(0);
    880         BitBlock WS = simd_const_1(0);
     807        BitBlock WS, Control;
    881808        for (int i = 0; i < buffer_blocks; i++) {
    882                 Restricted = simd_or(Restricted, simd_andc(Control, WS));
    883809                EBCDIC_WS_Control_Blocks_11(x8basis[i].bit, WS, Control);
    884810                parsing_engine_data->item_stream[NonWS][i] = simd_not(WS);
    885         }
    886         if ((buffer_units % BLOCKSIZE) != 0)
    887                 Control = simd_andc(Control,
    888                                     sisd_sfl(simd_const_1(1),
    889                                              sisd_from_int(buffer_units % BLOCKSIZE)));
    890         Restricted = simd_or(Restricted, simd_andc(Control, WS));
    891         if (bitblock_has_bit(Restricted)) {
    892                 printf("***Restricted control character in input.\n");
     811                validation_stream[i] = simd_andc(Control, WS);
     812        }
     813};
     814
     815
     816
     817void Lexer_Interface::AnalyzeBuffer(BitBlockBasis * basis, int buffer_limit_pos) {
     818#ifdef DEBUG
     819        printf("Entered AnalyzeBuffer, buffer_limit_pos = %i\n", buffer_limit_pos);
     820#endif
     821        x8basis = basis;
     822        int err_pos;
     823#ifdef CODE_CLOCKING
     824        start_Interval(WS_Control_clocker);
     825#endif
     826        buffer_blocks = (buffer_limit_pos + BLOCKSIZE - 1)/BLOCKSIZE;
     827        buffer_units = buffer_limit_pos;
     828
     829        if (model_info->version == XML_1_1) Do_XML_11_WS_Control();
     830        else Do_XML_10_WS_Control();
     831        err_pos = bitstream_scan0(validation_stream);
     832        if (err_pos < buffer_units) {
     833                printf("Illegal control character in XML input stream at position %i\n",
     834                        lexer_base_pos + err_pos);
    893835                exit(-1);
    894836        }
    895 };
    896 
    897 
    898 
    899 #include "transpose.h"
    900 
    901 void Lexer_Interface::TransposeToBitStreams() {
    902837#ifdef CODE_CLOCKING
    903 start_Interval(transpose_clocker);
    904 #endif
    905         BytePack * pseudoASCII_src = &(xml_buf->x8data[lexer_base_pos/PACKSIZE]);
    906         for (int blk = 0; blk < buffer_blocks; blk++) {
    907                 s2p_bytepack(&pseudoASCII_src[blk*8], x8basis[blk].bit);
    908         }
     838        end_Interval(WS_Control_clocker, BUFFER_SIZE);
     839#endif
    909840#ifdef CODE_CLOCKING
    910 end_Interval(transpose_clocker, buffer_blocks * BLOCKSIZE);
    911 #endif
    912 }
    913 
    914 void Lexer_Interface::AdvanceBuffer(int& base_pos, int& rel_pos, int& limit_pos) {
    915         BitBlock final_block_mask;
    916 #ifdef BUFFER_PROFILING
    917         start_BOM_interval(bitstream_timer);
    918 #endif
    919 #ifdef DEBUG
    920         printf("AdvanceBuffer entry.\n");
    921 #endif
    922         int abspos = base_pos + rel_pos;
    923         lexer_base_pos = abspos & (-PACKSIZE); /* align the base_position for lexer*/
    924         buffer_units = xml_buf->AvailableUnits(lexer_base_pos);
    925 #ifdef DEBUG
    926         printf("buffer_units = %i.\n", buffer_units);
    927 #endif
    928         if (buffer_units >= BUFFER_SIZE) {
    929                 buffer_units = BUFFER_SIZE;
    930                 final_block_mask = simd_const_1(0);
    931         }
    932         else {
    933                 final_block_mask =
    934                         sisd_sfl(simd_const_1(1), sisd_from_int(buffer_units % BLOCKSIZE));
    935         }
    936         buffer_blocks = (buffer_units + BLOCKSIZE - 1)/BLOCKSIZE;
    937 #ifdef DEBUG
    938         printf("Transpose for abspos = %i, lexer_base_pos= %i, buffer_blocks = %i.\n", abspos, lexer_base_pos, buffer_blocks);
    939 #endif
    940 
    941         TransposeToBitStreams();
    942 #ifdef DEBUG
    943         printf("Transposition to bit streams complete.\n");
    944 #endif
    945 #ifdef CODE_CLOCKING
    946 start_Interval(WS_Control_clocker);
    947 #endif
    948         if (xml_buf->version == XML_1_1) Do_XML_11_WS_Control();
    949         else Do_XML_10_WS_Control();
    950 #ifdef CODE_CLOCKING
    951 end_Interval(WS_Control_clocker, buffer_blocks * BLOCKSIZE);
    952 #endif
    953 #ifdef CODE_CLOCKING
    954 start_Interval(MarkupStreams_clocker);
     841        start_Interval(MarkupStreams_clocker);
    955842#endif
    956843        Do_MarkupStreams();
    957844#ifdef CODE_CLOCKING
    958 end_Interval(MarkupStreams_clocker, buffer_blocks * BLOCKSIZE);
    959 #endif
    960 
    961 #ifdef DEBUG
    962         printf("Markup streams complete.\n");
     845        end_Interval(MarkupStreams_clocker, BUFFER_SIZE);
    963846#endif
    964847#ifdef CODE_CLOCKING
    965 //start_Interval(char_validation_clocker);
     848        start_Interval(char_validation_clocker);
    966849#endif
    967850        Do_CharsetValidation();
     851        err_pos = bitstream_scan0(validation_stream);
     852        if (err_pos < buffer_units) {
     853                printf("Invalid %s character in input stream at position %i\n",
     854                        model_info->encoding,
     855                        lexer_base_pos + err_pos);
     856                exit(-1);
     857        }
    968858#ifdef CODE_CLOCKING
    969 //end_Interval(char_validation_clocker, buffer_blocks * BLOCKSIZE);
    970 #endif
    971 #ifdef DEBUG
    972         printf("Validation complete.\n");
     859        end_Interval(char_validation_clocker, buffer_blocks * BLOCKSIZE);
    973860#endif
    974861        if (buffer_units < BUFFER_SIZE) {
    975 #ifdef DEBUG
    976                 printf("SENTINELS at %i of length %i\n", lexer_base_pos + buffer_units,
    977                                                 buffer_units % BLOCKSIZE);
    978 #endif
     862                BitBlock final_block_mask =
     863                        sisd_sfl(simd_const_1(1), sisd_from_int(buffer_units % BLOCKSIZE));
    979864                int lastblk = buffer_units/BLOCKSIZE;
    980865                for (int j = minLexicalItem; j < LexicalItemCount; j++) {
     
    984869                }
    985870        }
    986         /* Update parser control variables. */
    987         base_pos = lexer_base_pos;
    988         rel_pos = abspos - lexer_base_pos;
    989         limit_pos = buffer_units;
    990 }
    991 
     871
     872}
     873
  • trunk/src/bitlex.h

    r59 r72  
    1 /*  bitlex.h - parabix lexical analysis (bit streams)
     1/*  bitlex.h - Lexical Item Stream Module.
    22    Copyright (c) 2007, 2008, Robert D. Cameron.
    33    Licensed to the public under the Open Software License 3.0.
     
    99#define BITLEX_H
    1010
    11 #include "xmlparam.h"
    12 #include "xmlbuffer.h"
     11#include "xmlmodel.h"
     12#include "byteplex.h"
     13#include "bitplex.h"
     14#include "xmldecl.h"
    1315
    1416/* Lexical items are particular characters, character classes
     
    4244   items.
    4345
    44    A BitBlockBasis is a set of 8 parallel bit blocks for
    45    that represent a block of 8-bit code units in bit-parallel
    46    form. */
     46*/
    4747
    48 struct BitBlockBasis {
    49         BitBlock bit[8];
    50 };
    5148
    5249/* A BitStreamBuffer is a bit stream of BUFFER_BLOCKS consecutive
     
    6360class Lexer_Interface {
    6461public:
    65         Lexer_Interface(XML_Buffer_Interface *b, LexicalStreamSet *l);
     62        Lexer_Interface(Model_Info * m, LexicalStreamSet *l);
    6663        ~Lexer_Interface();
    67         void AdvanceBuffer(int& base_pos, int& rel_pos, int& limit_pos);
     64        void AnalyzeBuffer(BitBlockBasis * x8basis, int buffer_limit_pos);
    6865
    6966protected:
    70         XML_Buffer_Interface *xml_buf;
    71         void TransposeToBitStreams();
     67        Model_Info * model_info;
    7268        virtual void Do_XML_10_WS_Control() = 0;
    7369        virtual void Do_MarkupStreams() = 0;
     
    7672        int lexer_base_pos;
    7773        BitBlockBasis * x8basis;
     74        BitBlock * validation_stream;
    7875        LexicalStreamSet * parsing_engine_data;
    7976        int buffer_units;
     
    8481class Lexer : public Lexer_Interface {
    8582public:
    86         static Lexer_Interface * LexerFactory(XML_Buffer_Interface *b, LexicalStreamSet *l);
     83        static Lexer_Interface * LexerFactory(Model_Info * m,LexicalStreamSet *l);
    8784
    8885protected:
    89         Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     86        Lexer(Model_Info * m,LexicalStreamSet *l);
    9087        void Do_XML_10_WS_Control();
    9188        void Do_MarkupStreams();
     
    9693class UTF_8_Lexer : public Lexer<ASCII> {
    9794public:
    98         UTF_8_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     95        UTF_8_Lexer(Model_Info * m,LexicalStreamSet *l);
    9996        void Do_XML_11_WS_Control();
    10097        void Do_CharsetValidation();
     
    103100class ASCII_7_Lexer : public Lexer<ASCII> {
    104101public:
    105         ASCII_7_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     102        ASCII_7_Lexer(Model_Info * m,LexicalStreamSet *l);
    106103        void Do_XML_11_WS_Control();
    107104        void Do_CharsetValidation();
     
    110107class EASCII_8_Lexer : public Lexer<ASCII> {
    111108public:
    112         EASCII_8_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     109        EASCII_8_Lexer(Model_Info * m,LexicalStreamSet *l);
    113110        void Do_XML_11_WS_Control();
    114111        void Do_CharsetValidation();
     
    121118class U16_Lexer : public Lexer<ASCII> {
    122119public:
    123         U16_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     120        U16_Lexer(Model_Info * m,LexicalStreamSet *l);
    124121        void Do_XML_11_WS_Control();
    125122        virtual void Do_CharsetValidation() = 0;
     
    128125class UTF_16_Lexer : public U16_Lexer {
    129126public:
    130         UTF_16_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     127        UTF_16_Lexer(Model_Info * m,LexicalStreamSet *l);
    131128        void Do_CharsetValidation();
    132129};
     
    134131class UCS_2_Lexer : public U16_Lexer {
    135132public:
    136         UCS_2_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     133        UCS_2_Lexer(Model_Info * m,LexicalStreamSet *l);
    137134        void Do_CharsetValidation();
    138135};
     
    140137class UTF_32_Lexer : public Lexer<ASCII> {
    141138public:
    142         UTF_32_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     139        UTF_32_Lexer(Model_Info * m,LexicalStreamSet *l);
    143140        void Do_XML_11_WS_Control();
    144141        void Do_CharsetValidation();
     
    147144class EBCDIC_Lexer: public Lexer<EBCDIC> {
    148145public:
    149         EBCDIC_Lexer(XML_Buffer_Interface *b, LexicalStreamSet *l);
     146        EBCDIC_Lexer(Model_Info * m,LexicalStreamSet *l);
    150147        void Do_XML_11_WS_Control();
    151148        void Do_CharsetValidation();
     
    153150
    154151
    155 #ifdef BUFFER_PROFILING
    156 #include "../Profiling/BOM_Profiler.c"
    157 BOM_Table * bitstream_timer;
    158 BOM_Table * lextranspose_timer;
    159 BOM_Table * scanner_timer;
    160152#endif
    161 
    162 
    163 #endif
  • trunk/src/bytelex.h

    r33 r72  
    99#define BYTELEX_H
    1010
    11 #include "xmlparam.h"
     11#include "xmlmodel.h"
    1212#include "multiliteral.h"
    1313
  • trunk/src/charsets/ASCII_EBCDIC.h

    r26 r72  
    1212
    1313#include <stdint.h>
    14 #include "../xmlparam.h"
     14#include "../xmlmodel.h"
    1515
    1616template<CodeUnit_Base C, unsigned char c> struct Ord;
  • trunk/src/multiliteral.h

    r33 r72  
    2020#include <assert.h>
    2121#include <stdint.h>
    22 #include "xmlparam.h"
     22#include "xmlmodel.h"
    2323#include "charsets/ASCII_EBCDIC.h"
    2424
Note: See TracChangeset for help on using the changeset viewer.