Changeset 197 for trunk


Ignore:
Timestamp:
Oct 2, 2008, 11:15:25 AM (11 years ago)
Author:
cameron
Message:

Rearchitecting for WorkingCharacterSet?, Document Characet Set

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/markup_stats.cxx

    r194 r197  
    7979
    8080/* Global declarations of parsing engine. */
    81 Parser_Interface * parser;
     81Parser_Interface<UTF_8> * parser;
    8282
    8383/* Global declarations for statistics. */
     
    125125
    126126/* Action routine for an XML comment in "<!--"  "-->" brackets. */
    127 template <class B>
    128 inline void ParsingEngine<B>::Comment_action(unsigned char * item, int lgth) {
     127template<>
     128inline void Parser_Interface<UTF_8>::Comment_action(unsigned char * item, int lgth) {
    129129        comment_count +=1;
    130130       
     
    135135
    136136/* Action routine called upon recognizing "<![CDATA[" to start a CDATA section. */
    137 template <class B>
    138 inline void ParsingEngine<B>::CDATA_start_action(unsigned char * CDATA_ptr){
    139         CDATA_start_pos = AbsPos() - 9;
     137template<>
     138inline void Parser_Interface<UTF_8>::CDATA_start_action(unsigned char * CDATA_ptr){
     139        CDATA_start_pos = (int) CDATA_ptr;
    140140        CDATA_start_count +=1;
    141141}
    142142
    143143/* Action routine called upon recognizing "]]>" to end a CDATA section. */
    144 template <class B>
    145 inline void ParsingEngine<B>::CDATA_end_action(unsigned char * CDATA_end_ptr) {
     144template<>
     145inline void Parser_Interface<UTF_8>::CDATA_end_action(unsigned char * CDATA_end_ptr) {
    146146        CDATA_end_count +=1;
    147147       
    148148        #if defined(CALC_AVG)
    149                 CDATA_length += AbsPos() - CDATA_start_pos;
     149                CDATA_length += (int) CDATA_end_ptr - CDATA_start_pos;
    150150        #endif
    151151}
    152152
    153153/* Action routine for an XML processing instruction enclosed in "<?" and "?>" brackets. */
    154 template <class B>
    155 inline void ParsingEngine<B>::PI_action(unsigned char * item, int lgth) {
     154template<>
     155inline void Parser_Interface<UTF_8>::PI_action(unsigned char * item, int lgth) {
    156156        PI_count +=1;
    157157       
     
    162162
    163163/* Action routine for an empty element enclosed in "<" and "/>" brackets. */
    164 template <class B>
    165 inline void ParsingEngine<B>::EmptyElement_action(unsigned char * item, int lgth) {
     164template<>
     165inline void Parser_Interface<UTF_8>::EmptyElement_action(unsigned char * item, int lgth) {
    166166        empty_elem_count +=1;
    167167#ifdef LEAF_COUNTING
     
    176176
    177177/* Action routine for a start tag enclosed in "<" and ">" brackets. */
    178 template <class B>
    179 inline void ParsingEngine<B>::StartTag_action(unsigned char * item, int lgth) {
     178template<>
     179inline void Parser_Interface<UTF_8>::StartTag_action(unsigned char * item, int lgth) {
    180180        start_tag_count +=1;
    181181#ifdef LEAF_COUNTING
     
    193193
    194194/* Action routine for an end tag enclosed in "</" and ">" brackets. */
    195 template <class B>
    196 inline void ParsingEngine<B>::EndTag_action(unsigned char * item, int lgth) {
     195template<>
     196inline void Parser_Interface<UTF_8>::EndTag_action(unsigned char * item, int lgth) {
    197197        end_tag_count +=1;
    198198#ifdef LEAF_COUNTING
     
    210210
    211211/* Action routine for an error item */
    212 template <class B>
    213 inline void ParsingEngine<B>::Error_action(unsigned char * item, int lgth) {
     212template<>
     213inline void Parser_Interface<UTF_8>::Error_action(unsigned char * item, int lgth) {
    214214        error_item_count +=1;
    215215       
     
    218218        #endif
    219219       
    220         fprintf(stderr, "Error: illegal markup at positions %i of length %i.\n", AbsPos()-lgth, lgth);
     220        fprintf(stderr, "Error: illegal markup of length %i.\n", lgth);
    221221        cerr << string((char *) item, lgth) << endl;
    222222}
    223223
    224224/* Action routine for a text item */
    225 template <class B>
    226 inline void ParsingEngine<B>::Text_action(unsigned char * item, int lgth, bool more) {
     225template<>
     226inline void Parser_Interface<UTF_8>::Text_action(unsigned char * item, int lgth, bool more) {
    227227        text_item_count +=1;
    228228       
     
    232232}
    233233
    234 template <class B>
    235 inline void ParsingEngine<B>::Reference_action(unsigned char * item, int lgth) {
     234template<>
     235inline void Parser_Interface<UTF_8>::Reference_action(unsigned char * item, int lgth) {
    236236        reference_count +=1;
    237237       
     
    264264/* Action routine for an element name occurring immediately after the
    265265   opening "<" of a start tag or empty element tag. */
    266 template <class B>
    267 inline void ParsingEngine<B>::ElementName_action(unsigned char * item, int lgth) {
     266template<>
     267inline void Parser_Interface<UTF_8>::ElementName_action(unsigned char * item, int lgth) {
    268268}
    269269
    270270/* Action routine for a processing instruction target name occurring immediately
    271271   after the opening "<?" of a processing instruction. */
    272 template <class B>
    273 inline void ParsingEngine<B>::PI_Target_action(unsigned char * item, int lgth) {
     272template<>
     273inline void Parser_Interface<UTF_8>::PI_Target_action(unsigned char * item, int lgth) {
    274274}
    275275
    276276/* Action routine for an individual attribute/value pair occurring in
    277277   a element start tag or an empty element tag. */
    278 template <class B>
    279 inline void ParsingEngine<B>::AttributeValue_action(unsigned char * name, int name_lgth,
     278template<>
     279inline void Parser_Interface<UTF_8>::AttributeValue_action(unsigned char * name, int name_lgth,
    280280                                 unsigned char * val, int val_lgth) {
    281281        total_attribute_count+=1;
     
    289289/* Action routine for an individual attribute/value pair occurring in
    290290   a element start tag or an empty element tag. */
    291 template <class B>
    292 inline void ParsingEngine<B>::Namespace_action(unsigned char * name, int name_lgth,
     291template<>
     292inline void Parser_Interface<UTF_8>::Namespace_action(unsigned char * name, int name_lgth,
    293293                             unsigned char * URI, int URI_lgth) {
    294294        namespace_count+=1;
     
    301301
    302302
    303 template <class B>
    304 void ParsingEngine<B>::FinalizeBuffer_action() {
     303template<>
     304void Parser_Interface<UTF_8>::FinalizeBuffer_action() {
    305305       
    306306       
     
    319319
    320320
    321 template <class B>
    322 inline void ParsingEngine<B>::DocumentStart_action() {
     321template<>
     322inline void Parser_Interface<UTF_8>::DocumentStart_action() {
    323323        #if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == BUFFER_TOTAL)
    324324                code_clocker->start_interval();
     
    326326}
    327327
    328 template <class B>
    329 inline void ParsingEngine<B>::DocumentEnd_action() {
     328template<>
     329inline void Parser_Interface<UTF_8>::DocumentEnd_action() {
    330330        #if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == BUFFER_TOTAL)
    331331                code_clocker->end_interval(buffer_rel_pos);
    332332        #endif
    333 }
    334 
    335 template <class B>
    336 inline void ParsingEngine<B>::Doctype_action(unsigned char * item, int lgth) {
     333        printf("Document end\n");
     334        //Parser_Interface<UTF_8>::model_info->ReportSymbolInfo();
     335}
     336
     337template<>
     338inline void Parser_Interface<UTF_8>::Doctype_action(unsigned char * item, int lgth) {
    337339#ifdef SHOW_DTD_ACTIONS
    338340        printf("Document Type:\n");
     
    341343}
    342344
    343 template <class B>
    344 inline void ParsingEngine<B>::PEReference_action(unsigned char * item, int lgth) {
    345 }
    346 
    347 
    348 template <class B>
    349 inline void ParsingEngine<B>::ExtSubsetDecl_action(unsigned char * item, int lgth) {
     345template<>
     346inline void Parser_Interface<UTF_8>::PEReference_action(unsigned char * item, int lgth) {
     347}
     348
     349
     350template<>
     351inline void Parser_Interface<UTF_8>::ExtSubsetDecl_action(unsigned char * item, int lgth) {
    350352#ifdef SHOW_DTD_ACTIONS
    351353        printf("ExtSubsetDecl:\n");
     
    354356}
    355357
    356 template <class B>
    357 inline void ParsingEngine<B>::Prolog_action(unsigned char * item, int lgth) {
     358template<>
     359inline void Parser_Interface<UTF_8>::Prolog_action(unsigned char * item, int lgth) {
    358360#ifdef SHOW_DTD_ACTIONS
    359361        printf("Prolog:\n");
     
    448450                #endif
    449451
    450                 parser = Parser_Interface::ParserFactory(src_filename);
     452                parser = Parser_Interface<UTF_8>::ParserFactory(src_filename);
    451453       
    452454               
  • trunk/src/engine.c

    r196 r197  
    3939       
    4040       
    41        
    42 Parser_Interface * Parser_Interface::ParserFactory(char * filename) {
     41template <WorkingCharacterSet W>       
     42Parser_Interface<W> * Parser_Interface<W>::ParserFactory(char * filename) {
    4343       
    4444        int chars_read;
     
    6464                if (e->code_unit_size == SingleByte) {
    6565                        if (!(e->has_encoding_decl) || at_UTF_8(e->encoding))
    66                                 return new ParsingEngine< UTF8_Buffer>(e, m, b, false);         
    67                         else return new ParsingEngine< X8_Buffer<ASCII> >(e, m, b, false);
     66                                return new ParsingEngine< UTF8_Buffer, W>(e, m, b, false);             
     67                        else return new ParsingEngine< X8_Buffer<ASCII>, W>(e, m, b, false);
    6868                }
    6969                else if (e->code_unit_size == DoubleByte) {
    70                         return new ParsingEngine<U16_Buffer>(e, m, b, false);
     70                        return new ParsingEngine<U16_Buffer, W>(e, m, b, false);
    7171                }
    7272                else if (e->code_unit_size == QuadByte) {
    73                         return new ParsingEngine<U32_Buffer>(e, m, b, false);
     73                        return new ParsingEngine<U32_Buffer, W>(e, m, b, false);
    7474                }
    7575        }
     
    7777                XML_Decl_Parser<EBCDIC> decl_parser(b);
    7878                decl_parser.ReadXMLInfo(*e);
    79                 return new ParsingEngine< X8_Buffer<EBCDIC> >(e, m, b, false);
     79                return new ParsingEngine< X8_Buffer<EBCDIC>, W>(e, m, b, false);
    8080        }       
    8181}
    8282
    83 Parser_Interface * Parser_Interface::ParserFactory(char * filename, Model_Info * m) {
     83template <WorkingCharacterSet W>
     84Parser_Interface<W> * Parser_Interface<W>::ParserFactory(char * filename, Model_Info * m) {
    8485       
    8586        int chars_read;
     
    102103                decl_parser.ReadXMLInfo(*e);
    103104                if (e->code_unit_size == SingleByte) {
    104                         return new ParsingEngine< X8_Buffer<ASCII> >(e, m, b, true);
     105                        return new ParsingEngine< X8_Buffer<ASCII>, W>(e, m, b, true);
    105106                }
    106107                else if (e->code_unit_size == DoubleByte) {
    107                         return new ParsingEngine<U16_Buffer>(e, m, b, true);
     108                        return new ParsingEngine<U16_Buffer, W>(e, m, b, true);
    108109                }
    109110                else if (e->code_unit_size == QuadByte) {
    110                         return new ParsingEngine<U32_Buffer>(e, m, b, true);
     111                        return new ParsingEngine<U32_Buffer, W>(e, m, b, true);
    111112                }
    112113        }
     
    114115                XML_Decl_Parser<EBCDIC> decl_parser(b);
    115116                decl_parser.ReadXMLInfo(*e);
    116                 return new ParsingEngine< X8_Buffer<EBCDIC> >(e, m, b, true);
     117                return new ParsingEngine< X8_Buffer<EBCDIC>, W>(e, m, b, true);
    117118        }       
    118119}
    119120
    120 Parser_Interface * Parser_Interface::ParserFactory(char * byte_buffer, int byte_count, Entity_Info * e1, Model_Info * m){
     121template <WorkingCharacterSet W>
     122Parser_Interface<W> * Parser_Interface<W>::ParserFactory(char * byte_buffer, int byte_count, Entity_Info * e1, Model_Info * m){
    121123        Entity_Info * e = new Entity_Info;
    122124        e->BOM_units = 0;
     
    131133        if (e->code_unit_base == ASCII) {
    132134                if (e->code_unit_size == SingleByte) {
    133                         return new ParsingEngine< X8_Buffer<ASCII> >(e, m, b, false);
     135                        return new ParsingEngine< X8_Buffer<ASCII>, W>(e, m, b, false);
    134136                }
    135137                else if (e->code_unit_size == DoubleByte) {
    136                         return new ParsingEngine<U16_Buffer>(e, m, b, false);
     138                        return new ParsingEngine<U16_Buffer, W>(e, m, b, false);
    137139                }
    138140                else if (e->code_unit_size == QuadByte) {
    139                         return new ParsingEngine<U32_Buffer>(e, m, b, false);
     141                        return new ParsingEngine<U32_Buffer, W>(e, m, b, false);
    140142                }
    141143        }
    142144        else /* if (e->code_unit_base == EBCDIC) */ {
    143                 return new ParsingEngine< X8_Buffer<EBCDIC> >(e, m, b, false);
     145                return new ParsingEngine< X8_Buffer<EBCDIC>, W>(e, m, b, false);
    144146        }       
    145147}
    146148
    147 Parser_Interface::~Parser_Interface() {
    148 }
    149 
    150 
    151 bool Parser_Interface::has_ByteOrderMark() {
     149template <WorkingCharacterSet W>
     150Parser_Interface<W>::~Parser_Interface() {
     151}
     152
     153
     154template <WorkingCharacterSet W>
     155bool Parser_Interface<W>::has_ByteOrderMark() {
    152156        return entity_Info->BOM_units > 0;
    153157}
    154158
    155 XML_version Parser_Interface::get_version() {
     159template <WorkingCharacterSet W>
     160XML_version Parser_Interface<W>::get_version() {
    156161        return entity_Info->version;
    157162}
    158163
    159 XML_standalone Parser_Interface::standalone_status() {
     164template <WorkingCharacterSet W>
     165XML_standalone Parser_Interface<W>::standalone_status() {
    160166        return entity_Info->standalone;
    161167}
    162168
    163 bool Parser_Interface::has_EncodingDecl() {
     169template <WorkingCharacterSet W>
     170bool Parser_Interface<W>::has_EncodingDecl() {
    164171        return entity_Info->has_encoding_decl;
    165172}
    166173
    167 unsigned char * Parser_Interface::get_Encoding() {
     174template <WorkingCharacterSet W>
     175unsigned char * Parser_Interface<W>::get_Encoding() {
    168176        return entity_Info->encoding;
    169177}
    170178
    171 template <class B>
    172 inline unsigned char * ParsingEngine<B>::GetCodeUnitPtr(int pos) {
     179template <class B, WorkingCharacterSet W>
     180inline unsigned char * ParsingEngine<B, W>::GetCodeUnitPtr(int pos) {
    173181        int rel_pos = pos - buffer_base_pos;
    174182        return &((unsigned char *) (byteplex->src_buffer))[rel_pos * (int) B::Size];
     
    176184
    177185template <>
    178 inline unsigned char * ParsingEngine<UTF8_Buffer>::GetCodeUnitPtr(int pos) {
     186inline unsigned char * ParsingEngine<UTF8_Buffer, UTF_8>::GetCodeUnitPtr(int pos) {
    179187        int rel_pos = pos - buffer_base_pos;
    180188        return &((unsigned char *) (x8data))[rel_pos];
     
    184192
    185193
    186 template <class B>
    187 ParsingEngine<B>::ParsingEngine(Entity_Info * e, Model_Info * m, Byteplex * b, bool is_external) : Parser_Interface () {
    188         entity_Info = e;
    189         model_info = m;
     194template <class B, WorkingCharacterSet W>
     195ParsingEngine<B, W>::ParsingEngine(Entity_Info * e, Model_Info * m, Byteplex * b, bool is_external) : Parser_Interface<W> () {
     196        Parser_Interface<W>::entity_Info = e;
     197        Parser_Interface<W>::model_info = m;
    190198        byteplex = b;
    191199
     
    231239}
    232240
    233 template <class B>
    234 ParsingEngine<B>::~ParsingEngine() {
    235   // How do we do this?  model_info->~Model_Info();
    236   entity_Info->~Entity_Info();
     241template <class B, WorkingCharacterSet W>
     242ParsingEngine<B, W>::~ParsingEngine() {
     243  // How do we do this?  Parser_Interface<W>::model_info->~Model_Info();
     244  Parser_Interface<W>::entity_Info->~Entity_Info();
    237245  byteplex->~Byteplex();
    238246  bitplex->~Bitplex();
     
    241249}
    242250
    243 template <class B>
    244 void ParsingEngine<B>::AdvanceBuffers(){
     251template <class B, WorkingCharacterSet W>
     252void ParsingEngine<B, W>::AdvanceBuffers(){
    245253#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == ADVANCE_BUFFERS)
    246254        code_clocker->cc_start_interval();
     
    277285
    278286template <>
    279 void ParsingEngine<U16_Buffer>::AdvanceBuffers(){
     287void ParsingEngine<U16_Buffer, UTF_16>::AdvanceBuffers(){
    280288#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == ADVANCE_BUFFERS)
    281289        code_clocker->cc_start_interval();
     
    293301#endif
    294302        byteplex->DoByteplex();
    295         if (at_UTF_16(entity_Info->encoding)) ((U16_Buffer *) byteplex)->Validate_UTF16();
     303        if (at_UTF_16(Parser_Interface<UTF_16>::entity_Info->encoding)) ((U16_Buffer *) byteplex)->Validate_UTF16();
    296304        byteplex->PreparePseudoASCII_Stream();
    297305#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == BYTEPLEX)
     
    312320}
    313321
    314 template <class B>
    315 inline unsigned char * ParsingEngine<B>::cur() const {
     322template <class B, WorkingCharacterSet W>
     323inline unsigned char * ParsingEngine<B, W>::cur() const {
    316324  return &((unsigned char *) x8data)[buffer_rel_pos];
    317325}
    318326
    319 template <class B>
    320 inline int ParsingEngine<B>::AbsPos() const {
     327template <class B, WorkingCharacterSet W>
     328inline int ParsingEngine<B, W>::AbsPos() const {
    321329  return buffer_base_pos + buffer_rel_pos;
    322330}
    323331
    324 template <class B>
    325 inline int ParsingEngine<B>::LengthFrom(int start_pos) const {
     332template <class B, WorkingCharacterSet W>
     333inline int ParsingEngine<B, W>::LengthFrom(int start_pos) const {
    326334  return buffer_base_pos + buffer_rel_pos - start_pos;
    327335}
     
    329337
    330338
    331 template <class B>
    332 inline int ParsingEngine<B>::BufferRelPos() const {
     339template <class B, WorkingCharacterSet W>
     340inline int ParsingEngine<B, W>::BufferRelPos() const {
    333341  return buffer_rel_pos;
    334342}
    335343
    336344
    337 template <class B>
    338 inline bool ParsingEngine<B>::at_EOF() const {
     345template <class B, WorkingCharacterSet W>
     346inline bool ParsingEngine<B, W>::at_EOF() const {
    339347  return (buffer_rel_pos >= buffer_limit_pos) &&
    340348         (buffer_limit_pos < BUFFER_SIZE);
    341349}
    342350
    343 //template <class B>
    344 //inline void ParsingEngine<B>::Advance(int n) {
     351//template <class B, WorkingCharacterSet W>
     352//inline void ParsingEngine<B, W>::Advance(int n) {
    345353//      buffer_rel_pos += n;
    346354//  if (buffer_rel_pos >= BUFFER_SIZE) {       
    347 //      FinalizeBuffer_action();
     355//      Parser_Interface<W>::FinalizeBuffer_action();
    348356//      AdvanceBuffers();
    349357//  }
     
    354362        buffer_rel_pos += n; \
    355363        if (buffer_rel_pos >= BUFFER_SIZE) {    \
    356                 FinalizeBuffer_action();\
     364                Parser_Interface<W>::FinalizeBuffer_action();\
    357365        AdvanceBuffers();\
    358366        }\
     
    360368
    361369
    362 template <class B>
    363 void ParsingEngine<B>::AdjustBufferEndForIncompleteSequences() {
     370template <class B, WorkingCharacterSet W>
     371void ParsingEngine<B, W>::AdjustBufferEndForIncompleteSequences() {
    364372}
    365373
    366374template <>
    367 void ParsingEngine<UTF8_Buffer>::AdjustBufferEndForIncompleteSequences() {
     375void ParsingEngine<UTF8_Buffer, UTF_8>::AdjustBufferEndForIncompleteSequences() {
    368376        if (*(cur()-1) >= 0xC0) buffer_rel_pos--;
    369377        else if (*(cur()-2) >= 0xE0) buffer_rel_pos -= 2;
     
    372380
    373381template <>
    374 void ParsingEngine<U16_Buffer>::AdjustBufferEndForIncompleteSequences() {
     382void ParsingEngine<U16_Buffer, UTF_8>::AdjustBufferEndForIncompleteSequences() {
     383        unsigned short last_u16_unit = *(GetCodeUnitPtr(AbsPos()-1));
     384        if ((last_u16_unit >= 0xD800) & (last_u16_unit <= 0xDC00)) buffer_rel_pos--;
     385}
     386
     387template <>
     388void ParsingEngine<UTF8_Buffer, UTF_16>::AdjustBufferEndForIncompleteSequences() {
     389        if (*(cur()-1) >= 0xC0) buffer_rel_pos--;
     390        else if (*(cur()-2) >= 0xE0) buffer_rel_pos -= 2;
     391        else if (*(cur()-3) >= 0xF0) buffer_rel_pos -= 3;
     392}
     393
     394template <>
     395void ParsingEngine<U16_Buffer, UTF_16>::AdjustBufferEndForIncompleteSequences() {
    375396        unsigned short last_u16_unit = *(GetCodeUnitPtr(AbsPos()-1));
    376397        if ((last_u16_unit >= 0xD800) & (last_u16_unit <= 0xDC00)) buffer_rel_pos--;
     
    393414                        buffer_rel_pos = BUFFER_SIZE;\
    394415                        AdjustBufferEndForIncompleteSequences();\
    395                         FinalizeBuffer_action();\
     416                        Parser_Interface<W>::FinalizeBuffer_action();\
    396417                        AdvanceBuffers();\
    397418                        buffer_rel_pos = bitstream_scan(buf->item_stream[item], buffer_rel_pos);\
     
    409430//                      buffer_rel_pos = BUFFER_SIZE;\
    410431//                      AdjustBufferEndForIncompleteSequences();\
    411 //                      FinalizeBuffer_action();\
     432//                      Parser_Interface<W>::FinalizeBuffer_action();\
    412433//                      AdvanceBuffers();\
    413434//              }\
     
    430451//                      Text_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start), true);\
    431452//                      text_or_markup_start = AbsPos();\
    432 //                      FinalizeBuffer_action();\
     453//                      Parser_Interface<W>::FinalizeBuffer_action();\
    433454//                      AdvanceBuffers();\
    434455//                      buffer_rel_pos = bitstream_scan(buf->item_stream[item], buffer_rel_pos);\
     
    437458// } while(0)
    438459
    439 template <class B>
    440 inline void ParsingEngine<B>::ScanTextTo(int item) {
     460template <class B, WorkingCharacterSet W>
     461inline void ParsingEngine<B, W>::ScanTextTo(int item) {
    441462        text_or_markup_start = AbsPos();
    442463        unsigned long segment = bitstream_segment_from(buf->item_stream[item], buffer_rel_pos);
     
    450471                        Text_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start), true);
    451472                        text_or_markup_start = AbsPos();
    452                         FinalizeBuffer_action();
     473                        Parser_Interface<W>::FinalizeBuffer_action();
    453474                        AdvanceBuffers();
    454475                        buffer_rel_pos = bitstream_scan(buf->item_stream[item], buffer_rel_pos);
     
    466487  while (buffer_rel_pos >= BUFFER_SIZE) {\
    467488        AdjustBufferEndForIncompleteSequences();\
    468         FinalizeBuffer_action();\
     489        Parser_Interface<W>::FinalizeBuffer_action();\
    469490        AdvanceBuffers();\
    470491        buffer_rel_pos = bitstream_scan(buf->item_stream[item], buffer_rel_pos);\
     
    473494
    474495
    475 // template <class B>
    476 // inline void ParsingEngine<B>::ScanTo(int item) {
     496// template <class B, WorkingCharacterSet W>
     497// inline void ParsingEngine<B, W>::ScanTo(int item) {
    477498//      buffer_rel_pos = bitstream_scan(buf->item_stream[item], buffer_rel_pos);
    478499//      while (buffer_rel_pos >= BUFFER_SIZE) {
    479500//              AdjustBufferEndForIncompleteSequences();
    480 //              FinalizeBuffer_action();
     501//              Parser_Interface<W>::FinalizeBuffer_action();
    481502//              AdvanceBuffers();
    482503//              buffer_rel_pos = bitstream_scan(buf->item_stream[item], buffer_rel_pos);
     
    484505// }
    485506
    486 template <class B>
    487 inline void ParsingEngine<B>::ScanTextTo(int item) {
     507template <class B, WorkingCharacterSet W>
     508inline void ParsingEngine<B, W>::ScanTextTo(int item) {
    488509        text_or_markup_start = AbsPos();
    489510        buffer_rel_pos = bitstream_scan(buf->item_stream[item], buffer_rel_pos);
     
    492513                Text_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start), true);
    493514                text_or_markup_start = AbsPos();
    494                 FinalizeBuffer_action();
     515                Parser_Interface<W>::FinalizeBuffer_action();
    495516                AdvanceBuffers();
    496517                buffer_rel_pos = bitstream_scan(buf->item_stream[item], buffer_rel_pos);
     
    499520#endif
    500521
    501 template <class B>
    502 void ParsingEngine<B>::WF_Error (XML_Constraint errCode) {
     522template <class B, WorkingCharacterSet W>
     523void ParsingEngine<B, W>::WF_Error (XML_Constraint errCode) {
    503524        printf("Error at position %i in input.\n", AbsPos());
    504525        ShowConstraintError(errCode);
     
    508529       
    509530
    510 template <class B>
    511 void ParsingEngine<B>::Validity_Error (XML_Constraint errCode) {
     531template <class B, WorkingCharacterSet W>
     532void ParsingEngine<B, W>::Validity_Error (XML_Constraint errCode) {
    512533        printf("Error at position %i in input.\n", AbsPos());
    513534        ShowConstraintError(errCode);
     
    516537}
    517538       
    518 template <class B>
    519 void ParsingEngine<B>::Syntax_Error (XML_NonTerminal errNT) {
     539template <class B, WorkingCharacterSet W>
     540void ParsingEngine<B, W>::Syntax_Error (XML_NonTerminal errNT) {
    520541        printf("Error at position %i in input.\n", AbsPos());
    521542        ShowSyntaxError(errNT);
     
    526547
    527548/* Parse a comment beginning "<!--" */
    528 template <class B>
    529 void ParsingEngine<B>::Parse_Comment() {
     549template <class B, WorkingCharacterSet W>
     550void ParsingEngine<B, W>::Parse_Comment() {
    530551
    531552        Advance(4); /* Skip "<!--". */
     
    548569
    549570/* Parse an end tag beginning "</" */
    550 template <class B>
    551 inline void ParsingEngine<B>::Parse_EndTag() {
     571template <class B, WorkingCharacterSet W>
     572inline void ParsingEngine<B, W>::Parse_EndTag() {
    552573        Advance(2); /* Skip "</". */
    553574        int nameID = Parse_Name();
     
    567588
    568589/* Parse a CDATA section beginning "<![CDATA". */
    569 template <class B>
    570 void ParsingEngine<B>::Parse_CDATA() {
     590template <class B, WorkingCharacterSet W>
     591void ParsingEngine<B, W>::Parse_CDATA() {
    571592                Advance(8); /* Skip "<![CDATA". */
    572593        if (!AtChar<B::Base,'['>(cur())) {
     
    590611}
    591612
    592 template <class B>
    593 void ParsingEngine<B>::Parse_EntityRef() {
     613template <class B, WorkingCharacterSet W>
     614void ParsingEngine<B, W>::Parse_EntityRef() {
    594615    Advance(1);  // skip "&"
    595616        int nameID = Parse_Name();  /* Name delimiter */
     
    603624                //      The following code will replace Reference_Action.
    604625                GEntity_info * this_info;
    605                 Parser_Interface * entity_parser;
    606                 int entityID = model_info->GlobalGEntityTable[nameID];
     626                Parser_Interface<W> * entity_parser;
     627                int entityID = Parser_Interface<W>::model_info->GlobalGEntityTable[nameID];
    607628                if (entityID == 0)
    608629                        WF_Error(wfErr_wf_entdeclared);
    609630                else{
    610                         this_info = model_info->GEntityData[entityID-1];
     631                        this_info = Parser_Interface<W>::model_info->GEntityData[entityID-1];
    611632                        if (this_info->is_external){
    612633                               
    613                         if (entity_Info->standalone != Standalone_no)
     634                        if (Parser_Interface<W>::entity_Info->standalone != Standalone_no)
    614635                                WF_Error(wfErr_NoExternalRefs);
    615636                        else {
    616                                         entity_parser = ParserFactory(this_info->systemLiteral, model_info);
     637                                        entity_parser = ParserFactory(this_info->systemLiteral, Parser_Interface<W>::model_info);
    617638                                        entity_parser->Parse_WF_Content();
    618639                                        if(!entity_parser->at_EOF())
    619640                                                Syntax_Error(NT_content);
    620                                         entity_parser->~Parser_Interface();
     641                                        entity_parser->~Parser_Interface<W>();
    621642                        }
    622643                        }
     
    626647                                else{
    627648//                                      printf("Not a simple text: %s\n",this_info->ReplacementText);
    628                                         entity_parser = ParserFactory(this_info->ReplacementText, strlen(this_info->ReplacementText),entity_Info, model_info);
     649                                        entity_parser = ParserFactory(this_info->ReplacementText, strlen(this_info->ReplacementText),Parser_Interface<W>::entity_Info, Parser_Interface<W>::model_info);
    629650                                        entity_parser->Parse_WF_Content();
    630651                                        if(!entity_parser->at_EOF())
    631652                                                Syntax_Error(NT_content);
    632                                         entity_parser->~Parser_Interface();
     653                                        entity_parser->~Parser_Interface<W>();
    633654                                }
    634655                        }
     
    638659}
    639660
    640 template <class B>
    641 void ParsingEngine<B>::Parse_EntityRef_inMixed(symbol_set_t elems) {
     661template <class B, WorkingCharacterSet W>
     662void ParsingEngine<B, W>::Parse_EntityRef_inMixed(symbol_set_t elems) {
    642663    Advance(1);  // skip "&"
    643664        int nameID = Parse_Name();  /* Name delimiter */
     
    651672                //      The following code will replace Reference_Action.
    652673                GEntity_info * this_info;
    653                 Parser_Interface * entity_parser;
    654                 int entityID = model_info->GlobalGEntityTable[nameID];
     674                Parser_Interface<W> * entity_parser;
     675                int entityID = Parser_Interface<W>::model_info->GlobalGEntityTable[nameID];
    655676                if (entityID == 0)
    656677                        WF_Error(wfErr_wf_entdeclared);
    657678                else{
    658                         this_info = model_info->GEntityData[entityID-1];
     679                        this_info = Parser_Interface<W>::model_info->GEntityData[entityID-1];
    659680                        if (this_info->is_external){
    660681                               
    661                         if (entity_Info->standalone != Standalone_no)
     682                        if (Parser_Interface<W>::entity_Info->standalone != Standalone_no)
    662683                                WF_Error(wfErr_NoExternalRefs);
    663684                        else {
    664                                         entity_parser = ParserFactory(this_info->systemLiteral, model_info);
     685                                        entity_parser = ParserFactory(this_info->systemLiteral, Parser_Interface<W>::model_info);
    665686                                        entity_parser->Parse_MixedContent(elems);
    666687                                        if(!entity_parser->at_EOF())
    667688                                                Syntax_Error(NT_content);
    668                                         entity_parser->~Parser_Interface();
     689                                        entity_parser->~Parser_Interface<W>();
    669690                        }
    670691                        }
     
    674695                                else{
    675696//                                      printf("Not a simple text: %s\n",this_info->ReplacementText);
    676                                         entity_parser = ParserFactory(this_info->ReplacementText, strlen(this_info->ReplacementText),entity_Info, model_info);
     697                                        entity_parser = ParserFactory(this_info->ReplacementText, strlen(this_info->ReplacementText),Parser_Interface<W>::entity_Info, Parser_Interface<W>::model_info);
    677698                                        entity_parser->Parse_MixedContent(elems);
    678699                                        if(!entity_parser->at_EOF())
    679700                                                Syntax_Error(NT_content);
    680                                         entity_parser->~Parser_Interface();
     701                                        entity_parser->~Parser_Interface<W>();
    681702                                }
    682703                        }
     
    686707}
    687708
    688 template <class B>
    689 void ParsingEngine<B>::Parse_EntityRef_inAnyContent() {
     709template <class B, WorkingCharacterSet W>
     710void ParsingEngine<B, W>::Parse_EntityRef_inAnyContent() {
    690711    Advance(1);  // skip "&"
    691712        int nameID = Parse_Name();  /* Name delimiter */
     
    699720                //      The following code will replace Reference_Action.
    700721                GEntity_info * this_info;
    701                 Parser_Interface * entity_parser;
    702                 int entityID = model_info->GlobalGEntityTable[nameID];
     722                Parser_Interface<W> * entity_parser;
     723                int entityID = Parser_Interface<W>::model_info->GlobalGEntityTable[nameID];
    703724                if (entityID == 0)
    704725                        WF_Error(wfErr_wf_entdeclared);
    705726                else{
    706                         this_info = model_info->GEntityData[entityID-1];
     727                        this_info = Parser_Interface<W>::model_info->GEntityData[entityID-1];
    707728                        if (this_info->is_external){
    708729                               
    709                         if (entity_Info->standalone != Standalone_no)
     730                        if (Parser_Interface<W>::entity_Info->standalone != Standalone_no)
    710731                                WF_Error(wfErr_NoExternalRefs);
    711732                        else {
    712                                         entity_parser = ParserFactory(this_info->systemLiteral, model_info);
     733                                        entity_parser = ParserFactory(this_info->systemLiteral, Parser_Interface<W>::model_info);
    713734                                        entity_parser->Parse_AnyContent();
    714735                                        if(!entity_parser->at_EOF())
    715736                                                Syntax_Error(NT_content);
    716                                         entity_parser->~Parser_Interface();
     737                                        entity_parser->~Parser_Interface<W>();
    717738                        }
    718739                        }
     
    722743                                else{
    723744//                                      printf("Not a simple text: %s\n",this_info->ReplacementText);
    724                                         entity_parser = ParserFactory(this_info->ReplacementText, strlen(this_info->ReplacementText),entity_Info, model_info);
     745                                        entity_parser = ParserFactory(this_info->ReplacementText, strlen(this_info->ReplacementText),Parser_Interface<W>::entity_Info, Parser_Interface<W>::model_info);
    725746                                        entity_parser->Parse_AnyContent();
    726747                                        if(!entity_parser->at_EOF())
    727748                                                Syntax_Error(NT_content);
    728                                         entity_parser->~Parser_Interface();
     749                                        entity_parser->~Parser_Interface<W>();
    729750                                }
    730751                        }
     
    734755}
    735756
    736 template <class B>
    737 void ParsingEngine<B>::Parse_ValidEntityRef(CM_RegExp * cre, int & cur_state) {
     757template <class B, WorkingCharacterSet W>
     758void ParsingEngine<B, W>::Parse_ValidEntityRef(CM_RegExp * cre, int & cur_state) {
    738759    Advance(1);  // skip "&"
    739760        int nameID = Parse_Name();  /* Name delimiter */
     
    747768                //      The following code will replace Reference_Action.
    748769                GEntity_info * this_info;
    749                 Parser_Interface * entity_parser;
    750                 int entityID = model_info->GlobalGEntityTable[nameID];
     770                Parser_Interface<W> * entity_parser;
     771                int entityID = Parser_Interface<W>::model_info->GlobalGEntityTable[nameID];
    751772                if (entityID == 0)
    752773                        WF_Error(wfErr_wf_entdeclared);
    753774                else{
    754                         this_info = model_info->GEntityData[entityID-1];
     775                        this_info = Parser_Interface<W>::model_info->GEntityData[entityID-1];
    755776                        if (this_info->is_external){
    756777                               
    757                         if (entity_Info->standalone != Standalone_no)
     778                        if (Parser_Interface<W>::entity_Info->standalone != Standalone_no)
    758779                                WF_Error(wfErr_NoExternalRefs);
    759780                        else {
    760                                         entity_parser = ParserFactory(this_info->systemLiteral, model_info);
     781                                        entity_parser = ParserFactory(this_info->systemLiteral, Parser_Interface<W>::model_info);
    761782                                        entity_parser->Parse_ValidContent(cre, cur_state);
    762783                                        if(!entity_parser->at_EOF())
    763784                                                Syntax_Error(NT_content);
    764                                         entity_parser->~Parser_Interface();
     785                                        entity_parser->~Parser_Interface<W>();
    765786                        }
    766787                        }
     
    770791                                else{
    771792//                                      printf("Not a simple text: %s\n",this_info->ReplacementText);
    772                                         entity_parser = ParserFactory(this_info->ReplacementText, strlen(this_info->ReplacementText),entity_Info, model_info);
     793                                        entity_parser = ParserFactory(this_info->ReplacementText, strlen(this_info->ReplacementText),Parser_Interface<W>::entity_Info, Parser_Interface<W>::model_info);
    773794                                        entity_parser->Parse_ValidContent(cre, cur_state);
    774795                                        if(!entity_parser->at_EOF())
    775796                                                Syntax_Error(NT_content);
    776                                         entity_parser->~Parser_Interface();
     797                                        entity_parser->~Parser_Interface<W>();
    777798                                }
    778799                        }
     
    782803}
    783804       
    784 template <class B>
    785 void ParsingEngine<B>::Parse_CharRef() {
     805template <class B, WorkingCharacterSet W>
     806void ParsingEngine<B, W>::Parse_CharRef() {
    786807        Advance(2);  // skip "&#"
    787808        int ch_val = 0;
     
    805826        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF))
    806827                                WF_Error(wfErr_wf_Legalchar);   
    807                 else  if (entity_Info->version != XML_1_1)
     828                else  if (Parser_Interface<W>::entity_Info->version != XML_1_1)
    808829                        if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA)))
    809830                                WF_Error(wfErr_wf_Legalchar);
     
    818839}
    819840
    820 template <class B>
    821 void ParsingEngine<B>::Parse_PI (){
     841template <class B, WorkingCharacterSet W>
     842void ParsingEngine<B, W>::Parse_PI (){
    822843        int nameID;
    823844        Advance(2); /* Skip "<?". */
     
    842863 
    843864/* Parse a start or empty element tag. */
    844 template <class B>
    845 inline void ParsingEngine<B>::Parse_StartTag (){
     865template <class B, WorkingCharacterSet W>
     866inline void ParsingEngine<B, W>::Parse_StartTag (){
    846867        int att_name_start;
    847868        int att_val_start;
     
    873894                        att_name_end = AbsPos();
    874895               
    875                         int attID = model_info->getOrInsertGlobalAttName(att_nameID);
     896                        int attID = Parser_Interface<W>::model_info->getOrInsertGlobalAttName(att_nameID);
    876897                        if (attID >= LastAttOccurrence.size()) LastAttOccurrence.push_back(0);
    877898                        else {
     
    942963}
    943964
    944 template <class B>
    945 inline void ParsingEngine<B>::text_if_nonnull_action(bool more){
     965template <class B, WorkingCharacterSet W>
     966inline void ParsingEngine<B, W>::text_if_nonnull_action(bool more){
    946967        if (AbsPos() > text_or_markup_start) {
    947968                Text_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start), more);
     
    950971}
    951972
    952 template <class B>
    953 void ParsingEngine<B>::Parse_WF_EndTag(int nameID) {
     973template <class B, WorkingCharacterSet W>
     974void ParsingEngine<B, W>::Parse_WF_EndTag(int nameID) {
    954975        Advance(2);
    955976        int end_nameID = Parse_Name();
     
    958979        if (AtChar<B::Base,'>'>(cur())) {
    959980                Advance(1);
    960                 EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     981                Parser_Interface<W>::EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    961982        }
    962983    else {
     
    964985                if (AtChar<B::Base,'>'>(cur())) {
    965986                        Advance(1);
    966                         EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     987                        Parser_Interface<W>::EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    967988                }
    968989                else Syntax_Error(NT_ETag);
     
    970991}
    971992
    972 template <>
    973 void ParsingEngine<UTF8_Buffer>::Parse_WF_EndTag(int nameID) {
    974         Advance(2); /* Skip "</". */
    975        
    976         int name_start = AbsPos();
    977 //      ScanTo(NameFollow);
    978 //      int lgth = AbsPos()-name_start;
    979 
    980 #if (not defined(OMISSION)) or ((OMISSION != END_TAG_MATCHING)  and (OMISSION != NAME_LOOKUP))
    981         char * start_elem_name = model_info->symbol_table->Get_UTF8_name(nameID);
    982         int lgth = model_info->symbol_table->Get_UTF8_lgth(nameID);
    983         char * end_elem_name = &((char *) x8data)[buffer_rel_pos];
    984        
    985 #ifdef TEMPLATED_SIMD_LIB       
    986         BytePack byte_compare =  simd<8>::eq(sisd_load_unaligned((BytePack *) end_elem_name),
    987                                                            sisd_load_unaligned((BytePack *) start_elem_name));
    988 #endif
    989 #ifndef TEMPLATED_SIMD_LIB     
    990         BytePack byte_compare =  simd_eq_8(sisd_load_unaligned((BytePack *) end_elem_name),
    991                                                            sisd_load_unaligned((BytePack *) start_elem_name));
    992 #endif
    993         if (lgth < 16) {
    994                 int expected_bits = ~(-1 << lgth);
    995             if ((_mm_movemask_epi8(byte_compare) & expected_bits) != expected_bits) {
    996                         WF_Error(wfErr_GIMatch);
    997             }
    998         }
    999         else {
    1000             /* Must compare with bytes beyond the first 16.  Set up to
    1001                compare 16 bytes at a time, with the first additional compare
    1002                overlapping with the first byte_compare. */
    1003             int pos = (lgth - 1) % PACKSIZE + 1;
    1004 #ifdef TEMPLATED_SIMD_LIB
    1005             byte_compare =  simd_or(byte_compare, simd<8>::eq(sisd_load_unaligned((BytePack *) &end_elem_name[pos]),
    1006                                                                                         sisd_load_unaligned((BytePack *) &start_elem_name[pos])));
    1007 #endif
    1008 #ifndef TEMPLATED_SIMD_LIB
    1009             byte_compare =  simd_or(byte_compare, simd_eq_8(sisd_load_unaligned((BytePack *) &end_elem_name[pos]),
    1010                                                                                         sisd_load_unaligned((BytePack *) &start_elem_name[pos])));
    1011 #endif
    1012             pos += 16;
    1013             while (pos < lgth) {
    1014                 if (_mm_movemask_epi8(byte_compare) != 0xFFFF) {
    1015                         WF_Error(wfErr_GIMatch);
    1016                 }
    1017 #ifdef TEMPLATED_SIMD_LIB
    1018                 byte_compare =  simd<8>::eq(sisd_load_unaligned((BytePack *) &end_elem_name[pos]),
    1019                                                   sisd_load_unaligned((BytePack *) &start_elem_name[pos]));
    1020 #endif
    1021 #ifndef TEMPLATED_SIMD_LIB
    1022                 byte_compare =  simd_eq_8(sisd_load_unaligned((BytePack *) &end_elem_name[pos]),
    1023                                                   sisd_load_unaligned((BytePack *) &start_elem_name[pos]));
    1024 #endif
    1025                 pos += 16;
    1026             }
    1027             if (_mm_movemask_epi8(byte_compare) != 0xFFFF) {
    1028                         WF_Error(wfErr_GIMatch);
    1029             }
    1030         }
    1031         Advance(lgth);
    1032 
    1033 #endif
    1034 #if defined(OMISSION) and ((OMISSION == END_TAG_MATCHING) or (OMISSION == NAME_LOOKUP))
    1035         ScanTo(NameFollow);
    1036 #endif
    1037 //      for(int i=0; i<lgth; i++) {
    1038 //              if (start_elem_name[i] != end_elem_name[i])
    1039 //                      WF_Error(wfErr_GIMatch);
    1040 //      }
    1041 //      if (start_elem_name[lgth] != '\0') WF_Error(wfErr_GIMatch);
    1042 
    1043         if (AtChar<ASCII,'>'>(cur())) {
    1044                 Advance(1);
    1045                 EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    1046         }
    1047     else {
    1048                 ScanTo(NonWS);
    1049                 if (AtChar<ASCII,'>'>(cur())) {
    1050                         Advance(1);
    1051                         EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    1052                 }
    1053                 else Syntax_Error(NT_ETag);
    1054     }
    1055 }
     993// template <>
     994// void ParsingEngine<UTF8_Buffer, UTF_8>::Parse_WF_EndTag(int nameID) {
     995//      Advance(2); /* Skip "</". */
     996//     
     997//      int name_start = AbsPos();
     998// //   ScanTo(NameFollow);
     999// //   int lgth = AbsPos()-name_start;
     1000//
     1001// #if (not defined(OMISSION)) or ((OMISSION != END_TAG_MATCHING)  and (OMISSION != NAME_LOOKUP))
     1002//      char * start_elem_name = Parser_Interface<UTF_8>::model_info->symbol_table->Get_UTF8_name(nameID);
     1003//      int lgth = Parser_Interface<UTF_8>::model_info->symbol_table->Get_UTF8_lgth(nameID);
     1004//      char * end_elem_name = &((char *) x8data)[buffer_rel_pos];
     1005//     
     1006// #ifdef TEMPLATED_SIMD_LIB   
     1007//      BytePack byte_compare =  simd<8>::eq(sisd_load_unaligned((BytePack *) end_elem_name),
     1008//                                                                 sisd_load_unaligned((BytePack *) start_elem_name));
     1009// #endif
     1010// #ifndef TEMPLATED_SIMD_LIB   
     1011//      BytePack byte_compare =  simd_eq_8(sisd_load_unaligned((BytePack *) end_elem_name),
     1012//                                                                 sisd_load_unaligned((BytePack *) start_elem_name));
     1013// #endif
     1014//      if (lgth < 16) {
     1015//              int expected_bits = ~(-1 << lgth);
     1016//          if ((_mm_movemask_epi8(byte_compare) & expected_bits) != expected_bits) {
     1017//                      WF_Error(wfErr_GIMatch);
     1018//          }
     1019//      }
     1020//      else {
     1021//          /* Must compare with bytes beyond the first 16.  Set up to
     1022//             compare 16 bytes at a time, with the first additional compare
     1023//             overlapping with the first byte_compare. */
     1024//          int pos = (lgth - 1) % PACKSIZE + 1;
     1025// #ifdef TEMPLATED_SIMD_LIB
     1026//          byte_compare =  simd_or(byte_compare, simd<8>::eq(sisd_load_unaligned((BytePack *) &end_elem_name[pos]),
     1027//                                                                                      sisd_load_unaligned((BytePack *) &start_elem_name[pos])));
     1028// #endif
     1029// #ifndef TEMPLATED_SIMD_LIB
     1030//          byte_compare =  simd_or(byte_compare, simd_eq_8(sisd_load_unaligned((BytePack *) &end_elem_name[pos]),
     1031//                                                                                      sisd_load_unaligned((BytePack *) &start_elem_name[pos])));
     1032// #endif
     1033//          pos += 16;
     1034//          while (pos < lgth) {
     1035//              if (_mm_movemask_epi8(byte_compare) != 0xFFFF) {
     1036//                      WF_Error(wfErr_GIMatch);
     1037//              }
     1038// #ifdef TEMPLATED_SIMD_LIB
     1039//              byte_compare =  simd<8>::eq(sisd_load_unaligned((BytePack *) &end_elem_name[pos]),
     1040//                                                sisd_load_unaligned((BytePack *) &start_elem_name[pos]));
     1041// #endif
     1042// #ifndef TEMPLATED_SIMD_LIB
     1043//              byte_compare =  simd_eq_8(sisd_load_unaligned((BytePack *) &end_elem_name[pos]),
     1044//                                                sisd_load_unaligned((BytePack *) &start_elem_name[pos]));
     1045// #endif
     1046//              pos += 16;
     1047//          }
     1048//          if (_mm_movemask_epi8(byte_compare) != 0xFFFF) {
     1049//                      WF_Error(wfErr_GIMatch);
     1050//          }
     1051//      }
     1052//      Advance(lgth);
     1053//
     1054// #endif
     1055// #if defined(OMISSION) and ((OMISSION == END_TAG_MATCHING) or (OMISSION == NAME_LOOKUP))
     1056//      ScanTo(NameFollow);
     1057// #endif
     1058// //   for(int i=0; i<lgth; i++) {
     1059// //           if (start_elem_name[i] != end_elem_name[i])
     1060// //                   WF_Error(wfErr_GIMatch);
     1061// //   }
     1062// //   if (start_elem_name[lgth] != '\0') WF_Error(wfErr_GIMatch);
     1063//
     1064//      if (AtChar<ASCII,'>'>(cur())) {
     1065//              Advance(1);
     1066//              Parser_Interface<UTF_8>::EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     1067//      }
     1068//     else {
     1069//              ScanTo(NonWS);
     1070//              if (AtChar<ASCII,'>'>(cur())) {
     1071//                      Advance(1);
     1072//                      Parser_Interface<UTF_8>::EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     1073//              }
     1074//              else Syntax_Error(NT_ETag);
     1075//     }
     1076// }
     1077
     1078
    10561079/* Parse a valid start or empty element tag. */
    1057 template <class B>
    1058 int ParsingEngine<B>::Parse_WF_StartTag (bool& is_emptyStartTag){
     1080template <class B, WorkingCharacterSet W>
     1081int ParsingEngine<B, W>::Parse_WF_StartTag (bool& is_emptyStartTag){
    10591082        int att_name_start;
    10601083        int att_val_start;
     
    11001123            att_name_end = AbsPos();
    11011124                #if (not defined(OMISSION)) or ((OMISSION != ATTRIBUTE_UNIQUENESS) and (OMISSION != NAME_LOOKUP))
    1102                         int attID = model_info->getOrInsertGlobalAttName(att_nameID);
     1125                        int attID = Parser_Interface<W>::model_info->getOrInsertGlobalAttName(att_nameID);
    11031126                        if (attID >= LastAttOccurrence.size()) LastAttOccurrence.push_back(0);
    11041127                        else {
     
    11751198
    11761199
    1177 template <class B>
    1178 void ParsingEngine<B>::Parse_WF_Element() {
     1200template <class B, WorkingCharacterSet W>
     1201void ParsingEngine<B, W>::Parse_WF_Element() {
    11791202        bool is_emptyStartTag = false;
    11801203        int nameID = Parse_WF_StartTag(is_emptyStartTag);
     
    11891212
    11901213
    1191 template <class B>
    1192 void ParsingEngine<B>::Parse_WF_Content() {
     1214template <class B, WorkingCharacterSet W>
     1215void ParsingEngine<B, W>::Parse_WF_Content() {
    11931216        do {
    11941217                text_or_markup_start = AbsPos();
     
    12421265
    12431266
    1244 
    1245 template <class B>
    1246 void ParsingEngine<B>::ParseContent() {
    1247         DocumentStart_action();
     1267#ifndef MARKUP_PASS_CONTROL
     1268#ifndef MARKUP_SORTING
     1269template <class B, WorkingCharacterSet W>
     1270void ParsingEngine<B, W>::ParseContent() {
     1271        Parser_Interface<W>::DocumentStart_action();   
    12481272        bool is_emptyStartTag = false;
    12491273        do {
     
    12521276/*              if (AtChar<B::Base,'<'>(cur())) {
    12531277                        text_if_nonnull_action();
    1254                         Parse_Markup<B>();
     1278                        Parse_Markup<B, W>();
    12551279                }*/
    12561280                if (at_ElementTag_Start<B::Base>(cur())) {
     
    12991323                }
    13001324        } while (1);
    1301         DocumentEnd_action();   
    1302 }
    1303 
    1304 
    1305 template <class B>
    1306 void ParsingEngine<B>::Parse_DocType (){
     1325        Parser_Interface<W>::DocumentEnd_action();     
     1326}
     1327#endif
     1328#endif
     1329
     1330template <class B, WorkingCharacterSet W>
     1331void ParsingEngine<B, W>::Parse_DocType (){
    13071332
    13081333        int old_abspos, start_pos;
     
    13221347    ScanTo(NonWS);
    13231348    if(at_SYSTEM<B::Base>(cur())||at_PUBLIC<B::Base>(cur())){
    1324         model_info->has_external_DTD = true;
     1349        Parser_Interface<W>::model_info->has_external_DTD = true;
    13251350        if(old_abspos == AbsPos())
    13261351                Syntax_Error(NT_doctypedecl);
    1327         Parse_ExternalID(model_info->external_DTD_systemLiteral, model_info->external_DTD_pubidLiteral);
    1328         Parser_Interface * entity_parser;
    1329         entity_parser = ParserFactory(model_info->external_DTD_systemLiteral, model_info);
     1352        Parse_ExternalID(Parser_Interface<W>::model_info->external_DTD_systemLiteral, Parser_Interface<W>::model_info->external_DTD_pubidLiteral);
     1353        Parser_Interface<W> * entity_parser;
     1354        entity_parser = ParserFactory(Parser_Interface<W>::model_info->external_DTD_systemLiteral, Parser_Interface<W>::model_info);
    13301355                entity_parser->Parse_ExtSubsetDecl();
    1331                 entity_parser->~Parser_Interface();
     1356                entity_parser->~Parser_Interface<W>();
    13321357    }
    1333     else model_info->has_external_DTD = false;
     1358    else Parser_Interface<W>::model_info->has_external_DTD = false;
    13341359    ScanTo(NonWS);     
    13351360
     
    13641389                cre -> transition_map = transition_map;
    13651390               
    1366                 model_info->rootModel = cre;
     1391                Parser_Interface<W>::model_info->rootModel = cre;
    13671392               
    13681393                /* Check for notations that were used, but not defined by the end of the DTD. */
    13691394                #if (VALIDATION_MODE == ON)
    13701395                hash_map<int, int >::iterator j;
    1371                 for (j=model_info->GlobalNotationTable.begin(); j!=model_info->GlobalNotationTable.end(); j++) {
     1396                for (j=Parser_Interface<W>::model_info->GlobalNotationTable.begin(); j!=Parser_Interface<W>::model_info->GlobalNotationTable.end(); j++) {
    13721397                        if (j->second == -1)
    13731398                                Validity_Error(vErr_notatn);
     
    13791404}
    13801405
    1381 template <class B>
    1382 void ParsingEngine<B>::Parse_ExternalID (char *& systemLiteral, char *& pubidLiteral){
     1406template <class B, WorkingCharacterSet W>
     1407void ParsingEngine<B, W>::Parse_ExternalID (char *& systemLiteral, char *& pubidLiteral){
    13831408        int quot_start, lgth;
    13841409        if(at_SYSTEM<B::Base>(cur())){
     
    14141439}
    14151440
    1416 template <class B>
    1417 void ParsingEngine<B>::Parse_SystemLiteral (){
     1441template <class B, WorkingCharacterSet W>
     1442void ParsingEngine<B, W>::Parse_SystemLiteral (){
    14181443        unsigned char quoteCh;
    14191444        if(AtQuote<B::Base>(cur())){
     
    14311456}
    14321457
    1433 template <class B>
    1434 void ParsingEngine<B>::Parse_PubidLiteral (){
     1458template <class B, WorkingCharacterSet W>
     1459void ParsingEngine<B, W>::Parse_PubidLiteral (){
    14351460        unsigned char quoteCh;
    14361461        quoteCh = cur()[0];
     
    14451470}
    14461471
    1447 template <class B>
    1448 void ParsingEngine<B>::Parse_IntSubset (){
     1472template <class B, WorkingCharacterSet W>
     1473void ParsingEngine<B, W>::Parse_IntSubset (){
    14491474       
    14501475        while(1){
     
    14871512
    14881513
    1489 template <class B>
    1490 void ParsingEngine<B>::Parse_PEReference (){
     1514template <class B, WorkingCharacterSet W>
     1515void ParsingEngine<B, W>::Parse_PEReference (){
    14911516
    14921517        Advance(1); /* Skip "%". */
     
    14981523                PEReference_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    14991524                PEntity_info * this_info;
    1500                 Parser_Interface * entity_parser;
    1501                 int entityID = model_info->GlobalPEntityTable[nameID];
     1525                Parser_Interface<W> * entity_parser;
     1526                int entityID = Parser_Interface<W>::model_info->GlobalPEntityTable[nameID];
    15021527                if (entityID == 0)
    15031528                        WF_Error(wfErr_wf_entdeclared);
    15041529                else{
    1505                         this_info = model_info->PEntityData[entityID-1];
     1530                        this_info = Parser_Interface<W>::model_info->PEntityData[entityID-1];
    15061531                        if (this_info->is_external){
    15071532                               
    1508 //                      if (entity_Info->standalone != Standalone_no)
     1533//                      if (Parser_Interface<W>::entity_Info->standalone != Standalone_no)
    15091534//                              WF_Error(wfErr_NoExternalRefs);
    15101535//                      else {
    1511                                         entity_parser = ParserFactory(this_info->systemLiteral, model_info);
     1536                                        entity_parser = ParserFactory(this_info->systemLiteral, Parser_Interface<W>::model_info);
    15121537                                        entity_parser->Parse_WF_Content();
    15131538                                        if(!entity_parser->at_EOF())
    15141539                                                Syntax_Error(NT_content);
    1515                                         entity_parser->~Parser_Interface();
     1540                                        entity_parser->~Parser_Interface<W>();
    15161541//                      }
    15171542                        }
     
    15251550
    15261551
    1527 template <class B>
    1528 void ParsingEngine<B>::Parse_Elementdecl (){
     1552template <class B, WorkingCharacterSet W>
     1553void ParsingEngine<B, W>::Parse_Elementdecl (){
    15291554
    15301555        Advance(7); /* Skip "<!ELEMENT". */
     
    15321557    requireWS();
    15331558        int nameID = Parse_Name();
    1534         int elemID = model_info->getOrInsertGlobalElement(nameID);
     1559        int elemID = Parser_Interface<W>::model_info->getOrInsertGlobalElement(nameID);
    15351560
    15361561        requireWS();
     
    15401565        Advance(5);
    15411566        cm = new CM_Empty();
    1542         model_info->ContentModelData[nameID] = cm;
     1567        Parser_Interface<W>::model_info->ContentModelData[nameID] = cm;
    15431568        }
    15441569    else if (at_ANY<B::Base>(cur())) {
    15451570        Advance(3);
    15461571        cm = new CM_Any();
    1547         model_info->ContentModelData[nameID] = cm;
     1572        Parser_Interface<W>::model_info->ContentModelData[nameID] = cm;
    15481573    }
    15491574    else {
     
    15531578                if (at_PCDATA<B::Base>(cur())){
    15541579                        cm = Parse_RemainingMixed();
    1555                         model_info->ContentModelData[nameID] = cm;
     1580                        Parser_Interface<W>::model_info->ContentModelData[nameID] = cm;
    15561581                }
    15571582                else{
     
    15731598                        cre -> transition_map = transition_map;
    15741599                       
    1575                         model_info->ContentModelData[nameID] = cre;
     1600                        Parser_Interface<W>::model_info->ContentModelData[nameID] = cre;
    15761601                        cm = cre;
    15771602                }                       
     
    15851610                Syntax_Error(NT_elementdecl);
    15861611}
    1587 template <class B>
    1588 ContentModel * ParsingEngine<B>::Parse_RemainingMixed (){
     1612template <class B, WorkingCharacterSet W>
     1613ContentModel * ParsingEngine<B, W>::Parse_RemainingMixed (){
    15891614        CM_Mixed * r = new CM_Mixed();
    15901615        Advance(7);  /* Skip "#PCDATA". */
     
    16181643
    16191644
    1620 template <class B>
    1621 Content_RE * ParsingEngine<B>::Parse_RemainingChildren (){
     1645template <class B, WorkingCharacterSet W>
     1646Content_RE * ParsingEngine<B, W>::Parse_RemainingChildren (){
    16221647        Content_RE * c1 = Parse_Cp();
    16231648        Content_RE * r = c1;
     
    16851710}
    16861711
    1687 template <class B>
    1688 Content_RE * ParsingEngine<B>::Parse_Cp (){
     1712template <class B, WorkingCharacterSet W>
     1713Content_RE * ParsingEngine<B, W>::Parse_Cp (){
    16891714        if (AtChar<B::Base,'('>(cur())){
    16901715                Advance(1);
     
    17121737}
    17131738
    1714 template <class B>
    1715 void ParsingEngine<B>::Parse_AttlistDecl (){
     1739template <class B, WorkingCharacterSet W>
     1740void ParsingEngine<B, W>::Parse_AttlistDecl (){
    17161741       
    17171742        int old_abspos;
     
    17271752       
    17281753        int nameID = Parse_Name();
    1729         elemID = model_info->getOrInsertGlobalElement(nameID);
     1754        elemID = Parser_Interface<W>::model_info->getOrInsertGlobalElement(nameID);
    17301755       
    17311756        old_abspos = AbsPos();
     
    17371762                int att_nameID = Parse_Name();
    17381763               
    1739                 attID = model_info->getOrInsertGlobalAttName(att_nameID);
     1764                attID = Parser_Interface<W>::model_info->getOrInsertGlobalAttName(att_nameID);
    17401765                if (attID >= LastAttOccurrence.size()) LastAttOccurrence.push_back(0);
    17411766        ATT_info * this_info = new ATT_info;
     
    17931818
    17941819                ScanTo(NonWS);
    1795                 model_info->ElementAttributeData[elemID].push_back(this_info);
     1820                Parser_Interface<W>::model_info->ElementAttributeData[elemID].push_back(this_info);
    17961821        }
    17971822
     
    17991824}
    18001825
    1801 template <class B>
    1802 void ParsingEngine<B>::Parse_Notation (ATT_info * this_info){
     1826template <class B, WorkingCharacterSet W>
     1827void ParsingEngine<B, W>::Parse_Notation (ATT_info * this_info){
    18031828
    18041829        if(AtChar<B::Base,'('>(cur()))
     
    18111836
    18121837        /*Notation name is not in the global table!*/
    1813         if(model_info->GlobalNotationTable[notn_nameID]==0)
    1814                 model_info->GlobalNotationTable[notn_nameID] = -1;
     1838        if(Parser_Interface<W>::model_info->GlobalNotationTable[notn_nameID]==0)
     1839                Parser_Interface<W>::model_info->GlobalNotationTable[notn_nameID] = -1;
    18151840       
    18161841        ScanTo(NonWS);
     
    18201845                notn_nameID = Parse_Name();
    18211846                       
    1822                 if(model_info->GlobalNotationTable[notn_nameID]==0)
     1847                if(Parser_Interface<W>::model_info->GlobalNotationTable[notn_nameID]==0)
    18231848//                      Validity_Error(vErr_notatn);
    1824                         model_info->GlobalNotationTable[notn_nameID] = -1;
     1849                        Parser_Interface<W>::model_info->GlobalNotationTable[notn_nameID] = -1;
    18251850                       
    18261851                ScanTo(NonWS);
     
    18321857}
    18331858
    1834 template <class B>
    1835 void ParsingEngine<B>::Parse_Enumeration (ATT_info * this_info){
     1859template <class B, WorkingCharacterSet W>
     1860void ParsingEngine<B, W>::Parse_Enumeration (ATT_info * this_info){
    18361861
    18371862        int enumCount=0;
     
    18681893}
    18691894
    1870 template <class B>
    1871 void ParsingEngine<B>::Parse_DefaultDecl (ATT_info * this_info){
     1895template <class B, WorkingCharacterSet W>
     1896void ParsingEngine<B, W>::Parse_DefaultDecl (ATT_info * this_info){
    18721897        if(at_REQUIRED<B::Base>(cur())){
    18731898                Advance(9);
     
    19001925}
    19011926
    1902 template <class B>
    1903 void ParsingEngine<B>::Parse_Entitydecl (){
     1927template <class B, WorkingCharacterSet W>
     1928void ParsingEngine<B, W>::Parse_Entitydecl (){
    19041929       
    19051930        int name_start;
     
    19181943                int nameID = Parse_Name();
    19191944                PEntity_info * this_info = new PEntity_info;
    1920                 int entityID = model_info->GlobalPEntityTable[nameID];
     1945                int entityID = Parser_Interface<W>::model_info->GlobalPEntityTable[nameID];
    19211946                if(entityID==0){       
    1922                         model_info->GlobalPEntityTable[nameID]=++(model_info->globalPEntityCount);
    1923                         entityID = model_info->globalPEntityCount;
     1947                        Parser_Interface<W>::model_info->GlobalPEntityTable[nameID]=++(Parser_Interface<W>::model_info->globalPEntityCount);
     1948                        entityID = Parser_Interface<W>::model_info->globalPEntityCount;
    19241949                        this_info->globalPEntity_id = entityID;
    19251950                }
     
    19371962                if (this_info->systemLiteral == NULL) Syntax_Error(NT_EntityDecl);
    19381963        }
    1939         model_info->PEntityData.push_back(this_info);
     1964        Parser_Interface<W>::model_info->PEntityData.push_back(this_info);
    19401965        }
    19411966        else{
     
    19431968       
    19441969                GEntity_info * this_info = new GEntity_info();
    1945                 int entityID = model_info->GlobalGEntityTable[nameID];
     1970                int entityID = Parser_Interface<W>::model_info->GlobalGEntityTable[nameID];
    19461971                if(entityID==0){       
    1947                         model_info->GlobalGEntityTable[nameID]=++(model_info->globalGEntityCount);
    1948                         entityID = model_info->globalGEntityCount;
     1972                        Parser_Interface<W>::model_info->GlobalGEntityTable[nameID]=++(Parser_Interface<W>::model_info->globalGEntityCount);
     1973                        entityID = Parser_Interface<W>::model_info->globalGEntityCount;
    19491974                        this_info->globalGEntity_id = entityID;
    19501975                }
     
    19762001                }
    19772002                }
    1978         model_info->GEntityData.push_back(this_info);
     2003        Parser_Interface<W>::model_info->GEntityData.push_back(this_info);
    19792004        }
    19802005        ScanTo(NonWS);
     
    19862011}
    19872012
    1988 template <class B>
    1989 void ParsingEngine<B>::Parse_Notationdecl (){
     2013template <class B, WorkingCharacterSet W>
     2014void ParsingEngine<B, W>::Parse_Notationdecl (){
    19902015
    19912016        int old_abspos;
     
    19952020        int nameID = Parse_Name();
    19962021
    1997         int notationID = model_info->GlobalNotationTable[nameID];
     2022        int notationID = Parser_Interface<W>::model_info->GlobalNotationTable[nameID];
    19982023        /* notationID == -1: used but not yet defined; == 0: new, > 0 prev. defined */
    19992024        if(notationID <= 0){   
    2000                 model_info->GlobalNotationTable[nameID]=++(model_info->globalNotationCount);
    2001                 notationID = model_info->globalNotationCount;
     2025                Parser_Interface<W>::model_info->GlobalNotationTable[nameID]=++(Parser_Interface<W>::model_info->globalNotationCount);
     2026                notationID = Parser_Interface<W>::model_info->globalNotationCount;
    20022027        }
    20032028        else /*Duplicate notation name!*/
     
    20142039}
    20152040
    2016 template <class B>
    2017 void ParsingEngine<B>::requireWS(){
     2041template <class B, WorkingCharacterSet W>
     2042void ParsingEngine<B, W>::requireWS(){
    20182043       
    20192044    int old_abspos = AbsPos(); 
     
    20232048}
    20242049
    2025 template <class B>
    2026 void ParsingEngine<B>::Parse_AttValue(){
     2050template <class B, WorkingCharacterSet W>
     2051void ParsingEngine<B, W>::Parse_AttValue(){
    20272052       
    20282053        int     quoteCh = cur()[0];
     
    20492074}
    20502075
    2051 template <class B>
    2052 void ParsingEngine<B>::Parse_GEntityValue(GEntity_info * this_info){
     2076template <class B, WorkingCharacterSet W>
     2077void ParsingEngine<B, W>::Parse_GEntityValue(GEntity_info * this_info){
    20532078       
    20542079        int     quoteCh = cur()[0];
     
    20852110}
    20862111
    2087 template <class B>
    2088 char * ParsingEngine<B>::Replace_EntityRef(bool& is_simple){
     2112template <class B, WorkingCharacterSet W>
     2113char * ParsingEngine<B, W>::Replace_EntityRef(bool& is_simple){
    20892114        Advance(1);
    20902115        int nameID = Parse_Name();
     
    20932118        else
    20942119                Syntax_Error(NT_EntityValue);
    2095         int entityID = model_info->GlobalGEntityTable[nameID];
     2120        int entityID = Parser_Interface<W>::model_info->GlobalGEntityTable[nameID];
    20962121        if (entityID == 0)
    20972122                WF_Error(wfErr_wf_entdeclared);
    20982123        else{
    2099                 if (model_info->GEntityData[entityID-1]->is_simple == false)
     2124                if (Parser_Interface<W>::model_info->GEntityData[entityID-1]->is_simple == false)
    21002125                        is_simple = false;
    2101                 return model_info->GEntityData[entityID-1]->ReplacementText;
    2102         }
    2103        
    2104 }
    2105 
    2106 template <class B>
    2107 void ParsingEngine<B>::Parse_PEntityValue(PEntity_info * this_info){
     2126                return Parser_Interface<W>::model_info->GEntityData[entityID-1]->ReplacementText;
     2127        }
     2128       
     2129}
     2130
     2131template <class B, WorkingCharacterSet W>
     2132void ParsingEngine<B, W>::Parse_PEntityValue(PEntity_info * this_info){
    21082133        fprintf(stderr,"parsing of parameter entity value has not been completed yet.\n");
    21092134        exit(-1);
    21102135}
    21112136
    2112 template <class B>
    2113 char * ParsingEngine<B>::Replace_CharRef(){
     2137template <class B, WorkingCharacterSet W>
     2138char * ParsingEngine<B, W>::Replace_CharRef(){
    21142139        Advance(2);
    21152140        fprintf(stderr,"Replacement of Character Reference has not been completed yet.\n");
     
    21172142}
    21182143
    2119 template <class B>
    2120 void ParsingEngine<B>::Parse_Prolog(){
     2144template <class B, WorkingCharacterSet W>
     2145void ParsingEngine<B, W>::Parse_Prolog(){
    21212146        ScanTo(NonWS);
    21222147        int old_pos = AbsPos();
     
    21462171}
    21472172
    2148 template <class B>
    2149 void ParsingEngine<B>::Parse_ExtSubsetDecl() {
     2173template <class B, WorkingCharacterSet W>
     2174void ParsingEngine<B, W>::Parse_ExtSubsetDecl() {
    21502175        ScanTo(NonWS);
    21512176        int start_pos=AbsPos();
     
    22282253
    22292254/* Parse a valid start or empty element tag. */
    2230 template <class B>
    2231 inline int ParsingEngine<B>::Parse_ValidStartTag (bool& is_emptyStartTag){
     2255template <class B, WorkingCharacterSet W>
     2256inline int ParsingEngine<B, W>::Parse_ValidStartTag (bool& is_emptyStartTag){
    22322257        int att_name_start;
    22332258        int att_val_start;
     
    22372262
    22382263        int nameID = Parse_Name(); 
    2239         int elemID = model_info->GlobalElementTable[nameID];
     2264        int elemID = Parser_Interface<W>::model_info->GlobalElementTable[nameID];
    22402265        if(elemID==0)
    22412266                        Validity_Error(vErr_elementvalid);
     
    22642289                        int att_nameID = Parse_Name();
    22652290                        #if (not defined(OMISSION)) or (OMISSION != ATTRIBUTE_UNIQUENESS)
    2266                         int attID = model_info->getOrInsertGlobalAttName(att_nameID);
     2291                        int attID = Parser_Interface<W>::model_info->getOrInsertGlobalAttName(att_nameID);
    22672292                        if (attID >= LastAttOccurrence.size()) LastAttOccurrence.push_back(0);
    22682293                        else {
     
    23372362}
    23382363
    2339 template <class B>
    2340 int ParsingEngine<B>::Parse_ValidElement() {
     2364template <class B, WorkingCharacterSet W>
     2365int ParsingEngine<B, W>::Parse_ValidElement() {
    23412366        bool is_emptyStartTag = false;
    23422367        int nameID = Parse_ValidStartTag(is_emptyStartTag);
    23432368#ifdef DEBUG
    2344         printf("Parse_ValidElement: nameID = %d, name = %s, is_emptyStartTag=%i\n",nameID, model_info->symbol_table->Get_UTF8_name(nameID), is_emptyStartTag);
     2369        printf("Parse_ValidElement: nameID = %d, name = %s, is_emptyStartTag=%i\n",nameID, Parser_Interface<W>::model_info->symbol_table->Get_UTF8_name(nameID), is_emptyStartTag);
    23452370#endif
    2346         ContentModel * cm = model_info->ContentModelData[nameID];
     2371        ContentModel * cm = Parser_Interface<W>::model_info->ContentModelData[nameID];
    23472372        switch (cm->cm_type) {
    23482373                case cm_Empty:
     
    23852410}
    23862411
    2387 template <class B>
    2388 void ParsingEngine<B>::Parse_ValidContent(CM_RegExp * cre, int & cur_state) {
     2412template <class B, WorkingCharacterSet W>
     2413void ParsingEngine<B, W>::Parse_ValidContent(CM_RegExp * cre, int & cur_state) {
    23892414        do {
    23902415                ScanTo(NonWS);
     
    24302455
    24312456
    2432 template <class B>
    2433 void ParsingEngine<B>::Parse_AnyContent() {
     2457template <class B, WorkingCharacterSet W>
     2458void ParsingEngine<B, W>::Parse_AnyContent() {
    24342459        do {
    24352460                text_or_markup_start = AbsPos();
     
    24812506        } while (1);
    24822507}
    2483 template <class B>
    2484 void ParsingEngine<B>::Parse_MixedContent(symbol_set_t elems) {
     2508template <class B, WorkingCharacterSet W>
     2509void ParsingEngine<B, W>::Parse_MixedContent(symbol_set_t elems) {
    24852510        do {
    24862511                text_or_markup_start = AbsPos();
     
    24882513/*              if (AtChar<B::Base,'<'>(cur())) {
    24892514                        text_if_nonnull_action();
    2490                         Parse_Markup<B>();
     2515                        Parse_Markup<B, W>();
    24912516                }*/
    24922517                if (at_ElementTag_Start<B::Base>(cur())) {
     
    25412566
    25422567
    2543 template <class B>
    2544 int ParsingEngine<B>::Parse_Name() {
     2568template <class B, WorkingCharacterSet W>
     2569int ParsingEngine<B, W>::Parse_Name() {
    25452570        int name_pos = AbsPos();
    25462571        ScanTo(NameFollow);
    25472572        int lgth = AbsPos()-name_pos;
    2548         int nameID = model_info->symbol_table->ASCII_Lookup_or_Insert_Name(&((char *) x8data)[buffer_rel_pos-lgth], lgth);
     2573        int nameID = Parser_Interface<W>::model_info->symbol_table->ASCII_Lookup_or_Insert_Name(&((char *) x8data)[buffer_rel_pos-lgth], lgth);
    25492574        if (nameID != 0) return nameID;
    25502575        else {
    25512576                int u8_lgth = byteplex->UTF8_Length(name_pos, lgth);
    2552                 char * u8_ptr = model_info->symbol_table->ReserveSymbolSpace(u8_lgth);
     2577                char * u8_ptr = Parser_Interface<W>::model_info->symbol_table->ReserveSymbolSpace(u8_lgth);
    25532578                byteplex->to_UTF8(name_pos, lgth, u8_ptr);
    2554                 return model_info->symbol_table->LookupOrInsertReserved();
    2555         }
    2556 }
    2557 
    2558 template <>
    2559 int ParsingEngine< X8_Buffer<EBCDIC> >::Parse_Name() {
     2579                return Parser_Interface<W>::model_info->symbol_table->LookupOrInsertReserved();
     2580        }
     2581}
     2582
     2583// template <>
     2584// int ParsingEngine< X8_Buffer<EBCDIC>, UTF_8 >::Parse_Name() {
     2585//      int name_pos = AbsPos();
     2586//      ScanTo(NameFollow);
     2587//      int lgth = AbsPos()-name_pos;
     2588// //   int nameID = local_EBCDIC_table->Lookup_or_Insert(GetCodeUnitPtr(name_pos), lgth);
     2589// //   if (nameID != 0) return nameID;
     2590// //   else {
     2591//              int u8_lgth = byteplex->UTF8_Length(name_pos, lgth);
     2592//              char * u8_ptr = Parser_Interface<UTF_8>::model_info->symbol_table->ReserveSymbolSpace(u8_lgth);
     2593//              byteplex->to_UTF8(name_pos, lgth, u8_ptr);
     2594//              return Parser_Interface<UTF_8>::model_info->symbol_table->LookupOrInsertReserved();
     2595// //   }
     2596// }
     2597
     2598// template <>
     2599// inline int ParsingEngine<UTF8_Buffer, UTF_8>::Parse_Name() {
     2600//      int name_pos = AbsPos();
     2601//      ScanTo(NameFollow);
     2602//      int lgth = AbsPos()-name_pos;
     2603//      return Parser_Interface<UTF_8>::model_info->symbol_table->UTF8_Lookup_or_Insert_Name(&((char *)x8data)[buffer_rel_pos-lgth], lgth);
     2604// }
     2605
     2606template <class B, WorkingCharacterSet W>
     2607int ParsingEngine<B, W>::Parse_Nmtoken() {
     2608        int name_pos = AbsPos();
     2609        ScanTo(NameFollow);
     2610        int lgth = AbsPos()-name_pos;
     2611        int nameID = Parser_Interface<W>::model_info->symbol_table->ASCII_Lookup_or_Insert_Nmtoken(&((char *) x8data)[buffer_rel_pos-lgth], lgth);
     2612        if (nameID != 0) return nameID;
     2613        else {
     2614                int u8_lgth = byteplex->UTF8_Length(name_pos, lgth);
     2615                char * u8_ptr = Parser_Interface<W>::model_info->symbol_table->ReserveSymbolSpace(u8_lgth);
     2616                byteplex->to_UTF8(name_pos, lgth, u8_ptr);
     2617                return Parser_Interface<W>::model_info->symbol_table->LookupOrInsertReserved_nmtoken();
     2618        }
     2619}
     2620
     2621/*template <>
     2622int ParsingEngine< X8_Buffer<EBCDIC>, UTF_8 >::Parse_Nmtoken() {
    25602623        int name_pos = AbsPos();
    25612624        ScanTo(NameFollow);
     
    25652628//      else {
    25662629                int u8_lgth = byteplex->UTF8_Length(name_pos, lgth);
    2567                 char * u8_ptr = model_info->symbol_table->ReserveSymbolSpace(u8_lgth);
     2630                char * u8_ptr = Parser_Interface<UTF_8>::model_info->symbol_table->ReserveSymbolSpace(u8_lgth);
    25682631                byteplex->to_UTF8(name_pos, lgth, u8_ptr);
    2569                 return model_info->symbol_table->LookupOrInsertReserved();
     2632                return Parser_Interface<UTF_8>::model_info->symbol_table->LookupOrInsertReserved_nmtoken();
    25702633//      }
    2571 }
    2572 
    2573 template <>
    2574 inline int ParsingEngine<UTF8_Buffer>::Parse_Name() {
    2575         int name_pos = AbsPos();
    2576         ScanTo(NameFollow);
    2577         int lgth = AbsPos()-name_pos;
    2578         return model_info->symbol_table->UTF8_Lookup_or_Insert_Name(&((char *)x8data)[buffer_rel_pos-lgth], lgth);
    2579 }
    2580 
    2581 template <class B>
    2582 int ParsingEngine<B>::Parse_Nmtoken() {
    2583         int name_pos = AbsPos();
    2584         ScanTo(NameFollow);
    2585         int lgth = AbsPos()-name_pos;
    2586         int nameID = model_info->symbol_table->ASCII_Lookup_or_Insert_Nmtoken(&((char *) x8data)[buffer_rel_pos-lgth], lgth);
    2587         if (nameID != 0) return nameID;
    2588         else {
    2589                 int u8_lgth = byteplex->UTF8_Length(name_pos, lgth);
    2590                 char * u8_ptr = model_info->symbol_table->ReserveSymbolSpace(u8_lgth);
    2591                 byteplex->to_UTF8(name_pos, lgth, u8_ptr);
    2592                 return model_info->symbol_table->LookupOrInsertReserved_nmtoken();
    2593         }
    2594 }
    2595 
    2596 template <>
    2597 int ParsingEngine< X8_Buffer<EBCDIC> >::Parse_Nmtoken() {
    2598         int name_pos = AbsPos();
    2599         ScanTo(NameFollow);
    2600         int lgth = AbsPos()-name_pos;
    2601 //      int nameID = local_EBCDIC_table->Lookup_or_Insert(GetCodeUnitPtr(name_pos), lgth);
    2602 //      if (nameID != 0) return nameID;
    2603 //      else {
    2604                 int u8_lgth = byteplex->UTF8_Length(name_pos, lgth);
    2605                 char * u8_ptr = model_info->symbol_table->ReserveSymbolSpace(u8_lgth);
    2606                 byteplex->to_UTF8(name_pos, lgth, u8_ptr);
    2607                 return model_info->symbol_table->LookupOrInsertReserved_nmtoken();
    2608 //      }
    2609 }
    2610 template <>
    2611 int ParsingEngine<UTF8_Buffer>::Parse_Nmtoken() {
    2612         int name_pos = AbsPos();
    2613         ScanTo(NameFollow);
    2614         int lgth = AbsPos()-name_pos;
    2615         return model_info->symbol_table->UTF8_Lookup_or_Insert_Nmtoken(&((char *)x8data)[buffer_rel_pos-lgth], lgth);
    2616 }
    2617 
    2618 template <class B>
    2619 void ParsingEngine<B>::Parse_DocumentContent() {
     2634}*/
     2635// template <>
     2636// int ParsingEngine<UTF8_Buffer, UTF_8>::Parse_Nmtoken() {
     2637//      int name_pos = AbsPos();
     2638//      ScanTo(NameFollow);
     2639//      int lgth = AbsPos()-name_pos;
     2640//      return Parser_Interface<UTF_8>::model_info->symbol_table->UTF8_Lookup_or_Insert_Nmtoken(&((char *)x8data)[buffer_rel_pos-lgth], lgth);
     2641// }
     2642
     2643template <class B, WorkingCharacterSet W>
     2644void ParsingEngine<B, W>::Parse_DocumentContent() {
    26202645#if (VALIDATION_MODE == ON)
    26212646        int cur_state = 0;
    2622         Parse_ValidContent(model_info->rootModel, cur_state);
    2623         if (model_info->rootModel->transition_map[cur_state][0]==0) {
     2647        Parse_ValidContent(Parser_Interface<W>::model_info->rootModel, cur_state);
     2648        if (Parser_Interface<W>::model_info->rootModel->transition_map[cur_state][0]==0) {
    26242649                Validity_Error(vErr_elementvalid);
    26252650        }
     
    26392664        }       
    26402665#endif
    2641 }
    2642 
     2666        Parser_Interface<W>::DocumentEnd_action();     
     2667}
     2668
     2669#ifdef MARKUP_PASS_CONTROL
     2670// Test routine as an alternative to MarkupPass.
     2671template <class B, WorkingCharacterSet W>
     2672void ParsingEngine<B, W>::ParseContent() {
     2673        int start_code = 0;
     2674        int end_code = 0;
     2675        int charref_code = 0;
     2676        int general_ref_code = 0;
     2677        DocumentStart_action();
     2678        bool is_emptyStartTag = false;
     2679        do {
     2680                text_or_markup_start = AbsPos();
     2681                ScanTo(MarkupStart); /* '<', '&', or ']' for 0b11']]>' test */
     2682/*              if (AtChar<B::Base,'<'>(cur())) {
     2683                        text_if_nonnull_action();
     2684                        Parse_Markup<B, W>();
     2685                }*/
     2686                if (at_EndTag_Start<B::Base>(cur())) {
     2687                        end_code |= AbsPos();
     2688                }
     2689                else if (AtChar<B::Base,'<'>(cur())) {
     2690                        start_code += AbsPos();
     2691                }
     2692                else if (at_CharRef_Start<B::Base>(cur())) {
     2693                        charref_code += 1;
     2694                }
     2695                else  if (AtChar<B::Base,'&'>(cur())) {
     2696                        general_ref_code += 1;
     2697                }
     2698                else if (at_EOF()) break;
     2699                Advance(1);
     2700        } while (1);
     2701        printf("Start_code: %i\n", start_code);
     2702        printf("End_code: %i\n", end_code);
     2703        printf("general_ref_code: %i\n", general_ref_code);
     2704        printf("charref_code: %i\n", charref_code);
     2705        DocumentEnd_action();   
     2706}
     2707#endif
     2708
     2709#ifdef MARKUP_SORTING
     2710// Little endian codes for [&#/] stream.
     2711enum MarkupSortCodes {
     2712  StartTagTwoBitCode = 0,
     2713  EndTagTwoBitCode = 2,
     2714  GeneralRefCode = 1,
     2715  CharRefCode = 3
     2716};
     2717
     2718
     2719static inline int GetBitPair(SIMD_type * stream, int bit_posn) {
     2720        return bitstream_segment_from(stream, bit_posn) & 3;
     2721}
     2722
     2723template <class B, WorkingCharacterSet W>
     2724void ParsingEngine<B, W>::ParseContent() {
     2725/*vector<int> MarkupPositions[4];*/
     2726int MarkupPositions[4][BUFFER_SIZE];
     2727int MarkupCounts[4];
     2728        int start_code = 0;
     2729        int end_code = 0;
     2730        int charref_code = 0;
     2731        int general_ref_code = 0;
     2732
     2733        DocumentStart_action();
     2734        bool is_emptyStartTag = false;
     2735                for (int i = 0; i < 4; i++) MarkupCounts[i] = 0;
     2736                text_or_markup_start = AbsPos();
     2737        do {
     2738                unsigned long segment = bitstream_segment_from(buf->item_stream[MarkupStart], buffer_rel_pos);
     2739//printf("buffer_rel_pos = %i, segment = %x\n", buffer_rel_pos, segment);
     2740                if (segment != 0) {
     2741                        buffer_rel_pos += cfzl(segment);
     2742                text_or_markup_start = AbsPos();
     2743                        int markup_code = GetBitPair(buf->item_stream[AmpHashSlash], buffer_rel_pos);
     2744                        MarkupPositions[markup_code][MarkupCounts[markup_code]] = AbsPos();
     2745                        MarkupCounts[markup_code]++;
     2746                        Advance(1);
     2747                }
     2748                else {
     2749                        buffer_rel_pos = (buffer_rel_pos & -8) + 8*sizeof(unsigned long);
     2750// printf("buffer_rel_pos = %i, segment = %x\n", buffer_rel_pos, segment);
     2751
     2752                        if (buffer_rel_pos >= buffer_limit_pos) {
     2753/*                              for (int i = 0; i < MarkupCounts[StartTagTwoBitCode]; i++) {
     2754                                        start_code += MarkupPositions[StartTagTwoBitCode][i];
     2755                                }
     2756                                for (int i = 0; i < MarkupCounts[EndTagTwoBitCode]; i++) {
     2757                                        end_code |= MarkupPositions[EndTagTwoBitCode][i];
     2758                                }
     2759                                for (int i = 0; i < MarkupCounts[GeneralRefCode]; i++) {
     2760                                        general_ref_code += 1;
     2761                                }
     2762                                for (int i = 0; i < MarkupCounts[CharRefCode]; i++) {
     2763                                        charref_code += 1;
     2764                                }*/
     2765/*      printf("Start_code: %i\n", start_code);
     2766        printf("End_code: %i\n", end_code);
     2767        printf("general_ref_code: %i\n", general_ref_code);
     2768        printf("charref_code: %i\n", charref_code);*/
     2769                                for (int i = 0; i < 4; i++) MarkupCounts[i] = 0;
     2770                                if (buffer_rel_pos >= BUFFER_SIZE) {
     2771                                        AdjustBufferEndForIncompleteSequences();
     2772                                        Parser_Interface<W>::FinalizeBuffer_action();
     2773                                        AdvanceBuffers();
     2774                                }
     2775                                else break;
     2776                        }
     2777                       
     2778                }
     2779
     2780        } while (1);
     2781/*      vector<int>::iterator i;
     2782        for (i = MarkupPositions[StartTagTwoBitCode].begin(); i != MarkupPositions[StartTagTwoBitCode].end(); i++) {
     2783                start_code += *i;
     2784        }
     2785        for (i = MarkupPositions[EndTagTwoBitCode].begin(); i != MarkupPositions[EndTagTwoBitCode].end(); i++) {
     2786                end_code |= *i;
     2787        }
     2788        for (i = MarkupPositions[GeneralRefCode].begin(); i != MarkupPositions[GeneralRefCode].end(); i++) {
     2789                general_ref_code += 1;
     2790        }
     2791        for (i = MarkupPositions[CharRefCode].begin(); i != MarkupPositions[CharRefCode].end(); i++) {
     2792                charref_code += 1;
     2793        }*/
     2794        printf("Start_code: %i\n", start_code);
     2795        printf("End_code: %i\n", end_code);
     2796        printf("general_ref_code: %i\n", general_ref_code);
     2797        printf("charref_code: %i\n", charref_code);
     2798        DocumentEnd_action();   
     2799}
     2800
     2801#endif
     2802
     2803
     2804
     2805
  • trunk/src/engine.h

    r188 r197  
    88#ifndef ENGINE_H
    99#define ENGINE_H
     10
     11/*  Parabix provides strings to the application using the WorkingCharacterSet.
     12    This parameter is set by template instantiation; normally only one
     13    WorkingCharacterSet parameter is chosen.  However, it is possible
     14    to compile different parsers having different WorkingCharacterSet
     15    parameters within one run-time code base.
     16*/
     17
     18enum WorkingCharacterSet {UTF_8, UTF_16, UTF_32};
    1019
    1120#include "xmlmodel.h"
     
    2130data.  */
    2231
     32template <WorkingCharacterSet W>
    2333class Parser_Interface {
    2434public:
     
    4454        Model_Info * model_info;
    4555        Entity_Info * entity_Info;
    46 protected:
    47         /* Co-classes */
    48 
    49         Byteplex * byteplex;   
    50         Bitplex * bitplex;
    51         Lexer_Interface * lexer;
    52         /* Parallel data streams for current buffer full of XML data. */
    53         BytePack * x8data;
    54         LexicalStreamSet * buf;
    55                
    56         int buffer_base_pos;
    57         int buffer_rel_pos;
    58         int buffer_limit_pos;
     56
     57
     58        /* Action routine for document start. */
     59        void DocumentStart_action();   
     60       
     61        /* Action routine for document end. */
     62        void DocumentEnd_action();
     63       
     64        /* Action routine for an XML comment in "<!--"  "-->" brackets. */
     65        void Comment_action(unsigned char * item, int lgth);
     66       
     67        /* Action routine called upon recognizing "<![CDATA[" to start a CDATA section. */
     68        void CDATA_start_action(unsigned char * CDATA_ptr);
     69
     70        /* Action routine called upon recognizing "]]>" to end a CDATA section. */
     71        void CDATA_end_action(unsigned char * CDATA_end_ptr);
     72       
     73        /* Action routine for an XML processing instruction enclosed in "<?" and "?>" brackets. */
     74        void PI_action(unsigned char * item, int lgth);
     75       
     76        /* Action routine for an empty element enclosed in "<" and "/>" brackets. */
     77        void EmptyElement_action(unsigned char * item, int lgth);
     78       
     79        /* Action routine for a start tag enclosed in "<" and ">" brackets. */
     80        void StartTag_action(unsigned char * item, int lgth);
     81       
     82        /* Action routine for an end tag enclosed in "</" and ">" brackets. */
     83        void EndTag_action(unsigned char * item, int lgth);
     84       
     85        /* Action routine for an error item */
     86        void Error_action(unsigned char * item, int lgth);
     87       
     88        /* Action routine for a text item */
     89        void Text_action(unsigned char * item, int lgth, bool more);
     90       
     91        /* Action routine for a character or entity reference.*/
     92        void Reference_action(unsigned char * item, int lgth);
     93       
     94        /* Action routine for an element name occurring immediately after the
     95        opening "<" of a start tag or empty element tag. */
     96        void ElementName_action(unsigned char * item, int lgth);
     97       
     98        /* Action routine for a processing instruction target name occurring immediately
     99        after the opening "<?" of a processing instruction. */
     100        void PI_Target_action(unsigned char * item, int lgth);
     101       
     102        /* Action routine for an individual attribute/value pair occurring in
     103        a element start tag or an empty element tag. */
     104        void AttributeValue_action(unsigned char * name, int name_lgth,
     105                                   unsigned char * val, int val_lgth);
     106       
     107        /* Action routine for an individual namespace binding occurring in
     108        a element start tag or an empty element tag. */
     109        void Namespace_action(unsigned char * name, int name_end,
     110                              unsigned char * URI, int URI_end);
     111       
     112        /*Action routine for end of buffer events. */
     113        void FinalizeBuffer_action();
     114       
     115        /*Document Type actions.*/
     116        void Doctype_action(unsigned char * item, int lgth);
     117        void PEReference_action(unsigned char * item, int lgth);
     118       
     119        void Prolog_action(unsigned char * item, int lgth);
     120       
     121        void ExtSubsetDecl_action(unsigned char * item, int lgth);
    59122       
    60123};
    61124
    62 template <class B>
    63 class ParsingEngine : public Parser_Interface {
     125template <class B, WorkingCharacterSet W>
     126class ParsingEngine : public Parser_Interface<W> {
    64127public:
    65128        ParsingEngine(Entity_Info * e, Model_Info * m, Byteplex * b, bool is_external);
     
    150213        void Parse_ExtSubsetDecl ();
    151214       
    152         /* Action routine for document start. */
    153         void DocumentStart_action();   
    154        
    155         /* Action routine for document end. */
    156         void DocumentEnd_action();
    157        
    158         /* Action routine for an XML comment in "<!--"  "-->" brackets. */
    159         void Comment_action(unsigned char * item, int lgth);
    160        
    161         /* Action routine called upon recognizing "<![CDATA[" to start a CDATA section. */
    162         void CDATA_start_action(unsigned char * CDATA_ptr);
    163 
    164         /* Action routine called upon recognizing "]]>" to end a CDATA section. */
    165         void CDATA_end_action(unsigned char * CDATA_end_ptr);
    166        
    167         /* Action routine for an XML processing instruction enclosed in "<?" and "?>" brackets. */
    168         void PI_action(unsigned char * item, int lgth);
    169        
    170         /* Action routine for an empty element enclosed in "<" and "/>" brackets. */
    171         void EmptyElement_action(unsigned char * item, int lgth);
    172        
    173         /* Action routine for a start tag enclosed in "<" and ">" brackets. */
    174         void StartTag_action(unsigned char * item, int lgth);
    175        
    176         /* Action routine for an end tag enclosed in "</" and ">" brackets. */
    177         void EndTag_action(unsigned char * item, int lgth);
    178        
    179         /* Action routine for an error item */
    180         void Error_action(unsigned char * item, int lgth);
    181        
    182         /* Action routine for a text item */
    183         void Text_action(unsigned char * item, int lgth, bool more);
    184        
    185         /* Action routine for a character or entity reference.*/
    186         void Reference_action(unsigned char * item, int lgth);
    187        
    188         /* Action routine for an element name occurring immediately after the
    189         opening "<" of a start tag or empty element tag. */
    190         void ElementName_action(unsigned char * item, int lgth);
    191        
    192         /* Action routine for a processing instruction target name occurring immediately
    193         after the opening "<?" of a processing instruction. */
    194         void PI_Target_action(unsigned char * item, int lgth);
    195        
    196         /* Action routine for an individual attribute/value pair occurring in
    197         a element start tag or an empty element tag. */
    198         void AttributeValue_action(unsigned char * name, int name_lgth,
    199                                    unsigned char * val, int val_lgth);
    200        
    201         /* Action routine for an individual namespace binding occurring in
    202         a element start tag or an empty element tag. */
    203         void Namespace_action(unsigned char * name, int name_end,
    204                               unsigned char * URI, int URI_end);
    205        
    206         /*Action routine for end of buffer events. */
    207         void FinalizeBuffer_action();
    208        
    209         /*Document Type actions.*/
    210         void Doctype_action(unsigned char * item, int lgth);
    211         void PEReference_action(unsigned char * item, int lgth);
    212        
    213         void Prolog_action(unsigned char * item, int lgth);
    214        
    215         void ExtSubsetDecl_action(unsigned char * item, int lgth);
     215protected:
     216        /* Co-classes */
     217
     218        Byteplex * byteplex;   
     219        Bitplex * bitplex;
     220        Lexer_Interface * lexer;
     221        /* Parallel data streams for current buffer full of XML data. */
     222        BytePack * x8data;
     223        LexicalStreamSet * buf;
     224               
     225        int buffer_base_pos;
     226        int buffer_rel_pos;
     227        int buffer_limit_pos;
    216228};
    217229
Note: See TracChangeset for help on using the changeset viewer.