Changeset 100 for trunk


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

Parsers for internal and external entities.

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

    r72 r100  
    6060class Lexer_Interface {
    6161public:
    62         Lexer_Interface(Model_Info * m, LexicalStreamSet *l);
     62        Lexer_Interface(Entity_Info * e, LexicalStreamSet *l);
    6363        ~Lexer_Interface();
    6464        void AnalyzeBuffer(BitBlockBasis * x8basis, int buffer_limit_pos);
    6565
    6666protected:
    67         Model_Info * model_info;
     67        Entity_Info * entity_Info;
    6868        virtual void Do_XML_10_WS_Control() = 0;
    6969        virtual void Do_MarkupStreams() = 0;
     
    8181class Lexer : public Lexer_Interface {
    8282public:
    83         static Lexer_Interface * LexerFactory(Model_Info * m,LexicalStreamSet *l);
     83        static Lexer_Interface * LexerFactory(Entity_Info * e,LexicalStreamSet *l);
    8484
    8585protected:
    86         Lexer(Model_Info * m,LexicalStreamSet *l);
     86        Lexer(Entity_Info * e,LexicalStreamSet *l);
    8787        void Do_XML_10_WS_Control();
    8888        void Do_MarkupStreams();
     
    9393class UTF_8_Lexer : public Lexer<ASCII> {
    9494public:
    95         UTF_8_Lexer(Model_Info * m,LexicalStreamSet *l);
     95        UTF_8_Lexer(Entity_Info * e,LexicalStreamSet *l);
    9696        void Do_XML_11_WS_Control();
    9797        void Do_CharsetValidation();
     
    100100class ASCII_7_Lexer : public Lexer<ASCII> {
    101101public:
    102         ASCII_7_Lexer(Model_Info * m,LexicalStreamSet *l);
     102        ASCII_7_Lexer(Entity_Info * e,LexicalStreamSet *l);
    103103        void Do_XML_11_WS_Control();
    104104        void Do_CharsetValidation();
     
    107107class EASCII_8_Lexer : public Lexer<ASCII> {
    108108public:
    109         EASCII_8_Lexer(Model_Info * m,LexicalStreamSet *l);
     109        EASCII_8_Lexer(Entity_Info * e,LexicalStreamSet *l);
    110110        void Do_XML_11_WS_Control();
    111111        void Do_CharsetValidation();
     
    118118class U16_Lexer : public Lexer<ASCII> {
    119119public:
    120         U16_Lexer(Model_Info * m,LexicalStreamSet *l);
     120        U16_Lexer(Entity_Info * e,LexicalStreamSet *l);
    121121        void Do_XML_11_WS_Control();
    122122        virtual void Do_CharsetValidation() = 0;
     
    125125class UTF_16_Lexer : public U16_Lexer {
    126126public:
    127         UTF_16_Lexer(Model_Info * m,LexicalStreamSet *l);
     127        UTF_16_Lexer(Entity_Info * e,LexicalStreamSet *l);
    128128        void Do_CharsetValidation();
    129129};
     
    131131class UCS_2_Lexer : public U16_Lexer {
    132132public:
    133         UCS_2_Lexer(Model_Info * m,LexicalStreamSet *l);
     133        UCS_2_Lexer(Entity_Info * e,LexicalStreamSet *l);
    134134        void Do_CharsetValidation();
    135135};
     
    137137class UTF_32_Lexer : public Lexer<ASCII> {
    138138public:
    139         UTF_32_Lexer(Model_Info * m,LexicalStreamSet *l);
     139        UTF_32_Lexer(Entity_Info * e,LexicalStreamSet *l);
    140140        void Do_XML_11_WS_Control();
    141141        void Do_CharsetValidation();
     
    144144class EBCDIC_Lexer: public Lexer<EBCDIC> {
    145145public:
    146         EBCDIC_Lexer(Model_Info * m,LexicalStreamSet *l);
     146        EBCDIC_Lexer(Entity_Info * e,LexicalStreamSet *l);
    147147        void Do_XML_11_WS_Control();
    148148        void Do_CharsetValidation();
  • trunk/src/byteplex.c

    r68 r100  
    2222
    2323template <CodeUnit_Base C>
    24 XML_Buffer<C>::XML_Buffer(FILE * inputfile)
     24XML_Buffer<C>::XML_Buffer()
    2525        : Byteplex() {
    26         infile = inputfile;
    2726        /* For 8-bit code units, the input buffer is a also used directly
    2827           as the pseudo-ASCII buffer; make sure that there is room for
     
    3534}
    3635
    37 Extended_ASCII_8_Buffer::Extended_ASCII_8_Buffer(FILE * infile)
    38         : XML_Buffer<ASCII>(infile) {
     36Extended_ASCII_8_Buffer::Extended_ASCII_8_Buffer()
     37        : XML_Buffer<ASCII>() {
    3938        x8data = src_buffer;
    4039        // Set the sentinel for ScanToQuote,ScanWS in reading XML/text decls.
     
    4241}
    4342
    44 EBCDIC_Buffer::EBCDIC_Buffer(FILE * infile)
    45         : XML_Buffer<EBCDIC>(infile) {
     43EBCDIC_Buffer::EBCDIC_Buffer()
     44        : XML_Buffer<EBCDIC>() {
    4645        x8data = src_buffer;
    4746        // Set the sentinel for ScanToQuote,ScanWS in reading XML/text decls.
     
    4948}
    5049
    51 U16_Buffer::U16_Buffer(FILE * infile)
    52         : XML_Buffer<ASCII>(infile) {
     50U16_Buffer::U16_Buffer()
     51        : XML_Buffer<ASCII>() {
    5352
    5453        src_buffer = simd_new((BYTEPLEX_SIZE/PACKSIZE)*2);
     
    6766}
    6867
    69 U16LE_Buffer::U16LE_Buffer(FILE * infile)
    70         : U16_Buffer(infile) {
    71 }
    72 
    73 U16BE_Buffer::U16BE_Buffer(FILE * infile)
    74         : U16_Buffer(infile) {
    75 }
    76 
    77 U32_Buffer::U32_Buffer(FILE * infile)
    78         : XML_Buffer<ASCII>(infile) {
     68U16LE_Buffer::U16LE_Buffer()
     69        : U16_Buffer() {
     70}
     71
     72U16BE_Buffer::U16BE_Buffer()
     73        : U16_Buffer() {
     74}
     75
     76U32_Buffer::U32_Buffer()
     77        : XML_Buffer<ASCII>() {
    7978
    8079        src_buffer = simd_new((BYTEPLEX_SIZE/PACKSIZE)*4);
     
    9897}
    9998
    100 U32LE_Buffer::U32LE_Buffer(FILE * infile)
    101         : U32_Buffer(infile) {
    102 }
    103 
    104 U32BE_Buffer::U32BE_Buffer(FILE * infile)
    105         : U32_Buffer(infile) {
    106 }
    107 
    108 U32_2143_Buffer::U32_2143_Buffer(FILE * infile)
    109         : U32_Buffer(infile) {
    110 }
    111 
    112 U32_3412_Buffer::U32_3412_Buffer(FILE * infile)
    113         : U32_Buffer(infile) {
     99U32LE_Buffer::U32LE_Buffer()
     100        : U32_Buffer() {
     101}
     102
     103U32BE_Buffer::U32BE_Buffer()
     104        : U32_Buffer() {
     105}
     106
     107U32_2143_Buffer::U32_2143_Buffer()
     108        : U32_Buffer() {
     109}
     110
     111U32_3412_Buffer::U32_3412_Buffer()
     112        : U32_Buffer() {
    114113}
    115114
     
    314313}
    315314
    316 Byteplex * Byteplex::ByteplexFactory(Model_Info * m, FILE * inputfile) {
    317         if (likely(m->code_unit_size == SingleByte)) {
    318                 if (likely(m->code_unit_base == ASCII))
    319                         return new Extended_ASCII_8_Buffer(inputfile);
    320                 return new EBCDIC_Buffer(inputfile);
    321         }
    322         else if (likely(m->code_unit_size == DoubleByte)) {
    323                 if (likely(m->byte_order == BigEndian))
    324                         return new U16BE_Buffer(inputfile);
    325                 else return new U16LE_Buffer(inputfile);
    326         }
    327         else switch (m->byte_order) {
    328                 case BigEndian: return new U32BE_Buffer(inputfile);
    329                 case LittleEndian: return new U32LE_Buffer(inputfile);
    330                 case Unusual_2143: return new U32_2143_Buffer(inputfile);
    331                 case Unusual_3412: return new U32_3412_Buffer(inputfile);
     315Byteplex * Byteplex::ByteplexFactory(Entity_Info * e) {
     316        Byteplex * b;
     317        if (likely(e->code_unit_size == SingleByte)) {
     318                if (likely(e->code_unit_base == ASCII))
     319                        b = new Extended_ASCII_8_Buffer();
     320                else b = new EBCDIC_Buffer();
     321        }
     322        else if (likely(e->code_unit_size == DoubleByte)) {
     323                if (likely(e->byte_order == BigEndian))
     324                        b = new U16BE_Buffer();
     325                else b = new U16LE_Buffer();
     326        }
     327        else switch (e->byte_order) {
     328                case BigEndian: b = new U32BE_Buffer(); break;
     329                case LittleEndian: b = new U32LE_Buffer(); break;
     330                case Unusual_2143: b = new U32_2143_Buffer(); break;
     331                case Unusual_3412: b = new U32_3412_Buffer(); break;
    332332        }       
    333 }
    334 
     333        return b;
     334}
     335
     336Byteplex * Byteplex::ByteplexFactory(Entity_Info * e, FILE * inputfile) {
     337        Byteplex * b = ByteplexFactory(e);
     338        b->infile = inputfile;
     339        return b;
     340}
     341       
     342Byteplex * Byteplex::ByteplexFactory(Entity_Info * e, unsigned char * buffer_bytes, int buffer_size) {
     343        Byteplex * b = ByteplexFactory(e);
     344        memcpy(b->src_buffer, buffer_bytes, buffer_size);
     345    printf("buffer_bytes = %s\n", buffer_bytes);
     346        b->units_in_buffer = buffer_size / e->code_unit_size;
     347        b->packs_in_buffer = (b->units_in_buffer + PACKSIZE -1)/PACKSIZE;
     348        return b;
     349}
  • trunk/src/byteplex.h

    r87 r100  
    7373class Byteplex {
    7474public:
    75         static Byteplex * ByteplexFactory(Model_Info * m, FILE * inputfile);
     75        static Byteplex * ByteplexFactory(Entity_Info * e);
     76        static Byteplex * ByteplexFactory(Entity_Info * e, FILE * inputfile);
     77        static Byteplex * ByteplexFactory(Entity_Info * e, unsigned char * buffer_bytes, int buffer_size);
    7678        virtual void DoByteplex() = 0;
    7779        virtual void PreparePseudoASCII_Stream() = 0;
     
    7981        virtual void AdvanceInputBuffer(int advance_amt) = 0;
    8082
    81         FILE * infile;
    82 
    8383        /* Source code unit buffer. */
    8484        BytePack * src_buffer;
     
    8989
    9090protected:
    91 
     91        FILE * infile;
    9292        int packs_in_buffer;
    9393        void Set_limits(int units_in_buffer);
     
    9898class XML_Buffer : public Byteplex {
    9999public:
    100         XML_Buffer (FILE * infile);
     100        XML_Buffer ();
    101101        ~XML_Buffer();
    102102       
     
    116116class Extended_ASCII_8_Buffer : public XML_Buffer<ASCII> {
    117117public:
    118         Extended_ASCII_8_Buffer(FILE * infile);
     118        Extended_ASCII_8_Buffer();
    119119        void DoByteplex();
    120120        void PreparePseudoASCII_Stream();
     
    128128class EBCDIC_Buffer : public XML_Buffer<EBCDIC> {
    129129public:
    130         EBCDIC_Buffer(FILE * infile);
     130        EBCDIC_Buffer();
    131131        void DoByteplex();
    132132        void PreparePseudoASCII_Stream();
     
    145145class U16_Buffer : public XML_Buffer<ASCII> {
    146146public:
    147         U16_Buffer(FILE * infile);
     147        U16_Buffer();
    148148        ~U16_Buffer();
    149149        virtual void DoByteplex() = 0;
     
    158158class U16LE_Buffer : public U16_Buffer {
    159159public:
    160         U16LE_Buffer(FILE * infile);
     160        U16LE_Buffer();
    161161        void DoByteplex();
    162162};
     
    164164class U16BE_Buffer : public U16_Buffer {
    165165public:
    166         U16BE_Buffer(FILE * infile);
     166        U16BE_Buffer();
    167167        void DoByteplex();
    168168};
     
    176176class U32_Buffer : public XML_Buffer<ASCII> {
    177177public:
    178         U32_Buffer(FILE * infile);
     178        U32_Buffer();
    179179        ~U32_Buffer();
    180180        virtual void DoByteplex() = 0;
     
    191191class U32LE_Buffer : public U32_Buffer {
    192192public:
    193         U32LE_Buffer(FILE * infile);
     193        U32LE_Buffer();
    194194        void DoByteplex();
    195195};
     
    197197class U32BE_Buffer : public U32_Buffer {
    198198public:
    199         U32BE_Buffer(FILE * infile);
     199        U32BE_Buffer();
    200200        void DoByteplex();
    201201};
     
    203203class U32_2143_Buffer : public U32_Buffer {
    204204public:
    205         U32_2143_Buffer(FILE * infile);
     205        U32_2143_Buffer();
    206206        void DoByteplex();
    207207};
     
    209209class U32_3412_Buffer : public U32_Buffer {
    210210public:
    211         U32_3412_Buffer(FILE * infile);
     211        U32_3412_Buffer();
    212212        void DoByteplex();
    213213};
  • trunk/src/engine.c

    r99 r100  
    2020#include <iostream>
    2121using namespace std;
    22 
    23 Parser_Interface * Parser_Interface::ParserFactory(char * filename, bool is_external) {
     22       
     23inline char * copy_string (unsigned char * s, int lgth){               
     24        char * d = new char[lgth+1];
     25        memcpy(d, (char *)s,lgth);
     26        d[lgth] = '\0';
     27        return d;
     28}
     29
     30Parser_Interface * Parser_Interface::ParserFactory(char * filename) {
    2431       
    2532        int chars_read;
     
    3239        }
    3340        fread(signature,1,4,infile);
     41        Entity_Info * e = new Entity_Info;
    3442        Model_Info * m = new Model_Info;
    35         m->AnalyzeSignature(signature);
    36         Byteplex * b = Byteplex::ByteplexFactory(m, infile);
     43        e->AnalyzeSignature(signature);
     44        Byteplex * b = Byteplex::ByteplexFactory(e, infile);
    3745        b->InitializeBuffer(signature,4);
    3846
    39         if (m->code_unit_base == ASCII) {
    40                 return new ParsingEngine<ASCII>(m, b, is_external);
    41         }
    42         else /* if (m->code_unit_base == EBCDIC) */ {
    43                 return new ParsingEngine<EBCDIC>(m, b, is_external);
     47        if (e->code_unit_base == ASCII) {
     48                return new ParsingEngine<ASCII>(e, m, b, false);
     49        }
     50        else /* if (e->code_unit_base == EBCDIC) */ {
     51                return new ParsingEngine<EBCDIC>(e, m, b, false);
    4452        }       
    4553}
    4654
    47 Parser_Interface * Parser_Interface::ParserFactory(unsigned char * byte_buffer, int byte_count, Model_Info * m);
    48         Byteplex * b = Byteplex::ByteplexFactory(m, byte_buffer, byte_count);
    49         if (m->code_unit_base == ASCII) {
    50                 return new ParsingEngine<ASCII>(m, b, false);
    51         }
    52         else /* if (m->code_unit_base == EBCDIC) */ {
    53                 return new ParsingEngine<EBCDIC>(m, b, false);
     55Parser_Interface * Parser_Interface::ParserFactory(char * filename, Model_Info * m) {
     56       
     57        int chars_read;
     58        unsigned char signature[4];
     59        FILE * infile;
     60        infile = fopen(filename, "rb");
     61        if (!infile) {
     62                fprintf(stderr, "Error: cannot open %s for input.\n", filename);
     63                exit(-1);
     64        }
     65        fread(signature,1,4,infile);
     66        Entity_Info * e = new Entity_Info;
     67        e->AnalyzeSignature(signature);
     68        Byteplex * b = Byteplex::ByteplexFactory(e, infile);
     69        b->InitializeBuffer(signature,4);
     70
     71        if (e->code_unit_base == ASCII) {
     72                return new ParsingEngine<ASCII>(e, m, b, true);
     73        }
     74        else /* if (e->code_unit_base == EBCDIC) */ {
     75                return new ParsingEngine<EBCDIC>(e, m, b, true);
    5476        }       
    5577}
    5678
     79Parser_Interface * Parser_Interface::ParserFactory(char * byte_buffer, int byte_count, Entity_Info * e, Model_Info * m){
     80        Byteplex * b = Byteplex::ByteplexFactory(e, (unsigned char *) byte_buffer, byte_count);
     81        if (e->code_unit_base == ASCII) {
     82                return new ParsingEngine<ASCII>(e, m, b, false);
     83        }
     84        else {
     85                return new ParsingEngine<EBCDIC>(e, m, b, false);
     86        }       
     87}
    5788
    5889Parser_Interface::~Parser_Interface() {
     
    6192
    6293bool Parser_Interface::has_ByteOrderMark() {
    63         return model_info->BOM_units > 0;
     94        return entity_Info->BOM_units > 0;
    6495}
    6596
    6697XML_version Parser_Interface::get_version() {
    67         return model_info->version;
     98        return entity_Info->version;
    6899}
    69100
    70101XML_standalone Parser_Interface::standalone_status() {
    71         return model_info->standalone;
     102        return entity_Info->standalone;
    72103}
    73104
    74105bool Parser_Interface::has_EncodingDecl() {
    75         return model_info->has_encoding_decl;
     106        return entity_Info->has_encoding_decl;
    76107}
    77108
    78109unsigned char * Parser_Interface::get_Encoding() {
    79         return model_info->encoding;
     110        return entity_Info->encoding;
    80111}
    81112
    82113unsigned char * Parser_Interface::GetCodeUnitPtr(int pos) {
    83114        int rel_pos = pos - buffer_base_pos;
    84         return &((unsigned char *) (byteplex->src_buffer))[rel_pos * (int) model_info->code_unit_size];
    85 }
    86 
    87 
    88 
    89 
    90 template <CodeUnit_Base C>
    91 ParsingEngine<C>::ParsingEngine(Model_Info * m, Byteplex * b, bool is_external) : Parser_Interface () {
    92 
     115        return &((unsigned char *) (byteplex->src_buffer))[rel_pos * (int) entity_Info->code_unit_size];
     116}
     117
     118
     119
     120
     121template <CodeUnit_Base C>
     122ParsingEngine<C>::ParsingEngine(Entity_Info * e, Model_Info * m, Byteplex * b, bool is_external) : Parser_Interface () {
     123        entity_Info = e;
    93124        model_info = m;
    94125        byteplex = b;
     
    97128        byteplex->PreparePseudoASCII_Stream();
    98129         StrictWellFormedness=false;
    99         LastAttOccurrence.push_back(0);
     130        LastAttOccurrence.assign(m->globalAttributeCount+1, 0);
     131//      LastAttOccurrence.push_back(0);
    100132       
    101133        decl_parser = new XML_Decl_Parser<C>(byteplex);
    102134        int content_start = 0;
    103135        if(is_external == true)
    104                 content_start = decl_parser->ReadTextDeclaration(model_info);
     136                content_start = decl_parser->ReadTextDeclaration(entity_Info);
    105137        else
    106                 content_start = decl_parser->ReadXMLInfo(model_info);
     138                content_start = decl_parser->ReadXMLInfo(entity_Info);
    107139       
    108140        bitplex = new Bitplex;
     
    125157        int blocks_in_buffer = (buffer_limit_pos + BLOCKSIZE - 1)/BLOCKSIZE;
    126158        x8data = byteplex->x8data;
    127         lexer = Lexer<C>::LexerFactory(m, buf);
     159        lexer = Lexer<C>::LexerFactory(e, buf);
    128160        bitplex->TransposeToBitStreams(byteplex->x8data, blocks_in_buffer);
    129161        lexer->AnalyzeBuffer(bitplex->x8basis, buffer_limit_pos);
     
    132164template <CodeUnit_Base C>
    133165ParsingEngine<C>::~ParsingEngine() {
    134   model_info->~Model_Info();
     166  // How do we do this?  model_info->~Model_Info();
     167  entity_Info->~Entity_Info();
    135168  byteplex->~Byteplex();
    136169  decl_parser->~XML_Decl_Parser<C>();
     
    343376template <CodeUnit_Base C>
    344377inline void ParsingEngine<C>::Parse_EntityRef() {
    345         Advance(1);  // skip "&"
     378    Advance(1);  // skip "&"
     379    int ref_start = AbsPos();
    346380        ScanTo(NameFollow);  /* Name delimiter */
    347         if (!AtChar<C,';'>(cur())) {
     381    if (!AtChar<C,';'>(cur())) {
    348382                Syntax_Error(NT_Reference);
    349         }
     383    }
    350384        else {
     385                int lgth = AbsPos()-ref_start;
     386                char * s = new char[lgth+1];
     387                memcpy(s, GetCodeUnitPtr(ref_start),lgth);
     388                s[lgth] = '\0';
     389               
    351390                Advance(1);
    352391                Reference_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    353 //      The following code will replace Reference_Action.
    354 //              entity_info = LookupEntity();
    355 //              ParserInterface * entity_parser;
    356 //              if (entity_info->is_external) {
    357 //                      entity_parser = ParserFactory(filename, model_info);
    358 //              }
    359 //              else {
    360 //                      replText = GetReplacementText(LookupEntity());
    361 //                      entity_parser = ParserFactory(replText, strlen(replText), model_info);
    362 //              }
    363 //              entity_parser->ParseContent();
    364 //              entity_parser->~ParserInterface();
     392               
     393                //      The following code will replace Reference_Action.
     394                GEntity_info * this_info;
     395                Parser_Interface * entity_parser;
     396                int entityID = model_info->GlobalGEntityTable[s];
     397                if (entityID == 0)
     398                        WF_Error(wfErr_wf_entdeclared);
     399                else{
     400                        this_info = model_info->GEntityData[entityID-1];
     401                        if (this_info->is_external){
     402                                entity_parser = ParserFactory(this_info->systemLiteral, model_info);
     403                                entity_parser->ParseContent();
     404                                entity_parser->~Parser_Interface();
     405                        }
     406                        else {
     407                                if (this_info->is_simple == true)
     408                                        printf("Entity is %s\n",this_info->ReplacementText);
     409                                else{
     410                                        printf("Not a simple text: %s\n",this_info->ReplacementText);
     411                                        entity_parser = ParserFactory(this_info->ReplacementText, strlen(this_info->ReplacementText),entity_Info, model_info);
     412                                        entity_parser->ParseContent();
     413                                        entity_parser->~Parser_Interface();
     414                                }
     415                        }
     416                }
     417               
    365418        }
    366419}
     
    10341087       
    10351088        int name_start;
     1089        int quot_start;
    10361090        int lgth;
    10371091        int old_abspos;
     1092        char * s;
     1093       
    10381094        Advance(6); /* Skip "ENTITY. */
    10391095        requireWS();
     
    10461102                ScanTo(NameFollow);
    10471103                lgth = AbsPos()- name_start;
    1048                 char *s = new char[lgth+1];
    1049                 memcpy(s, GetCodeUnitPtr(name_start), lgth);
     1104                s = new char[lgth+1];
     1105                memcpy(s, GetCodeUnitPtr(name_start),lgth);
    10501106                s[lgth] = '\0';
    10511107       
    1052                 int entityID = model_info->GlobalEntityTable[s];
     1108                PEntity_info * this_info = new PEntity_info;
     1109                int entityID = model_info->GlobalPEntityTable[s];
    10531110                if(entityID==0){       
    1054                         model_info->GlobalEntityTable[s]=++(model_info->globalEntityCount);
    1055                         entityID = model_info->globalEntityCount;
     1111                        model_info->GlobalPEntityTable[s]=++(model_info->globalPEntityCount);
     1112                        entityID = model_info->globalPEntityCount;
     1113                        this_info->globalPEntity_id = entityID;
    10561114                }
    10571115                else
     
    10591117       
    10601118                requireWS();
    1061                 if(at_SYSTEM<C>(cur())||at_PUBLIC<C>(cur())){
    1062                 Parse_ExternalID();     
    1063         }
     1119                if(at_SYSTEM<C>(cur())){
     1120                        Advance(6);
     1121                        requireWS();
     1122                        quot_start = AbsPos()+1;
     1123                        Parse_MatchedQuote (); /*  SystemLiteral */
     1124                        lgth = AbsPos() - quot_start - 1;                       
     1125                        this_info->systemLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
     1126                        this_info->is_external = true;
     1127                }
     1128                else if (at_PUBLIC<C>(cur())){
     1129                        Advance(6);
     1130                        requireWS();
     1131                       
     1132                        quot_start = AbsPos()+1;
     1133                        Parse_MatchedQuote ();/*  PubidLiteral */               
     1134                        lgth = AbsPos() - quot_start - 1;                       
     1135                        this_info->pubidLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
     1136                        this_info->is_external = true; 
     1137                       
     1138                        requireWS();
     1139                       
     1140                        quot_start = AbsPos()+1;
     1141                        Parse_MatchedQuote (); /*  SystemLiteral */
     1142                        lgth = AbsPos() - quot_start - 1;                       
     1143                        this_info->systemLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
     1144                        this_info->is_external = true;
     1145                }
    10641146        else if(AtQuote<C>(cur())){
    1065                 Parse_AttValue(); /* Not parse PEReference*/
     1147                Parse_PEntityValue(this_info);
     1148                this_info->is_external = false;
    10661149        }
    10671150        else
    10681151                Syntax_Error(NT_EntityDecl);
     1152        model_info->PEntityData.push_back(this_info);
    10691153        }
    10701154        else{
     
    10721156                ScanTo(NameFollow);
    10731157                lgth = AbsPos()- name_start;
    1074                 char *s = new char[lgth+1];
    1075                 memcpy(s, GetCodeUnitPtr(name_start), lgth);
     1158                s = new char[lgth+1];
     1159                memcpy(s, GetCodeUnitPtr(name_start),lgth);
    10761160                s[lgth] = '\0';
    10771161       
    1078                 int entityID = model_info->GlobalEntityTable[s];
     1162                GEntity_info * this_info = new GEntity_info;
     1163                int entityID = model_info->GlobalGEntityTable[s];
    10791164                if(entityID==0){       
    1080                         model_info->GlobalEntityTable[s]=++(model_info->globalEntityCount);
    1081                         entityID = model_info->globalEntityCount;
     1165                        model_info->GlobalGEntityTable[s]=++(model_info->globalGEntityCount);
     1166                        entityID = model_info->globalGEntityCount;
     1167                        this_info->globalGEntity_id = entityID;
    10821168                }
    10831169                else
     
    10861172                requireWS();
    10871173               
    1088                 if(at_SYSTEM<C>(cur())||at_PUBLIC<C>(cur())){
    1089                 Parse_ExternalID();
    1090                 ScanTo(NonWS);
     1174                if(at_SYSTEM<C>(cur())){
     1175                        Advance(6);
     1176                        requireWS();
     1177                        quot_start = AbsPos()+1;
     1178                        Parse_MatchedQuote (); /*  SystemLiteral */
     1179                        lgth = AbsPos() - quot_start - 1;                       
     1180                        this_info->systemLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
     1181                        this_info->is_external = true;
     1182                       
     1183                        old_abspos = AbsPos();
     1184                        ScanTo(NonWS);
    10911185                if(at_NDATA<C>(cur())){
    10921186                        if(old_abspos == AbsPos())
     
    10951189                                Advance(5);
    10961190                        requireWS();
     1191                        name_start = AbsPos();
    10971192                        ScanTo(NameFollow);
     1193                        lgth = AbsPos() - name_start;
     1194                                this_info->NDataName = copy_string(GetCodeUnitPtr(name_start),lgth);
    10981195                }
    1099         }
    1100         else if(AtQuote<C>(cur())){
    1101                 Parse_AttValue(); /* Not parse PEReference*/
     1196                }
     1197                else if (at_PUBLIC<C>(cur())){
     1198                        Advance(6);
     1199                        requireWS();
     1200                       
     1201                        quot_start = AbsPos()+1;
     1202                        Parse_MatchedQuote ();/*  PubidLiteral */               
     1203                        lgth = AbsPos() - quot_start - 1;                       
     1204                        this_info->pubidLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
     1205                        this_info->is_external = true; 
     1206                       
     1207                        requireWS();
     1208                       
     1209                        quot_start = AbsPos()+1;
     1210                        Parse_MatchedQuote (); /*  SystemLiteral */
     1211                        lgth = AbsPos() - quot_start - 1;                       
     1212                        this_info->systemLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
     1213                        this_info->is_external = true;
     1214                       
     1215                        old_abspos = AbsPos();
     1216                        ScanTo(NonWS);
     1217                if(at_NDATA<C>(cur())){
     1218                        if(old_abspos == AbsPos())
     1219                                Syntax_Error(NT_EntityDecl);
     1220                        else
     1221                                Advance(5);
     1222                        requireWS();
     1223                        name_start = AbsPos();
     1224                        ScanTo(NameFollow);
     1225                        lgth = AbsPos() - name_start;
     1226                        this_info->NDataName = copy_string(GetCodeUnitPtr(name_start),lgth);
     1227                }
     1228                }
     1229                else if(AtQuote<C>(cur())){
     1230                Parse_GEntityValue(this_info);
     1231                this_info->is_external = false;
    11021232        }
    11031233        else
    11041234                Syntax_Error(NT_EntityDecl);
     1235        model_info->GEntityData.push_back(this_info);
    11051236        }
    11061237        ScanTo(NonWS);
     
    11131244                Syntax_Error(NT_EntityDecl);
    11141245}
    1115 
     1246       
    11161247template <CodeUnit_Base C>
    11171248inline void ParsingEngine<C>::Parse_Notationdecl (){
     
    11981329        }
    11991330        Advance(1);
     1331}
     1332
     1333template <CodeUnit_Base C>
     1334inline void ParsingEngine<C>::Parse_GEntityValue(GEntity_info * this_info){
     1335       
     1336        int     quoteCh = cur()[0];
     1337        Advance(1); /* Skip " or ' */
     1338        this_info->is_simple = true;
     1339        int quot_start = AbsPos();
     1340        ScanTo(Quote);         
     1341        char *  replText = copy_string(GetCodeUnitPtr(quot_start),AbsPos()-quot_start);
     1342
     1343        while (cur()[0] != quoteCh){
     1344                if (at_CharRef_Start<C>(cur())){
     1345                        strcat (replText,Replace_CharRef());
     1346                        quot_start = AbsPos();
     1347                        ScanTo(Quote);
     1348                }
     1349                else if (AtChar<C,'&'>(cur())){
     1350                        strcat (replText,Replace_EntityRef(this_info->is_simple));
     1351                        quot_start = AbsPos();
     1352                        ScanTo(Quote);
     1353                }
     1354                else if (AtQuote<C>(cur())) {
     1355                        quot_start = AbsPos();
     1356                        Advance(1);
     1357                        ScanTo(Quote);
     1358
     1359                }
     1360                else { /* '<' found */
     1361                        quot_start = AbsPos();
     1362                        Advance(1);
     1363                        ScanTo(Quote);
     1364                        this_info->is_simple = false;
     1365                }
     1366                strcat (replText,copy_string(GetCodeUnitPtr(quot_start),AbsPos()-quot_start));                 
     1367        }
     1368        this_info->ReplacementText = replText;
     1369        Advance(1);
     1370}
     1371
     1372template <CodeUnit_Base C>
     1373inline char * ParsingEngine<C>::Replace_EntityRef(bool& is_simple){
     1374        Advance(1);
     1375        int entity_start = AbsPos();
     1376        ScanTo(NameFollow);
     1377        char * s = copy_string(GetCodeUnitPtr(entity_start),AbsPos()-entity_start);
     1378        if (AtChar<C,';'>(cur()))
     1379                Advance(1);
     1380        else
     1381                Syntax_Error(NT_EntityValue);
     1382        int entityID = model_info->GlobalGEntityTable[s];
     1383        if (entityID == 0)
     1384                WF_Error(wfErr_wf_entdeclared);
     1385        else{
     1386                if (model_info->GEntityData[entityID-1]->is_simple == false)
     1387                        is_simple = false;
     1388                return model_info->GEntityData[entityID-1]->ReplacementText;
     1389        }
     1390       
     1391}
     1392
     1393template <CodeUnit_Base C>
     1394inline void ParsingEngine<C>::Parse_PEntityValue(PEntity_info * this_info){
     1395}
     1396
     1397template <CodeUnit_Base C>
     1398inline char * ParsingEngine<C>::Replace_CharRef(){
     1399        Advance(1);
     1400        int entity_start = AbsPos();
     1401        ScanTo(NameFollow);
     1402        char * s = copy_string(GetCodeUnitPtr(entity_start),AbsPos()-entity_start);
     1403        int entityID = model_info->GlobalGEntityTable[s];
     1404        if (entityID == 0)
     1405                WF_Error(wfErr_wf_entdeclared);
     1406        else
     1407                return model_info->GEntityData[entityID-1]->ReplacementText;
     1408       
     1409       
    12001410}
    12011411
     
    12251435        }
    12261436        Prolog_action(GetCodeUnitPtr(old_pos), LengthFrom(old_pos));
    1227 }
    1228 
    1229 template <CodeUnit_Base C>
    1230 inline void ParsingEngine<C>::ExtSubsetDecl_action(unsigned char * item, int lgth) {
    12311437}
    12321438
  • trunk/src/engine.h

    r99 r100  
    2121public:
    2222        ~Parser_Interface();
    23         static Parser_Interface * ParserFactory(char * filename, bool is_external);
     23        static Parser_Interface * ParserFactory(char * filename);
     24        static Parser_Interface * ParserFactory(char * filename, Model_Info * m);
    2425        // Constructor for a subsidiary parser for internal entities.
    25         static Parser_Interface * ParserFactory(unsigned char * byte_buffer, int byte_count, Model_Info * m);
     26        static Parser_Interface * ParserFactory(char * byte_buffer, int byte_count, Entity_Info * e, Model_Info * m);
    2627        virtual void ParseContent() = 0;
    2728        virtual void Parse_ExtSubsetDecl() = 0;
     
    3435        unsigned char * get_Encoding();
    3536        Model_Info * model_info;
     37        Entity_Info * entity_Info;
    3638protected:
    3739        /* Co-classes */
     
    5355class ParsingEngine : public Parser_Interface {
    5456public:
    55         ParsingEngine(Model_Info * m, Byteplex * b, bool is_external);
     57        ParsingEngine(Entity_Info * e, Model_Info * m, Byteplex * b, bool is_external);
    5658        ~ParsingEngine();
    5759        void ParseContent();
     
    111113        void requireWS ();
    112114        void Parse_AttValue ();
    113        
     115        void Parse_GEntityValue(GEntity_info * this_info);
     116        void Parse_PEntityValue(PEntity_info * this_info);
     117        char * Replace_EntityRef(bool& is_simple);
     118        char * Replace_CharRef();
    114119        void Parse_Prolog();
    115120               
  • trunk/src/xmldecl.c

    r91 r100  
    7474
    7575template <CodeUnit_Base C>
    76 int XML_Decl_Parser<C>::EncodingAction(Model_Info * m, int start_pos, int end_pos) {
    77         m->encoding = (unsigned char *) malloc(end_pos-start_pos+1);
    78         memcpy(m->encoding, &x8data[start_pos-buffer_base_pos], end_pos - start_pos);
    79         m->encoding[end_pos - start_pos] = '\0';
     76int XML_Decl_Parser<C>::EncodingAction(Entity_Info *e, int start_pos, int end_pos) {
     77        e->encoding = (unsigned char *) malloc(end_pos-start_pos+1);
     78        memcpy(e->encoding, &x8data[start_pos-buffer_base_pos], end_pos - start_pos);
     79        e->encoding[end_pos - start_pos] = '\0';
    8080}
    8181//
    8282template <CodeUnit_Base C>
    83 int XML_Decl_Parser<C>::ReadXMLInfo(Model_Info * m) {
    84         m->version = no_XML_version_value;
    85         m->has_encoding_decl = false;
    86         m->standalone = Standalone_no_value;
    87         buffer_rel_pos = m->BOM_units;
     83int XML_Decl_Parser<C>::ReadXMLInfo(Entity_Info *e) {
     84        e->version = no_XML_version_value;
     85        e->has_encoding_decl = false;
     86        e->standalone = Standalone_no_value;
     87        buffer_rel_pos = e->BOM_units;
    8888        // It is possible that there is no XML declaration.
    8989        if (!at_XmlDecl_start<C>(cur())) {
     
    100100        Advance(1);
    101101        Scan_WS();
    102         if (at_1_0<C>(cur())) m->version = XML_1_0;
    103         else if (at_1_1<C>(cur())) m->version = XML_1_1;
     102        if (at_1_0<C>(cur())) e->version = XML_1_0;
     103        else if (at_1_1<C>(cur())) e->version = XML_1_1;
    104104        else DeclarationError(AbsPos());
    105105        Advance(5);
     
    108108        Scan_WS();
    109109        if (at_encoding<C>(cur())) {
    110                 m->has_encoding_decl = true;
     110                e->has_encoding_decl = true;
    111111                Advance(8);
    112112                Scan_WS();
     
    120120                        ScanToQuote();
    121121                        if (cur()[0] != quoteCh) DeclarationError(AbsPos());
    122                         EncodingAction(m, encoding_start_pos, AbsPos());
     122                        EncodingAction(e, encoding_start_pos, AbsPos());
    123123                }
    124124                else DeclarationError(AbsPos());
     
    134134                Advance(1);
    135135                Scan_WS();
    136                 if (at_yes<C>(cur())) {Advance(5); m->standalone = Standalone_yes;}
    137                 else if (at_no<C>(cur())) {Advance(4); m->standalone = Standalone_no;}
     136                if (at_yes<C>(cur())) {Advance(5); e->standalone = Standalone_yes;}
     137                else if (at_no<C>(cur())) {Advance(4); e->standalone = Standalone_no;}
    138138                else DeclarationError(AbsPos());
    139139                Scan_WS();
     
    148148// processing.
    149149template <CodeUnit_Base C>
    150 int XML_Decl_Parser<C>::ReadTextDeclaration(Model_Info * m) {
    151         m->version = no_XML_version_value;
    152         m->has_encoding_decl = false;
    153         m->standalone = Standalone_no_value;
    154         buffer_rel_pos = m->BOM_units;
     150int XML_Decl_Parser<C>::ReadTextDeclaration(Entity_Info *e) {
     151        e->version = no_XML_version_value;
     152        e->has_encoding_decl = false;
     153        e->standalone = Standalone_no_value;
     154        buffer_rel_pos = e->BOM_units;
    155155        // It is possible that there is no XML declaration.
    156156        if (!at_XmlDecl_start<C>(cur())) {
     
    167167                Advance(1);
    168168                Scan_WS();
    169                 if (at_1_0<C>(cur())) m->version = XML_1_0;
    170                 else if (at_1_1<C>(cur())) m->version = XML_1_1;
     169                if (at_1_0<C>(cur())) e->version = XML_1_0;
     170                else if (at_1_1<C>(cur())) e->version = XML_1_1;
    171171                else DeclarationError(AbsPos());
    172172                Advance(5);
     
    176176        }
    177177        if (!at_encoding<C>(cur())) DeclarationError(AbsPos());
    178         m->has_encoding_decl = true;
     178        e->has_encoding_decl = true;
    179179        Advance(8);
    180180        Scan_WS();
     
    188188                ScanToQuote();
    189189                if (cur()[0] != quoteCh) DeclarationError(AbsPos());
    190                 EncodingAction(m, encoding_start_pos, AbsPos());
     190                EncodingAction(e, encoding_start_pos, AbsPos());
    191191        }
    192192        else DeclarationError(AbsPos());
  • trunk/src/xmldecl.h

    r91 r100  
    1818        ~XML_Decl_Parser ();
    1919       
    20         int ReadXMLInfo(Model_Info * m);
    21         int ReadTextDeclaration(Model_Info * m);
     20        int ReadXMLInfo(Entity_Info * e);
     21        int ReadTextDeclaration(Entity_Info * e);
    2222       
    2323
     
    3434        unsigned char * cur() const;
    3535       
    36         int EncodingAction(Model_Info * m, int start_pos, int end_pos);
     36        int EncodingAction(Entity_Info * e, int start_pos, int end_pos);
    3737private:
    3838        /* Bytespace parsing routines for internal use in ReadXMLInfo and
  • trunk/src/xmlmodel.c

    r91 r100  
    1717
    1818Model_Info::~Model_Info() {
     19}
     20
     21Entity_Info::Entity_Info() {
     22}
     23Entity_Info::~Entity_Info() {
    1924        free(encoding);
    2025}
     
    3439static const int xEFBE = b2int16<0xEF, 0xBE>::value;
    3540
    36 void Model_Info::AnalyzeSignature(unsigned char * signature) {
     41void Entity_Info::AnalyzeSignature(unsigned char * signature) {
    3742        uint16_t * XML_dbl_byte = (uint16_t *) signature;
    3843        switch (XML_dbl_byte[0]) {
     
    7984        }
    8085}
    81 void Model_Info::set_charset_family(CodeUnit_Base C, CodeUnit_Size S, CodeUnit_ByteOrder O, int B){
     86void Entity_Info::set_charset_family(CodeUnit_Base C, CodeUnit_Size S, CodeUnit_ByteOrder O, int B){
    8287                code_unit_base = C;
    8388                code_unit_size = S;
  • trunk/src/xmlmodel.h

    r97 r100  
    101101};
    102102
     103
     104class GEntity_info {
     105public:
     106        int globalGEntity_id;
     107        bool is_external;
     108        char * ReplacementText;
     109        char * systemLiteral;
     110        char * pubidLiteral;   
     111        char * NDataName;
     112        bool is_simple;
     113};
     114
     115class PEntity_info {
     116public:
     117        int globalPEntity_id;
     118        bool is_external;
     119        char * ReplacementText;
     120        char * systemLiteral;
     121        char * pubidLiteral;   
     122};
     123
    103124/* The complete Attribute model for a given element is a vector of ATT_info
    104125   specifications for particular attribute names. */
    105126//typedef vector<ATT_info> ElementAttributeModel;
    106127
    107 class Model_Info {
     128
     129
     130class Entity_Info {
    108131       
    109132public:
    110         Model_Info();
    111         ~Model_Info();
     133        Entity_Info();
     134        ~Entity_Info();
    112135
    113136        /*  Information computed by analyzing the 4-byte initial signature
     
    127150        XML_standalone standalone;
    128151       
     152private:
     153        void set_charset_family(CodeUnit_Base C, CodeUnit_Size S, CodeUnit_ByteOrder O, int B);
     154};
     155
     156class Model_Info {
     157       
     158public:
     159        Model_Info();
     160        ~Model_Info();
     161   
    129162        /* Information computed from ATTLIST, ELEMENT, NOTATION and ENTITY declarations. */
    130163        hash_map<const char *, int, hash<const char *>, eqstr > GlobalAttributeTable;
    131164        hash_map<const char *, int, hash<const char *>, eqstr > GlobalElementTable;
    132165        hash_map<const char *, int, hash<const char *>, eqstr > GlobalNotationTable;
    133         hash_map<const char *, int, hash<const char *>, eqstr > GlobalEntityTable;
     166        hash_map<const char *, int, hash<const char *>, eqstr > GlobalGEntityTable;
     167        hash_map<const char *, int, hash<const char *>, eqstr > GlobalPEntityTable;
    134168        int globalElementCount;
    135169        int globalAttributeCount;
    136170        int globalNotationCount;
    137         int globalEntityCount;
     171        int globalGEntityCount;
     172        int globalPEntityCount;
    138173       
    139174    /* For each element, we have an ElementAttributeModel */
     
    142177        int getOrInsertGlobalAttName(unsigned char * att_name, int lgth);
    143178       
    144 private:
    145         void set_charset_family(CodeUnit_Base C, CodeUnit_Size S, CodeUnit_ByteOrder O, int B);
     179        vector<GEntity_info *> GEntityData;
     180        vector<PEntity_info *> PEntityData;
     181
    146182};
    147183
Note: See TracChangeset for help on using the changeset viewer.