Changeset 100 for trunk/src/bitlex.c


Ignore:
Timestamp:
Apr 14, 2008, 6:34:30 PM (11 years ago)
Author:
lindanl
Message:

Parsers for internal and external entities.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/bitlex.c

    r95 r100  
    1919
    2020
    21 Lexer_Interface::Lexer_Interface(Model_Info * m, LexicalStreamSet *l) {
    22         model_info = m;
     21Lexer_Interface::Lexer_Interface(Entity_Info * e, LexicalStreamSet *l) {
     22        entity_Info = e;
    2323        parsing_engine_data = l;
    2424
     
    4949
    5050template <>
    51 Lexer_Interface * Lexer<ASCII>::LexerFactory(Model_Info * m, LexicalStreamSet *l) {
     51Lexer_Interface * Lexer<ASCII>::LexerFactory(Entity_Info * e, LexicalStreamSet *l) {
    5252#ifdef CODE_CLOCKING
    5353        WS_Control_clocker = register_Code_Clocker("WS", "WhiteSpace/Control\n");
     
    5555        char_validation_clocker = register_Code_Clocker("charcheck", "Character validation\n");
    5656#endif
    57         if (!(m->has_encoding_decl)) {
     57        if (!(e->has_encoding_decl)) {
    5858                // Must be UTF-8 or UTF-16; UTF-16 requires a ByteOrderMark.
    59                 if (m->code_unit_size == SingleByte) return new UTF_8_Lexer(m, l);
    60                 else if ((m->code_unit_size == DoubleByte))
    61                         if (m->BOM_units == 1) return new UTF_16_Lexer(m, l);
     59                if (e->code_unit_size == SingleByte) return new UTF_8_Lexer(e, l);
     60                else if ((e->code_unit_size == DoubleByte))
     61                        if (e->BOM_units == 1) return new UTF_16_Lexer(e, l);
    6262                        else NoEncodingError("UTF-16 implied but no byte order found.");
    6363                else NoEncodingError("UTF-32 without an encoding declaration.\n");
    6464        }
    6565        else {
    66                 int lgth = strlen((const char *) m->encoding);
    67                 CodeUnit_ByteOrder order = m->byte_order;
    68                 switch (m->code_unit_size) {
     66                int lgth = strlen((const char *) e->encoding);
     67                CodeUnit_ByteOrder order = e->byte_order;
     68                switch (e->code_unit_size) {
    6969                case SingleByte:
    70                         if ((lgth == 5) && at_UTF_8(m->encoding))
    71                                 return new UTF_8_Lexer(m, l);
    72                         else if ((lgth == 5) && at_ASCII(m->encoding))
    73                                 return new ASCII_7_Lexer(m, l);
    74                         else if ((lgth == 6)  && at_Latin1(m->encoding))
    75                                 return new EASCII_8_Lexer(m, l);
     70                        if ((lgth == 5) && at_UTF_8(e->encoding))
     71                                return new UTF_8_Lexer(e, l);
     72                        else if ((lgth == 5) && at_ASCII(e->encoding))
     73                                return new ASCII_7_Lexer(e, l);
     74                        else if ((lgth == 6)  && at_Latin1(e->encoding))
     75                                return new EASCII_8_Lexer(e, l);
    7676                        /* Really need a table-based lookup here */
    77                         else EncodingError("8-bit", m->encoding, lgth);
     77                        else EncodingError("8-bit", e->encoding, lgth);
    7878                case DoubleByte:
    79                         if (m->BOM_units == 1)
    80                                 if ((lgth == 6) && at_UTF_16(m->encoding))
    81                                         return new UTF_16_Lexer(m, l);
    82                                 else if ((lgth == 5) && at_UCS_2(m->encoding))
    83                                         return new UCS_2_Lexer(m, l);
    84                                 else EncodingError("16-bit", m->encoding, lgth);
     79                        if (e->BOM_units == 1)
     80                                if ((lgth == 6) && at_UTF_16(e->encoding))
     81                                        return new UTF_16_Lexer(e, l);
     82                                else if ((lgth == 5) && at_UCS_2(e->encoding))
     83                                        return new UCS_2_Lexer(e, l);
     84                                else EncodingError("16-bit", e->encoding, lgth);
    8585                        else if (order == BigEndian)
    86                                 if ((lgth == 8) && at_UTF_16BE(m->encoding))
    87                                         return new UTF_16_Lexer(m, l);
    88                                 else if ((lgth == 7) && at_UCS_2BE(m->encoding))
    89                                         return new UCS_2_Lexer(m, l);
    90                                 else EncodingError("16BE", m->encoding, lgth);
     86                                if ((lgth == 8) && at_UTF_16BE(e->encoding))
     87                                        return new UTF_16_Lexer(e, l);
     88                                else if ((lgth == 7) && at_UCS_2BE(e->encoding))
     89                                        return new UCS_2_Lexer(e, l);
     90                                else EncodingError("16BE", e->encoding, lgth);
    9191                        else /*if (order == LittleEndian)*/
    92                                 if ((lgth == 8) && at_UTF_16LE(m->encoding))
    93                                         return new UTF_16_Lexer(m, l);
    94                                 else if ((lgth == 7) && at_UCS_2LE(m->encoding))
    95                                         return new UCS_2_Lexer(m, l);
    96                                 else EncodingError("16LE", m->encoding, lgth);
     92                                if ((lgth == 8) && at_UTF_16LE(e->encoding))
     93                                        return new UTF_16_Lexer(e, l);
     94                                else if ((lgth == 7) && at_UCS_2LE(e->encoding))
     95                                        return new UCS_2_Lexer(e, l);
     96                                else EncodingError("16LE", e->encoding, lgth);
    9797                case QuadByte:
    98                         if (m->BOM_units == 1)
    99                                 if ((lgth == 6) && at_UTF_32(m->encoding))
    100                                         return new UTF_32_Lexer(m, l);
    101                                 else if ((lgth == 5) && at_UCS_4(m->encoding))
    102                                         return new UTF_32_Lexer(m, l);
    103                                 else EncodingError("32-bit", m->encoding, lgth);
     98                        if (e->BOM_units == 1)
     99                                if ((lgth == 6) && at_UTF_32(e->encoding))
     100                                        return new UTF_32_Lexer(e, l);
     101                                else if ((lgth == 5) && at_UCS_4(e->encoding))
     102                                        return new UTF_32_Lexer(e, l);
     103                                else EncodingError("32-bit", e->encoding, lgth);
    104104                        else if (order == BigEndian)
    105                                 if ((lgth == 8) && at_UTF_32BE(m->encoding))
    106                                         return new UTF_32_Lexer(m, l);
    107                                 else if ((lgth == 7) && at_UCS_4BE(m->encoding))
    108                                         return new UTF_32_Lexer(m, l);
    109                                 else EncodingError("32BE", m->encoding, lgth);
     105                                if ((lgth == 8) && at_UTF_32BE(e->encoding))
     106                                        return new UTF_32_Lexer(e, l);
     107                                else if ((lgth == 7) && at_UCS_4BE(e->encoding))
     108                                        return new UTF_32_Lexer(e, l);
     109                                else EncodingError("32BE", e->encoding, lgth);
    110110                        else if (order == LittleEndian)
    111                                 if ((lgth == 8) && at_UTF_32LE(m->encoding))
    112                                         return new UTF_32_Lexer(m, l);
    113                                 else if ((lgth == 7) && at_UCS_4LE(m->encoding))
    114                                         return new UTF_32_Lexer(m, l);
    115                                 else EncodingError("32LE", m->encoding, lgth);
    116                         else EncodingError("32-bit", m->encoding, lgth);
     111                                if ((lgth == 8) && at_UTF_32LE(e->encoding))
     112                                        return new UTF_32_Lexer(e, l);
     113                                else if ((lgth == 7) && at_UCS_4LE(e->encoding))
     114                                        return new UTF_32_Lexer(e, l);
     115                                else EncodingError("32LE", e->encoding, lgth);
     116                        else EncodingError("32-bit", e->encoding, lgth);
    117117                }
    118118        }
     
    120120
    121121template <>
    122 Lexer_Interface * Lexer<EBCDIC>::LexerFactory(Model_Info * m, LexicalStreamSet *l) {
    123         if (!(m->has_encoding_decl)) {
     122Lexer_Interface * Lexer<EBCDIC>::LexerFactory(Entity_Info * e, LexicalStreamSet *l) {
     123        if (!(e->has_encoding_decl)) {
    124124                // Must be UTF-8 or UTF-16; UTF-16 requires a ByteOrderMark.
    125125                NoEncodingError("EBCDIC-family inferred, but no encoding declaration present.\n");
    126126        }
    127127        else {
    128                 int lgth = strlen((const char *) m->encoding);
     128                int lgth = strlen((const char *) e->encoding);
    129129                /* Really need a table-based lookup here */
    130                 if ((lgth == 6) && at_EBCDIC(m->encoding))
    131                         return new EBCDIC_Lexer(m, l);
    132                 else EncodingError("EBCDIC family", m->encoding, lgth);
     130                if ((lgth == 6) && at_EBCDIC(e->encoding))
     131                        return new EBCDIC_Lexer(e, l);
     132                else EncodingError("EBCDIC family", e->encoding, lgth);
    133133        }
    134134}
    135135
    136136template <CodeUnit_Base C>
    137 Lexer<C>::Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer_Interface::Lexer_Interface(m, l) {
    138 }
    139 
    140 UTF_8_Lexer::UTF_8_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(m, l) {
    141 }
    142 
    143 ASCII_7_Lexer::ASCII_7_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(m, l) {
    144 }
    145 
    146 EASCII_8_Lexer::EASCII_8_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(m, l) {
    147 }
    148 
    149 U16_Lexer::U16_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(m, l) {
    150 }
    151 
    152 UTF_16_Lexer::UTF_16_Lexer(Model_Info * m, LexicalStreamSet *l) : U16_Lexer::U16_Lexer(m, l) {
    153 }
    154 
    155 UCS_2_Lexer::UCS_2_Lexer(Model_Info * m, LexicalStreamSet *l) : U16_Lexer::U16_Lexer(m, l) {
    156 }
    157 
    158 UTF_32_Lexer::UTF_32_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(m, l) {
    159 }
    160 
    161 EBCDIC_Lexer::EBCDIC_Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer<EBCDIC>::Lexer(m, l) {
     137Lexer<C>::Lexer(Entity_Info * e, LexicalStreamSet *l) : Lexer_Interface::Lexer_Interface(e, l) {
     138}
     139
     140UTF_8_Lexer::UTF_8_Lexer(Entity_Info * e, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(e, l) {
     141}
     142
     143ASCII_7_Lexer::ASCII_7_Lexer(Entity_Info * e, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(e, l) {
     144}
     145
     146EASCII_8_Lexer::EASCII_8_Lexer(Entity_Info * e, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(e, l) {
     147}
     148
     149U16_Lexer::U16_Lexer(Entity_Info * e, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(e, l) {
     150}
     151
     152UTF_16_Lexer::UTF_16_Lexer(Entity_Info * e, LexicalStreamSet *l) : U16_Lexer::U16_Lexer(e, l) {
     153}
     154
     155UCS_2_Lexer::UCS_2_Lexer(Entity_Info * e, LexicalStreamSet *l) : U16_Lexer::U16_Lexer(e, l) {
     156}
     157
     158UTF_32_Lexer::UTF_32_Lexer(Entity_Info * e, LexicalStreamSet *l) : Lexer<ASCII>::Lexer(e, l) {
     159}
     160
     161EBCDIC_Lexer::EBCDIC_Lexer(Entity_Info * e, LexicalStreamSet *l) : Lexer<EBCDIC>::Lexer(e, l) {
    162162}
    163163
     
    883883        buffer_units = buffer_limit_pos;
    884884
    885         if (model_info->version == XML_1_1) Do_XML_11_WS_Control();
     885        if (entity_Info->version == XML_1_1) Do_XML_11_WS_Control();
    886886        else Do_XML_10_WS_Control();
    887887#ifdef DEBUG
     
    914914        if (err_pos < buffer_units) {
    915915                printf("Invalid %s character in input stream at position %i\n",
    916                         model_info->encoding,
     916                        entity_Info->encoding,
    917917                        lexer_base_pos + err_pos);
    918918                exit(-1);
Note: See TracChangeset for help on using the changeset viewer.