Changeset 160 for trunk/src/engine.c


Ignore:
Timestamp:
Jun 20, 2008, 3:30:40 PM (11 years ago)
Author:
lindanl
Message:

Restructured character set architecture; StringPool? in symbol table.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/engine.c

    r156 r160  
    5656        Byteplex * b = Byteplex::ByteplexFactory(e, infile);
    5757        b->InitializeBuffer(signature,4);
    58 
     58        b->DoByteplex();
     59        b->PreparePseudoASCII_Stream();
     60       
    5961        if (e->code_unit_base == ASCII) {
    60                 return new ParsingEngine<ASCII>(e, m, b, false);
     62                XML_Decl_Parser<ASCII> decl_parser(b);
     63                decl_parser.ReadXMLInfo(e);
     64                if (e->code_unit_size == SingleByte) {
     65                        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);
     68                }
     69                else if (e->code_unit_size == DoubleByte) {
     70                        return new ParsingEngine<U16_Buffer>(e, m, b, false);
     71                }
     72                else if (e->code_unit_size == QuadByte) {
     73                        return new ParsingEngine<U32_Buffer>(e, m, b, false);
     74                }
    6175        }
    6276        else /* if (e->code_unit_base == EBCDIC) */ {
    63                 return new ParsingEngine<EBCDIC>(e, m, b, false);
     77                XML_Decl_Parser<EBCDIC> decl_parser(b);
     78                decl_parser.ReadXMLInfo(e);
     79                return new ParsingEngine< X8_Buffer<EBCDIC> >(e, m, b, false);
    6480        }       
    6581}
     
    8096        Byteplex * b = Byteplex::ByteplexFactory(e, infile);
    8197        b->InitializeBuffer(signature,4);
    82 
     98        b->DoByteplex();
     99        b->PreparePseudoASCII_Stream();
    83100        if (e->code_unit_base == ASCII) {
    84                 return new ParsingEngine<ASCII>(e, m, b, true);
     101                XML_Decl_Parser<ASCII> decl_parser(b);
     102                decl_parser.ReadXMLInfo(e);
     103                if (e->code_unit_size == SingleByte) {
     104                        return new ParsingEngine< X8_Buffer<ASCII> >(e, m, b, true);
     105                }
     106                else if (e->code_unit_size == DoubleByte) {
     107                        return new ParsingEngine<U16_Buffer>(e, m, b, true);
     108                }
     109                else if (e->code_unit_size == QuadByte) {
     110                        return new ParsingEngine<U32_Buffer>(e, m, b, true);
     111                }
    85112        }
    86113        else /* if (e->code_unit_base == EBCDIC) */ {
    87                 return new ParsingEngine<EBCDIC>(e, m, b, true);
     114                XML_Decl_Parser<EBCDIC> decl_parser(b);
     115                decl_parser.ReadXMLInfo(e);
     116                return new ParsingEngine< X8_Buffer<EBCDIC> >(e, m, b, true);
    88117        }       
    89118}
    90119
    91 Parser_Interface * Parser_Interface::ParserFactory(char * byte_buffer, int byte_count, Entity_Info * e, Model_Info * m){
     120Parser_Interface * Parser_Interface::ParserFactory(char * byte_buffer, int byte_count, Entity_Info * e1, Model_Info * m){
     121        Entity_Info * e = new Entity_Info;
     122        e->BOM_units = 0;
     123        e->code_unit_base=e1->code_unit_base;
     124        e->code_unit_size=e1->code_unit_size;
     125        e->version=e1->version;
     126        e->encoding=e1->encoding;
     127        e->content_start = 0;
    92128        Byteplex * b = Byteplex::ByteplexFactory(e, (unsigned char *) byte_buffer, byte_count);
     129        b->DoByteplex();
     130        b->PreparePseudoASCII_Stream();
    93131        if (e->code_unit_base == ASCII) {
    94                 return new ParsingEngine<ASCII>(e, m, b, false);
    95         }
    96         else {
    97                 return new ParsingEngine<EBCDIC>(e, m, b, false);
     132                if (e->code_unit_size == SingleByte) {
     133                        return new ParsingEngine< X8_Buffer<ASCII> >(e, m, b, false);
     134                }
     135                else if (e->code_unit_size == DoubleByte) {
     136                        return new ParsingEngine<U16_Buffer>(e, m, b, false);
     137                }
     138                else if (e->code_unit_size == QuadByte) {
     139                        return new ParsingEngine<U32_Buffer>(e, m, b, false);
     140                }
     141        }
     142        else /* if (e->code_unit_base == EBCDIC) */ {
     143                return new ParsingEngine< X8_Buffer<EBCDIC> >(e, m, b, false);
    98144        }       
    99145}
     
    128174}
    129175
    130 
    131 
    132 
    133 template <CodeUnit_Base C>
    134 ParsingEngine<C>::ParsingEngine(Entity_Info * e, Model_Info * m, Byteplex * b, bool is_external) : Parser_Interface () {
     176template <class B>
     177inline unsigned char * ParsingEngine<B>::GetCodeUnitPtr(int pos) {
     178        int rel_pos = pos - buffer_base_pos;
     179        return &((unsigned char *) (byteplex->src_buffer))[rel_pos * (int) B::Size];
     180}
     181
     182
     183
     184
     185template <class B>
     186ParsingEngine<B>::ParsingEngine(Entity_Info * e, Model_Info * m, Byteplex * b, bool is_external) : Parser_Interface () {
    135187        entity_Info = e;
    136188        model_info = m;
    137189        byteplex = b;
    138190
    139         byteplex->DoByteplex();
    140         byteplex->PreparePseudoASCII_Stream();
     191        m->symbol_table = new Symbol_Table();
     192        m->SimpleEntity("lt", "<");
     193        m->SimpleEntity("gt", ">");
     194        m->SimpleEntity("amp", "&");
     195        m->SimpleEntity("quot", "\"");
     196        m->SimpleEntity("apos", "'");   
     197
     198
    141199        StrictWellFormedness=false;
    142200        LastAttOccurrence.assign(m->globalAttributeCount+1, 0);
    143201       
    144         decl_parser = new XML_Decl_Parser<C>(byteplex);
    145         int content_start = 0;
    146         if(is_external == true)
    147                 content_start = decl_parser->ReadTextDeclaration(entity_Info);
    148         else
    149                 content_start = decl_parser->ReadXMLInfo(entity_Info);
    150202       
    151203        bitplex = new Bitplex;
     
    164216
    165217        buffer_base_pos = 0;
    166         buffer_rel_pos = content_start;
     218        buffer_rel_pos = e->content_start;
    167219        buffer_limit_pos = min(BUFFER_SIZE, byteplex->units_in_buffer);
    168220        int blocks_in_buffer = (buffer_limit_pos + BLOCKSIZE - 1)/BLOCKSIZE;
    169221        x8data = byteplex->x8data;
    170         lexer = Lexer<C>::LexerFactory(e, buf);
     222        lexer = Lexer<B::Base>::LexerFactory(e, buf);
    171223        bitplex->TransposeToBitStreams(byteplex->x8data, blocks_in_buffer);
    172224        lexer->AnalyzeBuffer(bitplex->x8basis, buffer_base_pos, buffer_rel_pos, buffer_limit_pos);
    173225}
    174226
    175 template <CodeUnit_Base C>
    176 ParsingEngine<C>::~ParsingEngine() {
     227template <class B>
     228ParsingEngine<B>::~ParsingEngine() {
    177229  // How do we do this?  model_info->~Model_Info();
    178230  entity_Info->~Entity_Info();
    179231  byteplex->~Byteplex();
    180   decl_parser->~XML_Decl_Parser<C>();
    181232  bitplex->~Bitplex();
    182233  simd_delete((SIMD_type *) buf);
     
    184235}
    185236
    186 template <CodeUnit_Base C>
    187 inline void ParsingEngine<C>::AdvanceBuffers(){
     237template <class B>
     238inline void ParsingEngine<B>::AdvanceBuffers(){
    188239#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == ADVANCE_BUFFERS)
    189240        code_clocker->cc_start_interval();
     
    219270}
    220271
    221 template <CodeUnit_Base C>
    222 inline unsigned char * ParsingEngine<C>::cur() const {
     272template <class B>
     273inline unsigned char * ParsingEngine<B>::cur() const {
    223274  return &((unsigned char *) x8data)[buffer_rel_pos];
    224275}
    225276
    226 template <CodeUnit_Base C>
    227 inline int ParsingEngine<C>::AbsPos() const {
     277template <class B>
     278inline int ParsingEngine<B>::AbsPos() const {
    228279  return buffer_base_pos + buffer_rel_pos;
    229280}
    230281
    231 template <CodeUnit_Base C>
    232 inline int ParsingEngine<C>::LengthFrom(int start_pos) const {
     282template <class B>
     283inline int ParsingEngine<B>::LengthFrom(int start_pos) const {
    233284  return buffer_base_pos + buffer_rel_pos - start_pos;
    234285}
     
    236287
    237288
    238 template <CodeUnit_Base C>
    239 inline int ParsingEngine<C>::BufferRelPos() const {
     289template <class B>
     290inline int ParsingEngine<B>::BufferRelPos() const {
    240291  return buffer_rel_pos;
    241292}
    242293
    243294
    244 template <CodeUnit_Base C>
    245 inline bool ParsingEngine<C>::at_EOF() const {
     295template <class B>
     296inline bool ParsingEngine<B>::at_EOF() const {
    246297  return (buffer_rel_pos >= buffer_limit_pos) &&
    247298         (buffer_limit_pos < BUFFER_SIZE);
    248299}
    249300
    250 template <CodeUnit_Base C>
    251 inline void ParsingEngine<C>::Advance(int n) {
     301template <class B>
     302inline void ParsingEngine<B>::Advance(int n) {
    252303        buffer_rel_pos += n;
    253304  if (buffer_rel_pos >= BUFFER_SIZE) { 
     
    259310
    260311#ifndef OPTIMIZE_SHORT_SCAN
    261 template <CodeUnit_Base C>
    262 inline void ParsingEngine<C>::ScanTo(int item) {
     312template <class B>
     313inline void ParsingEngine<B>::ScanTo(int item) {
    263314  buffer_rel_pos = bitstream_scan(buf->item_stream[item],
    264315                                      buffer_rel_pos);
     
    277328}
    278329
    279 template <CodeUnit_Base C>
    280 inline void ParsingEngine<C>::ScanToMarkupStart() {
     330template <class B>
     331inline void ParsingEngine<B>::ScanToMarkupStart() {
    281332        text_or_markup_start = AbsPos();
    282333        buffer_rel_pos = bitstream_scan(buf->item_stream[MarkupStart], buffer_rel_pos);
     
    291342}
    292343
    293 template <CodeUnit_Base C>
    294 inline void ParsingEngine<C>::ScanToCD_End_check() {
     344template <class B>
     345inline void ParsingEngine<B>::ScanToCD_End_check() {
    295346        buffer_rel_pos = bitstream_scan(buf->item_stream[CD_End_check], buffer_rel_pos);
    296347        while (buffer_rel_pos >= BUFFER_SIZE) {
     
    305356
    306357#ifdef OPTIMIZE_SHORT_SCAN
    307 template <CodeUnit_Base C>
    308 inline void ParsingEngine<C>::ScanTo(int item) {
     358template <class B>
     359inline void ParsingEngine<B>::ScanTo(int item) {
    309360  SIMD_type * stream = buf->item_stream[item];
    310361  unsigned long * bitstream_ptr = (unsigned long *) (((intptr_t) stream) + buffer_rel_pos/8);
     
    327378#endif
    328379
    329 template <CodeUnit_Base C>
    330 inline void ParsingEngine<C>::WF_Error (XML_Constraint errCode) {
     380template <class B>
     381inline void ParsingEngine<B>::WF_Error (XML_Constraint errCode) {
    331382        printf("Error at position %i in input.\n", AbsPos());
    332383        ShowConstraintError(errCode);
     
    336387       
    337388
    338 template <CodeUnit_Base C>
    339 inline void ParsingEngine<C>::Validity_Error (XML_Constraint errCode) {
     389template <class B>
     390inline void ParsingEngine<B>::Validity_Error (XML_Constraint errCode) {
    340391        printf("Error at position %i in input.\n", AbsPos());
    341392        ShowConstraintError(errCode);
     
    344395}
    345396       
    346 template <CodeUnit_Base C>
    347 inline void ParsingEngine<C>::Syntax_Error (XML_NonTerminal errNT) {
     397template <class B>
     398inline void ParsingEngine<B>::Syntax_Error (XML_NonTerminal errNT) {
    348399        printf("Error at position %i in input.\n", AbsPos());
    349400        ShowSyntaxError(errNT);
     
    354405
    355406/* Parse a comment beginning "<!--" */
    356 template <CodeUnit_Base C>
    357 inline void ParsingEngine<C>::Parse_Comment() {
     407template <class B>
     408inline void ParsingEngine<B>::Parse_Comment() {
    358409
    359410        Advance(4); /* Skip "<!--". */
    360411        ScanTo(Hyphen);
    361         while (!at_DoubleHyphen<C>(cur())) {
     412        while (!at_DoubleHyphen<B::Base>(cur())) {
    362413                if(at_EOF())
    363414                        Syntax_Error(NT_CDSect);
     
    365416                ScanTo(Hyphen);
    366417        }
    367         if (at_Comment_End<C>(cur())) {
     418        if (at_Comment_End<B::Base>(cur())) {
    368419                Advance(3); /* Skip "-->". */
    369420                Comment_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     
    376427
    377428/* Parse an end tag beginning "</" */
    378 template <CodeUnit_Base C>
    379 inline void ParsingEngine<C>::Parse_EndTag() {
     429template <class B>
     430inline void ParsingEngine<B>::Parse_EndTag() {
    380431        Advance(2); /* Skip "</". */
    381432        int nameID = Parse_Name();
    382         if (AtChar<C,'>'>(cur())) {
     433        if (AtChar<B::Base,'>'>(cur())) {
    383434                Advance(1);
    384435                EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     
    386437        else {
    387438                ScanTo(NonWS);
    388                 if (AtChar<C,'>'>(cur())) {
     439                if (AtChar<B::Base,'>'>(cur())) {
    389440                        Advance(1);
    390441                        EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     
    395446
    396447/* Parse a CDATA section beginning "<![CDATA". */
    397 template <CodeUnit_Base C>
    398 inline void ParsingEngine<C>::Parse_CDATA() {
     448template <class B>
     449inline void ParsingEngine<B>::Parse_CDATA() {
    399450        Advance(8); /* Skip "<![CDATA". */
    400         if (!AtChar<C,'['>(cur())) {
     451        if (!AtChar<B::Base,'['>(cur())) {
    401452                Syntax_Error(NT_CDStart);
    402453        }
     
    406457                text_or_markup_start = AbsPos();
    407458                ScanTo(CD_End_check);
    408                 while (!at_CDATA_End<C>(cur())) {
     459                while (!at_CDATA_End<B::Base>(cur())) {
    409460                        if(at_EOF())
    410461                                Syntax_Error(NT_CDSect);
     
    418469}
    419470
    420 template <CodeUnit_Base C>
    421 inline void ParsingEngine<C>::Parse_EntityRef() {
     471template <class B>
     472inline void ParsingEngine<B>::Parse_EntityRef() {
    422473    Advance(1);  // skip "&"
    423474        int nameID = Parse_Name();  /* Name delimiter */
    424     if (!AtChar<C,';'>(cur())) {
     475    if (!AtChar<B::Base,';'>(cur())) {
    425476                Syntax_Error(NT_Reference);
    426477    }
     
    466517}
    467518
    468 template <CodeUnit_Base C>
    469 inline void ParsingEngine<C>::Parse_ValidEntityRef(CM_RegExp * cre, int & cur_state) {
     519template <class B>
     520inline void ParsingEngine<B>::Parse_ValidEntityRef(CM_RegExp * cre, int & cur_state) {
    470521    Advance(1);  // skip "&"
    471522        int nameID = Parse_Name();  /* Name delimiter */
    472     if (!AtChar<C,';'>(cur())) {
     523    if (!AtChar<B::Base,';'>(cur())) {
    473524                Syntax_Error(NT_Reference);
    474525    }
     
    514565}
    515566       
    516 template <CodeUnit_Base C>
    517 inline void ParsingEngine<C>::Parse_CharRef() {
     567template <class B>
     568inline void ParsingEngine<B>::Parse_CharRef() {
    518569        Advance(2);  // skip "&#"
    519570        int ch_val = 0;
    520         if (AtChar<C,'x'>(cur())) {
     571        if (AtChar<B::Base,'x'>(cur())) {
    521572                Advance(1);
    522                 while(at_HexDigit<C>(cur())){
    523                         ch_val = HexVal<C>(cur()[0]) + (ch_val<<4);
     573                while(at_HexDigit<B::Base>(cur())){
     574                        ch_val = HexVal<B::Base>(cur()[0]) + (ch_val<<4);
    524575                        if (ch_val> 0x10FFFF )
    525576                                WF_Error(wfErr_wf_Legalchar);
     
    528579        }
    529580        else {
    530                 while(at_Digit<C>(cur())){
    531                         ch_val = DigitVal<C>(cur()[0]) + ch_val*10;
     581                while(at_Digit<B::Base>(cur())){
     582                        ch_val = DigitVal<B::Base>(cur()[0]) + ch_val*10;
    532583                        if (ch_val> 0x10FFFF )
    533584                                WF_Error(wfErr_wf_Legalchar);
     
    541592                                WF_Error(wfErr_wf_Legalchar);
    542593                               
    543         if (!AtChar<C,';'>(cur())) {
     594        if (!AtChar<B::Base,';'>(cur())) {
    544595                        Syntax_Error(NT_CharRef);
    545596        }
     
    550601}
    551602
    552 template <CodeUnit_Base C>
    553 inline void ParsingEngine<C>::Parse_PI (){
     603template <class B>
     604inline void ParsingEngine<B>::Parse_PI (){
    554605        int nameID;
    555606        Advance(2); /* Skip "<?". */
    556607        int target_start = AbsPos();
    557         if (at_XxMmLll<C>(cur())) {
     608        if (at_XxMmLll<B::Base>(cur())) {
    558609                nameID = Parse_Name();
    559610                if (AbsPos() - target_start == 3) Syntax_Error(NT_PI);
     
    561612        else nameID = Parse_Name();
    562613        PI_Target_action(GetCodeUnitPtr(target_start), LengthFrom(target_start));
    563         if (!at_PI_End<C>(cur())) requireWS();
     614        if (!at_PI_End<B::Base>(cur())) requireWS();
    564615        ScanTo(QMark);
    565         while (!at_PI_End<C>(cur())) {
     616        while (!at_PI_End<B::Base>(cur())) {
    566617                if(at_EOF())
    567618                        Syntax_Error(NT_PI);
     
    574625 
    575626/* Parse a start or empty element tag. */
    576 template <CodeUnit_Base C>
    577 inline void ParsingEngine<C>::Parse_StartTag (){
     627template <class B>
     628inline void ParsingEngine<B>::Parse_StartTag (){
    578629        int att_name_start;
    579630        int att_val_start;
     
    585636        /* The following test optimizes the most common case of a
    586637        start tag with no attributes.  */
    587         if (AtChar<C,'>'>(cur())) {
     638        if (AtChar<B::Base,'>'>(cur())) {
    588639                Advance(1);
    589640                StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     
    591642        else {
    592643                ScanTo(NonWS);
    593                 if (AtChar<C,'>'>(cur())) {
     644                if (AtChar<B::Base,'>'>(cur())) {
    594645                        Advance(1);
    595646                        StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    596647                }
    597                 else if (at_EmptyElementDelim<C>(cur())) {
     648                else if (at_EmptyElementDelim<B::Base>(cur())) {
    598649                        Advance(2);
    599650                        EmptyElement_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     
    618669                        In many cases, the very first test handles 100% of actual
    619670                        attribute-value pairs encountered. */
    620                         if (at_EqualsQuote<C>(cur())) Advance(1);
     671                        if (at_EqualsQuote<B::Base>(cur())) Advance(1);
    621672                        else {
    622673                                ScanTo(NonWS);
    623                                 if (!AtChar<C,'='>(cur())) {
     674                                if (!AtChar<B::Base,'='>(cur())) {
    624675                                        Syntax_Error(NT_STag);
    625676                                        break;
     
    627678                                Advance(1);
    628679                                ScanTo(NonWS);
    629                                 if (!AtQuote<C>(cur())) {
     680                                if (!AtQuote<B::Base>(cur())) {
    630681                                        Syntax_Error(NT_STag);
    631682                                        break;
     
    635686                        Parse_AttValue();
    636687                        att_val_end = AbsPos()-1;
    637                         if (at_xmlns<C>(cur()+att_name_start-AbsPos())) {
     688                        if (at_xmlns<B::Base>(cur()+att_name_start-AbsPos())) {
    638689                                Namespace_action(GetCodeUnitPtr(att_name_start), att_name_end - att_name_start,
    639690                                                 GetCodeUnitPtr(att_val_start), att_val_end - att_val_start);
     
    644695                        }
    645696                        /* Now check for end or repeat. Avoid whitespace scan if possible.*/
    646                         if (AtChar<C,'>'>(cur())) {
     697                        if (AtChar<B::Base,'>'>(cur())) {
    647698                                Advance(1);
    648699                                StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    649700                                break;
    650701                        }
    651                         else if (at_EmptyElementDelim<C>(cur())) {
     702                        else if (at_EmptyElementDelim<B::Base>(cur())) {
    652703                                Advance(2);
    653704                                EmptyElement_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     
    655706                        }
    656707                        ScanTo(NonWS);
    657                         if (AtChar<C,'>'>(cur())) {
     708                        if (AtChar<B::Base,'>'>(cur())) {
    658709                                Advance(1);
    659710                                StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    660711                                break;
    661712                        }
    662                         else if (at_EmptyElementDelim<C>(cur())) {
     713                        else if (at_EmptyElementDelim<B::Base>(cur())) {
    663714                                Advance(2);
    664715                                EmptyElement_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     
    674725}
    675726
    676 template <CodeUnit_Base C>
    677 inline void ParsingEngine<C>::text_if_nonnull_action(){
     727template <class B>
     728inline void ParsingEngine<B>::text_if_nonnull_action(){
    678729        if (AbsPos() > text_or_markup_start) {
    679730                Text_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     
    684735
    685736
    686 template <CodeUnit_Base C>
    687 inline void ParsingEngine<C>::Parse_WF_EndTag(int nameID) {
     737template <class B>
     738inline void ParsingEngine<B>::Parse_WF_EndTag(int nameID) {
    688739        Advance(2); /* Skip "</". */
    689740       
     
    736787//      if (start_elem_name[lgth] != '\0') WF_Error(wfErr_GIMatch);
    737788
    738         if (AtChar<C,'>'>(cur())) {
     789        if (AtChar<B::Base,'>'>(cur())) {
    739790                Advance(1);
    740791                EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     
    742793    else {
    743794                ScanTo(NonWS);
    744                 if (AtChar<C,'>'>(cur())) {
     795                if (AtChar<B::Base,'>'>(cur())) {
    745796                        Advance(1);
    746797                        EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     
    750801}
    751802/* Parse a valid start or empty element tag. */
    752 template <CodeUnit_Base C>
    753 inline int ParsingEngine<C>::Parse_WF_StartTag (bool& is_emptyStartTag){
     803template <class B>
     804inline int ParsingEngine<B>::Parse_WF_StartTag (bool& is_emptyStartTag){
    754805        int att_name_start;
    755806        int att_val_start;
     
    768819        /* The following test optimizes the most common case of a
    769820        start tag with no attributes.  */
    770         if (AtChar<C,'>'>(cur())) {
     821        if (AtChar<B::Base,'>'>(cur())) {
    771822                Advance(1);
    772823                StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     
    774825        else {
    775826                ScanTo(NonWS);
    776                 if (AtChar<C,'>'>(cur())) {
     827                if (AtChar<B::Base,'>'>(cur())) {
    777828                        Advance(1);
    778829                        StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    779830                }
    780                 else if (at_EmptyElementDelim<C>(cur())) {
     831                else if (at_EmptyElementDelim<B::Base>(cur())) {
    781832                        Advance(2);
    782833                        is_emptyStartTag = true;
     
    809860                        In many cases, the very first test handles 100% of actual
    810861                        attribute-value pairs encountered. */
    811                         if (at_EqualsQuote<C>(cur())) Advance(1);
     862                        if (at_EqualsQuote<B::Base>(cur())) Advance(1);
    812863                        else {
    813864                                ScanTo(NonWS);
    814                                 if (!AtChar<C,'='>(cur())) {
     865                                if (!AtChar<B::Base,'='>(cur())) {
    815866                                        Syntax_Error(NT_STag);
    816867                                        break;
     
    818869                                Advance(1);
    819870                                ScanTo(NonWS);
    820                                 if (!AtQuote<C>(cur())) {
     871                                if (!AtQuote<B::Base>(cur())) {
    821872                                        Syntax_Error(NT_STag);
    822873                                        break;
     
    826877                        Parse_AttValue();
    827878                        att_val_end = AbsPos()-1;
    828                         if (at_xmlns<C>(cur()+att_name_start-AbsPos())) {
     879                        if (at_xmlns<B::Base>(cur()+att_name_start-AbsPos())) {
    829880                                Namespace_action(GetCodeUnitPtr(att_name_start), att_name_end - att_name_start,
    830881                                                 GetCodeUnitPtr(att_val_start), att_val_end - att_val_start);
     
    835886                        }
    836887                        /* Now check for end or repeat. Avoid whitespace scan if possible.*/
    837                         if (AtChar<C,'>'>(cur())) {
     888                        if (AtChar<B::Base,'>'>(cur())) {
    838889                                Advance(1);
    839890                                StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    840891                                break;
    841892                        }
    842                         else if (at_EmptyElementDelim<C>(cur())) {
     893                        else if (at_EmptyElementDelim<B::Base>(cur())) {
    843894                                Advance(2);
    844895                                is_emptyStartTag = true;       
     
    847898                        }
    848899                        ScanTo(NonWS);
    849                         if (AtChar<C,'>'>(cur())) {
     900                        if (AtChar<B::Base,'>'>(cur())) {
    850901                                Advance(1);
    851902                                StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    852903                                break;
    853904                        }
    854                         else if (at_EmptyElementDelim<C>(cur())) {
     905                        else if (at_EmptyElementDelim<B::Base>(cur())) {
    855906                                Advance(2);
    856907                                is_emptyStartTag = true;
     
    870921
    871922
    872 template <CodeUnit_Base C>
    873 inline void ParsingEngine<C>::Parse_WF_Element() {
     923template <class B>
     924inline void ParsingEngine<B>::Parse_WF_Element() {
    874925        bool is_emptyStartTag = false;
    875926        int nameID = Parse_WF_StartTag(is_emptyStartTag);
     
    884935
    885936
    886 template <CodeUnit_Base C>
    887 inline void ParsingEngine<C>::Parse_WF_Content() {
     937template <class B>
     938inline void ParsingEngine<B>::Parse_WF_Content() {
    888939        do {
    889940                text_or_markup_start = AbsPos();
    890941                ScanToMarkupStart(); /* '<', '&', or ']' for ']]>' test */
    891                 if (at_ElementTag_Start<C>(cur())) {
     942                if (at_ElementTag_Start<B::Base>(cur())) {
    892943                        text_if_nonnull_action();
    893944                        Parse_WF_Element();
    894945                }
    895                 else if (at_EndTag_Start<C>(cur())) {
     946                else if (at_EndTag_Start<B::Base>(cur())) {
    896947                        text_if_nonnull_action();
    897948                        return;
    898949                }
    899                 else if (at_Comment_Start<C>(cur())) {
     950                else if (at_Comment_Start<B::Base>(cur())) {
    900951                        text_if_nonnull_action();
    901952                        Parse_Comment();
    902953                }
    903                 else if (at_CharRef_Start<C>(cur())) {
     954                else if (at_CharRef_Start<B::Base>(cur())) {
    904955                        text_if_nonnull_action();
    905956                        Parse_CharRef();
    906957                }
    907                 else if (AtChar<C,'&'>(cur())) {
     958                else if (AtChar<B::Base,'&'>(cur())) {
    908959                        text_if_nonnull_action();
    909960                        Parse_EntityRef();
    910961                }
    911                 else if (at_CDATA_Start<C>(cur())) {
     962                else if (at_CDATA_Start<B::Base>(cur())) {
    912963                        text_if_nonnull_action();
    913964                        Parse_CDATA();
    914965                }
    915                 else if (at_PI_Start<C>(cur())) {
     966                else if (at_PI_Start<B::Base>(cur())) {
    916967                        text_if_nonnull_action();
    917968                        Parse_PI();
    918969                }
    919                 else if (at_CDATA_End<C>(cur())) {
     970                else if (at_CDATA_End<B::Base>(cur())) {
    920971                        text_if_nonnull_action();
    921972                        Advance(3);
     
    926977                        return;
    927978                }
    928                 else if (AtChar<C,'<'>(cur())) {
     979                else if (AtChar<B::Base,'<'>(cur())) {
    929980                        Syntax_Error(NT_markupdecl);
    930981                }
     
    938989
    939990
    940 template <CodeUnit_Base C>
    941 inline void ParsingEngine<C>::ParseContent() {
     991template <class B>
     992inline void ParsingEngine<B>::ParseContent() {
    942993        DocumentStart_action();
    943994        bool is_emptyStartTag = false;
     
    945996                text_or_markup_start = AbsPos();
    946997                ScanToMarkupStart(); /* '<', '&', or ']' for ']]>' test */
    947 /*              if (AtChar<C,'<'>(cur())) {
    948                         text_if_nonnull_action();
    949                         Parse_Markup<C>();
     998/*              if (AtChar<B::Base,'<'>(cur())) {
     999                        text_if_nonnull_action();
     1000                        Parse_Markup<B>();
    9501001                }*/
    951                 if (at_ElementTag_Start<C>(cur())) {
     1002                if (at_ElementTag_Start<B::Base>(cur())) {
    9521003                        text_if_nonnull_action();
    9531004                        Parse_StartTag();
    9541005                }
    955                 else if (at_EndTag_Start<C>(cur())) {
     1006                else if (at_EndTag_Start<B::Base>(cur())) {
    9561007                        text_if_nonnull_action();
    9571008                        Parse_EndTag();
    9581009                }
    959                 else if (at_Comment_Start<C>(cur())) {
     1010                else if (at_Comment_Start<B::Base>(cur())) {
    9601011                        text_if_nonnull_action();
    9611012                        Parse_Comment();
    9621013                }
    963                 else if (at_CharRef_Start<C>(cur())) {
     1014                else if (at_CharRef_Start<B::Base>(cur())) {
    9641015                        text_if_nonnull_action();
    9651016                        Parse_CharRef();
    9661017                }
    967                 else if (AtChar<C,'&'>(cur())) {
     1018                else if (AtChar<B::Base,'&'>(cur())) {
    9681019                        text_if_nonnull_action();
    9691020                        Parse_EntityRef();
    9701021                }
    971                 else if (at_CDATA_Start<C>(cur())) {
     1022                else if (at_CDATA_Start<B::Base>(cur())) {
    9721023                        text_if_nonnull_action();
    9731024                        Parse_CDATA();
    9741025                }
    975                 else if (at_PI_Start<C>(cur())) {
     1026                else if (at_PI_Start<B::Base>(cur())) {
    9761027                        text_if_nonnull_action();
    9771028                        Parse_PI();
    9781029                }
    979                 else if (at_CDATA_End<C>(cur())) {
     1030                else if (at_CDATA_End<B::Base>(cur())) {
    9801031                        text_if_nonnull_action();
    9811032                        Advance(3);
     
    9861037                        break;
    9871038                }
    988                 else if (AtChar<C,'<'>(cur())) {
     1039                else if (AtChar<B::Base,'<'>(cur())) {
    9891040                        Syntax_Error(NT_markupdecl);
    9901041                }
     
    9981049
    9991050
    1000 template <CodeUnit_Base C>
    1001 inline void ParsingEngine<C>::Parse_DocType (){
     1051template <class B>
     1052inline void ParsingEngine<B>::Parse_DocType (){
    10021053
    10031054        int old_abspos, start_pos;
     
    10051056        start_pos = AbsPos();
    10061057       
    1007         if (at_DOCTYPE_start<C>(cur()))
     1058        if (at_DOCTYPE_start<B::Base>(cur()))
    10081059        Advance(9);
    10091060        else{
     
    10161067        old_abspos = AbsPos(); 
    10171068    ScanTo(NonWS);
    1018     if(at_SYSTEM<C>(cur())||at_PUBLIC<C>(cur())){
     1069    if(at_SYSTEM<B::Base>(cur())||at_PUBLIC<B::Base>(cur())){
    10191070        model_info->has_external_DTD = true;
    10201071        if(old_abspos == AbsPos())
     
    10291080    ScanTo(NonWS);     
    10301081
    1031         if (AtChar<C,'['>(cur())){
     1082        if (AtChar<B::Base,'['>(cur())){
    10321083                Advance(1);
    10331084                Parse_IntSubset();
    1034                 if (AtChar<C,']'>(cur()))
     1085                if (AtChar<B::Base,']'>(cur()))
    10351086                        Advance(1);
    10361087                else
     
    10391090        }
    10401091       
    1041         if (AtChar<C,'>'>(cur())){
     1092        if (AtChar<B::Base,'>'>(cur())){
    10421093                Advance(1); 
    10431094
     
    10661117}
    10671118
    1068 template <CodeUnit_Base C>
    1069 inline void ParsingEngine<C>::Parse_ExternalID (char *& systemLiteral, char *& pubidLiteral){
     1119template <class B>
     1120inline void ParsingEngine<B>::Parse_ExternalID (char *& systemLiteral, char *& pubidLiteral){
    10701121        int quot_start, lgth;
    1071         if(at_SYSTEM<C>(cur())){
     1122        if(at_SYSTEM<B::Base>(cur())){
    10721123                Advance(6);
    10731124                pubidLiteral = NULL;
    10741125                requireWS();
    1075                 if (!AtQuote<C>(cur())) Syntax_Error(NT_ExternalID);
     1126                if (!AtQuote<B::Base>(cur())) Syntax_Error(NT_ExternalID);
    10761127                quot_start = AbsPos()+1;
    10771128                Parse_SystemLiteral (); /*  SystemLiteral */
     
    10791130                systemLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
    10801131        }
    1081         else if (at_PUBLIC<C>(cur())){
     1132        else if (at_PUBLIC<B::Base>(cur())){
    10821133                Advance(6);
    10831134                requireWS();
    1084                 if (!AtQuote<C>(cur())) Syntax_Error(NT_ExternalID);
     1135                if (!AtQuote<B::Base>(cur())) Syntax_Error(NT_ExternalID);
    10851136                quot_start = AbsPos()+1;
    10861137                Parse_PubidLiteral ();/*  PubidLiteral */
     
    10881139                pubidLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
    10891140                systemLiteral = NULL;
    1090                 if (AtChar<C, '>'>(cur())) return;
     1141                if (AtChar<B::Base, '>'>(cur())) return;
    10911142                requireWS();
    1092                 if (AtQuote<C>(cur())) {
     1143                if (AtQuote<B::Base>(cur())) {
    10931144                        quot_start = AbsPos()+1;       
    10941145                        Parse_SystemLiteral ();/*  SystemLiteral */
     
    11011152}
    11021153
    1103 template <CodeUnit_Base C>
    1104 inline void ParsingEngine<C>::Parse_SystemLiteral (){
     1154template <class B>
     1155inline void ParsingEngine<B>::Parse_SystemLiteral (){
    11051156        unsigned char quoteCh;
    1106         if(AtQuote<C>(cur())){
     1157        if(AtQuote<B::Base>(cur())){
    11071158                quoteCh = cur()[0];
    11081159                Advance(1);
     
    11181169}
    11191170
    1120 template <CodeUnit_Base C>
    1121 inline void ParsingEngine<C>::Parse_PubidLiteral (){
     1171template <class B>
     1172inline void ParsingEngine<B>::Parse_PubidLiteral (){
    11221173        unsigned char quoteCh;
    1123         if(AtQuote<C>(cur())){
     1174        if(AtQuote<B::Base>(cur())){
    11241175                quoteCh = cur()[0];
    11251176                Advance(1);
    11261177        }       
    1127         while (at_PubidChar<C>(cur())) Advance(1);
     1178        while (at_PubidChar<B::Base>(cur())) Advance(1);
    11281179        if (cur()[0] != quoteCh){
    11291180                Syntax_Error(NT_PubidLiteral);
     
    11321183}
    11331184
    1134 template <CodeUnit_Base C>
    1135 inline void ParsingEngine<C>::Parse_IntSubset (){
     1185template <class B>
     1186inline void ParsingEngine<B>::Parse_IntSubset (){
    11361187       
    11371188        while(1){
    11381189                ScanTo(NonWS); 
    11391190                text_or_markup_start = AbsPos();
    1140                 if (AtChar<C,'%'>(cur()))
     1191                if (AtChar<B::Base,'%'>(cur()))
    11411192                        Parse_PEReference();   
    1142                 else if (at_PI_Start<C>(cur())) {
     1193                else if (at_PI_Start<B::Base>(cur())) {
    11431194                        Parse_PI();
    11441195                }
    1145                 else if (at_Comment_Start<C>(cur())) {
     1196                else if (at_Comment_Start<B::Base>(cur())) {
    11461197                        Parse_Comment();
    11471198                }
    1148                 else if (AtChar<C,'<'>(cur())){
     1199                else if (AtChar<B::Base,'<'>(cur())){
    11491200                        Advance(1);
    1150                         if(AtChar<C,'!'>(cur())){
     1201                        if(AtChar<B::Base,'!'>(cur())){
    11511202                                Advance(1);
    1152                                 if (at_ELEMENT<C>(cur()))
     1203                                if (at_ELEMENT<B::Base>(cur()))
    11531204                                        Parse_Elementdecl();
    1154                                 else if (at_ATTLIST<C>(cur()))
     1205                                else if (at_ATTLIST<B::Base>(cur()))
    11551206                                        Parse_AttlistDecl();
    1156                                 else if (at_ENTITY<C>(cur()))
     1207                                else if (at_ENTITY<B::Base>(cur()))
    11571208                                        Parse_Entitydecl();
    1158                                 else if (at_NOTATION<C>(cur()))
     1209                                else if (at_NOTATION<B::Base>(cur()))
    11591210                                        Parse_Notationdecl();
    11601211                                else {
     
    11651216                                Syntax_Error(NT_markupdecl);
    11661217                }
    1167                 else if (AtChar<C,']'>(cur())){
     1218                else if (AtChar<B::Base,']'>(cur())){
    11681219                        break;
    11691220                }
     
    11741225
    11751226
    1176 template <CodeUnit_Base C>
    1177 inline void ParsingEngine<C>::Parse_PEReference (){
     1227template <class B>
     1228inline void ParsingEngine<B>::Parse_PEReference (){
    11781229
    11791230        Advance(1); /* Skip "%". */
    11801231        int nameID = Parse_Name();
    1181         if (AtChar<C,';'>(cur())) {
     1232        if (AtChar<B::Base,';'>(cur())) {
    11821233                Advance(1);
    11831234                PEReference_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     
    12101261
    12111262
    1212 template <CodeUnit_Base C>
    1213 inline void ParsingEngine<C>::Parse_Elementdecl (){
     1263template <class B>
     1264inline void ParsingEngine<B>::Parse_Elementdecl (){
    12141265
    12151266        Advance(7); /* Skip "<!ELEMENT". */
     
    12221273        ContentModel * cm;
    12231274        /* Start parsing "contentspec"*/
    1224         if (at_EMPTY<C>(cur())) {
     1275        if (at_EMPTY<B::Base>(cur())) {
    12251276        Advance(5);
    12261277        cm = new CM_Empty();
    12271278        model_info->ContentModelData[nameID] = cm;
    12281279        }
    1229     else if (at_ANY<C>(cur())) {
     1280    else if (at_ANY<B::Base>(cur())) {
    12301281        Advance(3);
    12311282        cm = new CM_Any();
     
    12331284    }
    12341285    else {
    1235         if (AtChar<C,'('>(cur()))
     1286        if (AtChar<B::Base,'('>(cur()))
    12361287                        Advance(1);
    12371288                ScanTo(NonWS);
    1238                 if (at_PCDATA<C>(cur())){
     1289                if (at_PCDATA<B::Base>(cur())){
    12391290                        cm = Parse_RemainingMixed();
    12401291                        model_info->ContentModelData[nameID] = cm;
     
    12641315    ScanTo(NonWS);   
    12651316
    1266         if (AtChar<C,'>'>(cur())) {
     1317        if (AtChar<B::Base,'>'>(cur())) {
    12671318                Advance(1);
    12681319        }
     
    12701321                Syntax_Error(NT_elementdecl);
    12711322}
    1272 template <CodeUnit_Base C>
    1273 inline ContentModel * ParsingEngine<C>::Parse_RemainingMixed (){
     1323template <class B>
     1324inline ContentModel * ParsingEngine<B>::Parse_RemainingMixed (){
    12741325        CM_Mixed * r = new CM_Mixed();
    12751326        Advance(7);  /* Skip "#PCDATA". */
    12761327   
    1277     if (AtChar<C,')'>(cur())){
    1278         if (AtChar<C,'*'>(cur())) {
     1328    if (AtChar<B::Base,')'>(cur())){
     1329        if (AtChar<B::Base,'*'>(cur())) {
    12791330                Advance(2);
    12801331                }
     
    12861337        ScanTo(NonWS);
    12871338        int k = 0;
    1288         while (AtChar<C,'|'>(cur())){
     1339        while (AtChar<B::Base,'|'>(cur())){
    12891340                        Advance(1);
    12901341                        ScanTo(NonWS);
     
    12931344                        ScanTo(NonWS);
    12941345                }
    1295                 if (at_Para_star<C>(cur())) Advance(2);
     1346                if (at_Para_star<B::Base>(cur())) Advance(2);
    12961347                else {
    12971348                        Syntax_Error(NT_Mixed);
     
    13031354
    13041355
    1305 template <CodeUnit_Base C>
    1306 inline Content_RE * ParsingEngine<C>::Parse_RemainingChildren (){
     1356template <class B>
     1357inline Content_RE * ParsingEngine<B>::Parse_RemainingChildren (){
    13071358        Content_RE * c1 = Parse_Cp();
    13081359        Content_RE * r = c1;
    13091360        ScanTo(NonWS);
    1310         if(AtChar<C,'|'>(cur())){
     1361        if(AtChar<B::Base,'|'>(cur())){
    13111362                CRE_Choice * rslt = new CRE_Choice;
    13121363                rslt->subCMs.push_back(c1);
     
    13151366                rslt->subCMs.push_back(Parse_Cp());
    13161367                ScanTo(NonWS);
    1317                 while(!AtChar<C,')'>(cur())){
    1318                         if(AtChar<C,'|'>(cur()))
     1368                while(!AtChar<B::Base,')'>(cur())){
     1369                        if(AtChar<B::Base,'|'>(cur()))
    13191370                                Advance(1);
    13201371                        else
     
    13281379                r = rslt;
    13291380        }
    1330         else if(AtChar<C,','>(cur())){
     1381        else if(AtChar<B::Base,','>(cur())){
    13311382                CRE_Seq * rslt = new CRE_Seq;
    13321383                rslt->subCMs.push_back(c1);
     
    13351386                rslt->subCMs.push_back(Parse_Cp());
    13361387                ScanTo(NonWS);
    1337                 while(!AtChar<C,')'>(cur())){
    1338                         if(AtChar<C,','>(cur()))
     1388                while(!AtChar<B::Base,')'>(cur())){
     1389                        if(AtChar<B::Base,','>(cur()))
    13391390                                Advance(1);
    13401391                        else
     
    13481399                r = rslt;
    13491400        }       
    1350         else if(AtChar<C,')'>(cur())){
     1401        else if(AtChar<B::Base,')'>(cur())){
    13511402                Advance(1);
    13521403        }
     
    13541405                Syntax_Error(NT_children);
    13551406               
    1356         if (AtChar<C,'?'>(cur())) {
     1407        if (AtChar<B::Base,'?'>(cur())) {
    13571408                Advance(1);
    13581409                r = new CRE_Opt(r);
    13591410        }
    1360         else if (AtChar<C,'*'>(cur())) {
     1411        else if (AtChar<B::Base,'*'>(cur())) {
    13611412                Advance(1);
    13621413                r = new CRE_Star(r);
    13631414        }
    1364         else if (AtChar<C,'+'>(cur())) {
     1415        else if (AtChar<B::Base,'+'>(cur())) {
    13651416                Advance(1);
    13661417                r = new CRE_Plus(r);
     
    13701421}
    13711422
    1372 template <CodeUnit_Base C>
    1373 inline Content_RE * ParsingEngine<C>::Parse_Cp (){
    1374         if (AtChar<C,'('>(cur())){
     1423template <class B>
     1424inline Content_RE * ParsingEngine<B>::Parse_Cp (){
     1425        if (AtChar<B::Base,'('>(cur())){
    13751426                Advance(1);
    13761427                ScanTo(NonWS);
     
    13811432                CRE_Name * r = new CRE_Name(nameID);
    13821433
    1383                 if (AtChar<C,'?'>(cur())) {
     1434                if (AtChar<B::Base,'?'>(cur())) {
    13841435                        Advance(1);
    13851436                        return new CRE_Opt(r);
    13861437                }
    1387                 else if (AtChar<C,'*'>(cur())) {
     1438                else if (AtChar<B::Base,'*'>(cur())) {
    13881439                        Advance(1);
    13891440                        return new CRE_Star(r);
    13901441                }
    1391                 else if (AtChar<C,'+'>(cur())) {
     1442                else if (AtChar<B::Base,'+'>(cur())) {
    13921443                        Advance(1);
    13931444                        return new CRE_Plus(r);
     
    13971448}
    13981449
    1399 template <CodeUnit_Base C>
    1400 inline void ParsingEngine<C>::Parse_AttlistDecl (){
     1450template <class B>
     1451inline void ParsingEngine<B>::Parse_AttlistDecl (){
    14011452       
    14021453        int old_abspos;
     
    14161467        old_abspos = AbsPos();
    14171468        ScanTo(NonWS);
    1418         while(!AtChar<C,'>'>(cur())) {
     1469        while(!AtChar<B::Base,'>'>(cur())) {
    14191470                if(old_abspos == AbsPos())
    14201471                Syntax_Error(NT_AttlistDecl);
     
    14271478        this_info->globalATT_id = attID;
    14281479        requireWS();
    1429         if (at_CDATA<C>(cur())){
     1480        if (at_CDATA<B::Base>(cur())){
    14301481                Advance(5);
    14311482                this_info->attType = CDATA_att;
    14321483        }
    1433         else if(at_ID<C>(cur())){
     1484        else if(at_ID<B::Base>(cur())){
    14341485                Advance(2);
    14351486                this_info->attType = ID_att;
    14361487        }
    14371488        /* Make sure to check IDREFS before IDREF*/
    1438         else if(at_IDREFS<C>(cur())){
     1489        else if(at_IDREFS<B::Base>(cur())){
    14391490                Advance(6);
    14401491                this_info->attType = IDREFS_att;
    14411492        }
    1442         else if(at_IDREF<C>(cur())){
     1493        else if(at_IDREF<B::Base>(cur())){
    14431494                Advance(5);
    14441495                this_info->attType = IDREF_att;
    14451496        }
    1446         else if(at_ENTITY<C>(cur())){
     1497        else if(at_ENTITY<B::Base>(cur())){
    14471498                Advance(6);
    14481499                this_info->attType = ENTITY_att;
    14491500        }
    1450         else if(at_ENTITIES<C>(cur())){
     1501        else if(at_ENTITIES<B::Base>(cur())){
    14511502                Advance(8);
    14521503                this_info->attType = ENTITIES_att;
    14531504        }
    14541505        /* Make sure to check NMTOKENS before NMTOKEN*/
    1455         else if(at_NMTOKENS<C>(cur())){
     1506        else if(at_NMTOKENS<B::Base>(cur())){
    14561507                Advance(8);
    14571508                this_info->attType = NMTOKENS_att;
    14581509        }
    1459         else if(at_NMTOKEN<C>(cur())){
     1510        else if(at_NMTOKEN<B::Base>(cur())){
    14601511                Advance(7);
    14611512                this_info->attType = NMTOKEN_att;
    14621513        }
    1463         else if(at_NOTATION<C>(cur())){ /* NotationType = 'NOTATION' S Enumeration
     1514        else if(at_NOTATION<B::Base>(cur())){ /* NotationType = 'NOTATION' S Enumeration
    14641515                                                                         when Nmtoken = Name */
    14651516                Advance(8);
     
    14681519                this_info->attType = NOTATION_att;
    14691520        }
    1470         else if(AtChar<C,'('>(cur())){
     1521        else if(AtChar<B::Base,'('>(cur())){
    14711522                Parse_Enumeration(this_info);
    14721523                this_info->attType = enumeration_att;
     
    14841535}
    14851536
    1486 template <CodeUnit_Base C>
    1487 inline void ParsingEngine<C>::Parse_Notation (ATT_info * this_info){
    1488 
    1489         if(AtChar<C,'('>(cur()))
     1537template <class B>
     1538inline void ParsingEngine<B>::Parse_Notation (ATT_info * this_info){
     1539
     1540        if(AtChar<B::Base,'('>(cur()))
    14901541                Advance(1);
    14911542        else
     
    15001551       
    15011552        ScanTo(NonWS);
    1502         while(AtChar<C,'|'>(cur())){
     1553        while(AtChar<B::Base,'|'>(cur())){
    15031554                Advance(1);
    15041555                ScanTo(NonWS); 
     
    15101561                ScanTo(NonWS);
    15111562        }
    1512         if (AtChar<C,')'>(cur()))
     1563        if (AtChar<B::Base,')'>(cur()))
    15131564                Advance(1);
    15141565        else
     
    15161567}
    15171568
    1518 template <CodeUnit_Base C>
    1519 inline void ParsingEngine<C>::Parse_Enumeration (ATT_info * this_info){
     1569template <class B>
     1570inline void ParsingEngine<B>::Parse_Enumeration (ATT_info * this_info){
    15201571
    15211572        int enumCount=0;
    1522         if(AtChar<C,'('>(cur()))
     1573        if(AtChar<B::Base,'('>(cur()))
    15231574                Advance(1);
    15241575        else
     
    15311582       
    15321583        ScanTo(NonWS);
    1533         while(AtChar<C,'|'>(cur())){
     1584        while(AtChar<B::Base,'|'>(cur())){
    15341585                Advance(1);
    15351586                ScanTo(NonWS); 
     
    15461597                ScanTo(NonWS);
    15471598        }
    1548         if (AtChar<C,')'>(cur()))
     1599        if (AtChar<B::Base,')'>(cur()))
    15491600                Advance(1);
    15501601        else
     
    15521603}
    15531604
    1554 template <CodeUnit_Base C>
    1555 inline void ParsingEngine<C>::Parse_DefaultDecl (ATT_info * this_info){
    1556         if(at_REQUIRED<C>(cur())){
     1605template <class B>
     1606inline void ParsingEngine<B>::Parse_DefaultDecl (ATT_info * this_info){
     1607        if(at_REQUIRED<B::Base>(cur())){
    15571608                Advance(9);
    15581609                this_info->defaultKind = REQUIRED_att;
    15591610        }
    1560         else if(at_IMPLIED<C>(cur())){
     1611        else if(at_IMPLIED<B::Base>(cur())){
    15611612                Advance(8);
    15621613                this_info->defaultKind = IMPLIED_att;
    15631614        }
    15641615        else {
    1565                 if(at_FIXED<C>(cur())){
     1616                if(at_FIXED<B::Base>(cur())){
    15661617                        Advance(6);
    15671618                        requireWS();
     
    15691620                }
    15701621                else this_info->defaultKind = DEFAULT_att;
    1571                 if(AtQuote<C>(cur())){
     1622                if(AtQuote<B::Base>(cur())){
    15721623                        int quot_start = AbsPos()+1;
    15731624                        Parse_AttValue();
     
    15841635}
    15851636
    1586 template <CodeUnit_Base C>
    1587 inline void ParsingEngine<C>::Parse_Entitydecl (){
     1637template <class B>
     1638inline void ParsingEngine<B>::Parse_Entitydecl (){
    15881639       
    15891640        int name_start;
     
    15961647        requireWS();
    15971648       
    1598         if (AtChar<C,'%'>(cur())){
     1649        if (AtChar<B::Base,'%'>(cur())){
    15991650                Advance(1);
    16001651                requireWS();
     
    16131664       
    16141665                requireWS();
    1615                 if(AtQuote<C>(cur())){
     1666                if(AtQuote<B::Base>(cur())){
    16161667                Parse_PEntityValue(this_info);
    16171668                this_info->is_external = false;
     
    16391690                requireWS();
    16401691               
    1641                 if(AtQuote<C>(cur())){
     1692                if(AtQuote<B::Base>(cur())){
    16421693                Parse_GEntityValue(this_info);                 
    16431694                this_info->is_external = false;
     
    16491700                        old_abspos = AbsPos();
    16501701                        ScanTo(NonWS);
    1651                 if(at_NDATA<C>(cur())){
     1702                if(at_NDATA<B::Base>(cur())){
    16521703                        if(old_abspos == AbsPos())
    16531704                                Syntax_Error(NT_EntityDecl);
     
    16641715        }
    16651716        ScanTo(NonWS);
    1666         if (AtChar<C,'>'>(cur())){
     1717        if (AtChar<B::Base,'>'>(cur())){
    16671718                Advance(1);
    16681719        }
     
    16711722}
    16721723
    1673 template <CodeUnit_Base C>
    1674 inline void ParsingEngine<C>::Parse_Notationdecl (){
     1724template <class B>
     1725inline void ParsingEngine<B>::Parse_Notationdecl (){
    16751726
    16761727        int old_abspos;
     
    16911742    Parse_ExternalID(this_info->systemLiteral, this_info->pubidLiteral);
    16921743        ScanTo(NonWS);
    1693         if (AtChar<C,'>'>(cur())) {
     1744        if (AtChar<B::Base,'>'>(cur())) {
    16941745                Advance(1);
    16951746        }
     
    16981749}
    16991750
    1700 template <CodeUnit_Base C>
    1701 inline void ParsingEngine<C>::requireWS(){
     1751template <class B>
     1752inline void ParsingEngine<B>::requireWS(){
    17021753       
    17031754    int old_abspos = AbsPos(); 
     
    17071758}
    17081759
    1709 template <CodeUnit_Base C>
    1710 inline void ParsingEngine<C>::Parse_AttValue(){
     1760template <class B>
     1761inline void ParsingEngine<B>::Parse_AttValue(){
    17111762       
    17121763        int     quoteCh = cur()[0];
     
    17151766        ScanTo(Quote);                 
    17161767        while (cur()[0] != quoteCh){
    1717                 if (at_CharRef_Start<C>(cur())){
     1768                if (at_CharRef_Start<B::Base>(cur())){
    17181769                        Parse_CharRef();
    17191770                        ScanTo(Quote);
    17201771                }
    1721                 else if (AtChar<C,'&'>(cur())){
     1772                else if (AtChar<B::Base,'&'>(cur())){
    17221773                        Parse_EntityRef();
    17231774                        ScanTo(Quote);
    17241775                }
    1725                 else if (AtQuote<C>(cur())) {
     1776                else if (AtQuote<B::Base>(cur())) {
    17261777                        Advance(1);
    17271778                        ScanTo(Quote);
    17281779                }
    1729                 else /* if (AtChar<C,'<'>(cur())) */
     1780                else /* if (AtChar<B::Base,'<'>(cur())) */
    17301781                        WF_Error(wfErr_CleanAttrVals);
    17311782        }
     
    17331784}
    17341785
    1735 template <CodeUnit_Base C>
    1736 inline void ParsingEngine<C>::Parse_GEntityValue(GEntity_info * this_info){
     1786template <class B>
     1787inline void ParsingEngine<B>::Parse_GEntityValue(GEntity_info * this_info){
    17371788       
    17381789        int     quoteCh = cur()[0];
     
    17441795
    17451796        while (cur()[0] != quoteCh){
    1746                 if (at_CharRef_Start<C>(cur())){
     1797                if (at_CharRef_Start<B::Base>(cur())){
    17471798                        strcat (replText,Replace_CharRef());
    17481799                        quot_start = AbsPos();
    17491800                        ScanTo(Quote);
    17501801                }
    1751                 else if (AtChar<C,'&'>(cur())){
     1802                else if (AtChar<B::Base,'&'>(cur())){
    17521803                        strcat (replText,Replace_EntityRef(this_info->is_simple));
    17531804                        quot_start = AbsPos();
    17541805                        ScanTo(Quote);
    17551806                }
    1756                 else if (AtQuote<C>(cur())) {
     1807                else if (AtQuote<B::Base>(cur())) {
    17571808                        quot_start = AbsPos();
    17581809                        Advance(1);
     
    17721823}
    17731824
    1774 template <CodeUnit_Base C>
    1775 inline char * ParsingEngine<C>::Replace_EntityRef(bool& is_simple){
     1825template <class B>
     1826inline char * ParsingEngine<B>::Replace_EntityRef(bool& is_simple){
    17761827        Advance(1);
    17771828        int nameID = Parse_Name();
    1778         if (AtChar<C,';'>(cur()))
     1829        if (AtChar<B::Base,';'>(cur()))
    17791830                Advance(1);
    17801831        else
     
    17911842}
    17921843
    1793 template <CodeUnit_Base C>
    1794 inline void ParsingEngine<C>::Parse_PEntityValue(PEntity_info * this_info){
    1795 }
    1796 
    1797 template <CodeUnit_Base C>
    1798 inline char * ParsingEngine<C>::Replace_CharRef(){
     1844template <class B>
     1845inline void ParsingEngine<B>::Parse_PEntityValue(PEntity_info * this_info){
     1846}
     1847
     1848template <class B>
     1849inline char * ParsingEngine<B>::Replace_CharRef(){
    17991850        Advance(1);
    18001851        int nameID = Parse_Name();
     
    18071858}
    18081859
    1809 template <CodeUnit_Base C>
    1810 inline void ParsingEngine<C>::Parse_Prolog(){
     1860template <class B>
     1861inline void ParsingEngine<B>::Parse_Prolog(){
    18111862        ScanTo(NonWS);
    18121863        int old_pos = AbsPos();
    1813         while (!at_DOCTYPE_start<C>(cur())) {
    1814                 if (at_Comment_Start<C>(cur()))
     1864        while (!at_DOCTYPE_start<B::Base>(cur())) {
     1865                if (at_Comment_Start<B::Base>(cur()))
    18151866                        Parse_Comment();
    1816                 else if (at_PI_Start<C>(cur()))
     1867                else if (at_PI_Start<B::Base>(cur()))
    18171868                                Parse_PI();
    18181869                else{
     
    18241875        Parse_DocType();
    18251876        ScanTo(NonWS);
    1826         while(at_Comment_Start<C>(cur()) || at_PI_Start<C>(cur()) ){
    1827                 if (at_Comment_Start<C>(cur()))
     1877        while(at_Comment_Start<B::Base>(cur()) || at_PI_Start<B::Base>(cur()) ){
     1878                if (at_Comment_Start<B::Base>(cur()))
    18281879                        Parse_Comment();
    18291880                else
     
    18341885}
    18351886
    1836 template <CodeUnit_Base C>
    1837 inline void ParsingEngine<C>::Parse_ExtSubsetDecl() {
     1887template <class B>
     1888inline void ParsingEngine<B>::Parse_ExtSubsetDecl() {
    18381889        int start_pos=AbsPos();
    18391890        while(!at_EOF()){
    1840                 if(at_condSect_start<C>(cur())){               
     1891                if(at_condSect_start<B::Base>(cur())){         
    18411892                        Advance(3);
    18421893                        ScanTo(NonWS);
    1843                         if (at_INCLUDE<C>(cur())){
     1894                        if (at_INCLUDE<B::Base>(cur())){
    18441895                                Advance(7);
    18451896                                ScanTo(NonWS);
    1846                                 if(AtChar<C,'['>(cur())){
     1897                                if(AtChar<B::Base,'['>(cur())){
    18471898                                        Advance(1);
    18481899                                        Parse_ExtSubsetDecl();
    1849                                         if(at_CDATA_End<C>(cur()))
     1900                                        if(at_CDATA_End<B::Base>(cur()))
    18501901                                                Advance(3);
    18511902                                        else Syntax_Error(NT_includeSect);
     
    18531904                                else Syntax_Error(NT_includeSect);
    18541905                        }
    1855                         else if (at_IGNORE<C>(cur())){
     1906                        else if (at_IGNORE<B::Base>(cur())){
    18561907                                Advance(6);
    18571908                                ScanTo(NonWS);         
    1858                                 if(AtChar<C,'['>(cur())){
     1909                                if(AtChar<B::Base,'['>(cur())){
    18591910                                        int section_depth=1;
    18601911                                        Advance(1);
    18611912                                        while(!at_EOF()){
    18621913                                                ScanToMarkupStart();
    1863                                                 if(at_condSect_start<C>(cur())){
     1914                                                if(at_condSect_start<B::Base>(cur())){
    18641915                                                        Advance(3);
    18651916                                                        section_depth++;
    18661917                                                }
    1867                                                 else if(at_CDATA_End<C>(cur())){
     1918                                                else if(at_CDATA_End<B::Base>(cur())){
    18681919                                                        Advance(3);
    18691920                                                        section_depth--;
     
    18791930                        else Syntax_Error(NT_conditionalSect);
    18801931                }
    1881                 else if (AtChar<C,'%'>(cur()))
     1932                else if (AtChar<B::Base,'%'>(cur()))
    18821933                        Parse_PEReference();   
    1883                 else if (at_PI_Start<C>(cur())) {
     1934                else if (at_PI_Start<B::Base>(cur())) {
    18841935                        Parse_PI();
    18851936                }
    1886                 else if (at_Comment_Start<C>(cur())) {
     1937                else if (at_Comment_Start<B::Base>(cur())) {
    18871938                        Parse_Comment();
    18881939                }
    1889                 else if (AtChar<C,'<'>(cur())){
     1940                else if (AtChar<B::Base,'<'>(cur())){
    18901941                        Advance(1);
    18911942
    1892                         if(AtChar<C,'!'>(cur())){
     1943                        if(AtChar<B::Base,'!'>(cur())){
    18931944                                Advance(1);
    1894                                 if(at_ELEMENT<C>(cur()))
     1945                                if(at_ELEMENT<B::Base>(cur()))
    18951946                                        Parse_Elementdecl();
    1896                                 else if(at_ATTLIST<C>(cur()))
     1947                                else if(at_ATTLIST<B::Base>(cur()))
    18971948                                        Parse_AttlistDecl();
    1898                                 else if(at_ENTITY<C>(cur()))
     1949                                else if(at_ENTITY<B::Base>(cur()))
    18991950                                        Parse_Entitydecl();
    1900                                 else if(at_NOTATION<C>(cur()))
     1951                                else if(at_NOTATION<B::Base>(cur()))
    19011952                                        Parse_Notationdecl();                                   
    19021953                                else{
     
    19151966
    19161967/* Parse a valid start or empty element tag. */
    1917 template <CodeUnit_Base C>
    1918 inline int ParsingEngine<C>::Parse_ValidStartTag (bool& is_emptyStartTag){
     1968template <class B>
     1969inline int ParsingEngine<B>::Parse_ValidStartTag (bool& is_emptyStartTag){
    19191970        int att_name_start;
    19201971        int att_val_start;
     
    19311982        /* The following test optimizes the most common case of a
    19321983        start tag with no attributes.  */
    1933         if (AtChar<C,'>'>(cur())) {
     1984        if (AtChar<B::Base,'>'>(cur())) {
    19341985                Advance(1);
    19351986                StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     
    19371988        else {
    19381989                ScanTo(NonWS);
    1939                 if (AtChar<C,'>'>(cur())) {
     1990                if (AtChar<B::Base,'>'>(cur())) {
    19401991                        Advance(1);
    19411992                        StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    19421993                }
    1943                 else if (at_EmptyElementDelim<C>(cur())) {
     1994                else if (at_EmptyElementDelim<B::Base>(cur())) {
    19441995                        Advance(2);
    19451996                        is_emptyStartTag = true;
     
    19652016                        In many cases, the very first test handles 100% of actual
    19662017                        attribute-value pairs encountered. */
    1967                         if (at_EqualsQuote<C>(cur())) Advance(1);
     2018                        if (at_EqualsQuote<B::Base>(cur())) Advance(1);
    19682019                        else {
    19692020                                ScanTo(NonWS);
    1970                                 if (!AtChar<C,'='>(cur())) {
     2021                                if (!AtChar<B::Base,'='>(cur())) {
    19712022                                        Syntax_Error(NT_STag);
    19722023                                        break;
     
    19742025                                Advance(1);
    19752026                                ScanTo(NonWS);
    1976                                 if (!AtQuote<C>(cur())) {
     2027                                if (!AtQuote<B::Base>(cur())) {
    19772028                                        Syntax_Error(NT_STag);
    19782029                                        break;
     
    19822033                        Parse_AttValue();
    19832034                        att_val_end = AbsPos()-1;
    1984                         if (at_xmlns<C>(cur()+att_name_start-AbsPos())) {
     2035                        if (at_xmlns<B::Base>(cur()+att_name_start-AbsPos())) {
    19852036                                Namespace_action(GetCodeUnitPtr(att_name_start), att_name_end - att_name_start,
    19862037                                                 GetCodeUnitPtr(att_val_start), att_val_end - att_val_start);
     
    19912042                        }
    19922043                        /* Now check for end or repeat. Avoid whitespace scan if possible.*/
    1993                         if (AtChar<C,'>'>(cur())) {
     2044                        if (AtChar<B::Base,'>'>(cur())) {
    19942045                                Advance(1);
    19952046                                StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    19962047                                break;
    19972048                        }
    1998                         else if (at_EmptyElementDelim<C>(cur())) {
     2049                        else if (at_EmptyElementDelim<B::Base>(cur())) {
    19992050                                Advance(2);
    20002051                                is_emptyStartTag = true;       
     
    20032054                        }
    20042055                        ScanTo(NonWS);
    2005                         if (AtChar<C,'>'>(cur())) {
     2056                        if (AtChar<B::Base,'>'>(cur())) {
    20062057                                Advance(1);
    20072058                                StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    20082059                                break;
    20092060                        }
    2010                         else if (at_EmptyElementDelim<C>(cur())) {
     2061                        else if (at_EmptyElementDelim<B::Base>(cur())) {
    20112062                                Advance(2);
    20122063                                is_emptyStartTag = true;
     
    20242075}
    20252076
    2026 template <CodeUnit_Base C>
    2027 inline int ParsingEngine<C>::Parse_ValidElement() {
     2077template <class B>
     2078inline int ParsingEngine<B>::Parse_ValidElement() {
    20282079        bool is_emptyStartTag = false;
    20292080        int nameID = Parse_ValidStartTag(is_emptyStartTag);
     
    20352086                case cm_Empty:
    20362087                        if (!is_emptyStartTag) {
    2037                                 if (at_EndTag_Start<C>(cur())) {
     2088                                if (at_EndTag_Start<B::Base>(cur())) {
    20382089                                        Parse_WF_EndTag(nameID);
    20392090                                }
     
    20722123}
    20732124
    2074 template <CodeUnit_Base C>
    2075 inline void ParsingEngine<C>::Parse_ValidContent(CM_RegExp * cre, int & cur_state) {
     2125template <class B>
     2126inline void ParsingEngine<B>::Parse_ValidContent(CM_RegExp * cre, int & cur_state) {
    20762127        do {
    20772128                ScanTo(NonWS);
    20782129                /* If non-null report WS  WS_action()? */
    20792130                text_or_markup_start = AbsPos();
    2080                 if (at_EndTag_Start<C>(cur())) {
     2131                if (at_EndTag_Start<B::Base>(cur())) {
    20812132                        break;
    20822133                }
    2083                 else if (at_ElementTag_Start<C>(cur())) {
     2134                else if (at_ElementTag_Start<B::Base>(cur())) {
    20842135                        int nameID = Parse_ValidElement();
    20852136#ifdef DEBUG
     
    20912142#endif
    20922143                }
    2093                 else if (at_Comment_Start<C>(cur())) {
     2144                else if (at_Comment_Start<B::Base>(cur())) {
    20942145                        Parse_Comment();
    20952146                }
    2096                 else if (at_PI_Start<C>(cur())) {
     2147                else if (at_PI_Start<B::Base>(cur())) {
    20972148                        Parse_PI();
    20982149                }
    2099                 else if (AtChar<C,'&'>(cur())) {
     2150                else if (AtChar<B::Base,'&'>(cur())) {
    21002151                        Parse_ValidEntityRef(cre, cur_state);
    21012152#ifdef DEBUG
     
    21072158                        break;
    21082159                }
    2109                 else if (AtChar<C,'<'>(cur())) {
     2160                else if (AtChar<B::Base,'<'>(cur())) {
    21102161                        Syntax_Error(NT_markupdecl);
    21112162                }
     
    21172168
    21182169
    2119 template <CodeUnit_Base C>
    2120 inline void ParsingEngine<C>::Parse_AnyContent() {
     2170template <class B>
     2171inline void ParsingEngine<B>::Parse_AnyContent() {
    21212172        do {
    21222173                text_or_markup_start = AbsPos();
    21232174                ScanToMarkupStart(); /* '<', '&', or ']' for ']]>' test */
    2124                 if (at_ElementTag_Start<C>(cur())) {
     2175                if (at_ElementTag_Start<B::Base>(cur())) {
    21252176                        text_if_nonnull_action();
    21262177                        int nameID = Parse_ValidElement();
    21272178                }
    2128                 else if (at_EndTag_Start<C>(cur())) {
     2179                else if (at_EndTag_Start<B::Base>(cur())) {
    21292180                        text_if_nonnull_action();
    21302181                        return;
    21312182                }
    2132                 else if (at_Comment_Start<C>(cur())) {
     2183                else if (at_Comment_Start<B::Base>(cur())) {
    21332184                        text_if_nonnull_action();
    21342185                        Parse_Comment();
    21352186                }
    2136                 else if (at_CharRef_Start<C>(cur())) {
     2187                else if (at_CharRef_Start<B::Base>(cur())) {
    21372188                        text_if_nonnull_action();
    21382189                        Parse_CharRef();
    21392190                }
    2140                 else if (AtChar<C,'&'>(cur())) {
     2191                else if (AtChar<B::Base,'&'>(cur())) {
    21412192                        text_if_nonnull_action();
    21422193                        Parse_EntityRef();
    21432194                }
    2144                 else if (at_CDATA_Start<C>(cur())) {
     2195                else if (at_CDATA_Start<B::Base>(cur())) {
    21452196                        text_if_nonnull_action();
    21462197                        Parse_CDATA();
    21472198                }
    2148                 else if (at_PI_Start<C>(cur())) {
     2199                else if (at_PI_Start<B::Base>(cur())) {
    21492200                        text_if_nonnull_action();
    21502201                        Parse_PI();
    21512202                }
    2152                 else if (at_CDATA_End<C>(cur())) {
     2203                else if (at_CDATA_End<B::Base>(cur())) {
    21532204                        text_if_nonnull_action();
    21542205                        Advance(3);
     
    21592210                        return;
    21602211                }
    2161                 else if (AtChar<C,'<'>(cur())) {
     2212                else if (AtChar<B::Base,'<'>(cur())) {
    21622213                        Syntax_Error(NT_markupdecl);
    21632214                }
     
    21682219        } while (1);
    21692220}
    2170 template <CodeUnit_Base C>
    2171 inline void ParsingEngine<C>::Parse_MixedContent(symbol_set_t elems) {
     2221template <class B>
     2222inline void ParsingEngine<B>::Parse_MixedContent(symbol_set_t elems) {
    21722223        do {
    21732224                text_or_markup_start = AbsPos();
    21742225                ScanToMarkupStart(); /* '<', '&', or ']' for ']]>' test */
    2175 /*              if (AtChar<C,'<'>(cur())) {
    2176                         text_if_nonnull_action();
    2177                         Parse_Markup<C>();
     2226/*              if (AtChar<B::Base,'<'>(cur())) {
     2227                        text_if_nonnull_action();
     2228                        Parse_Markup<B>();
    21782229                }*/
    2179                 if (at_ElementTag_Start<C>(cur())) {
     2230                if (at_ElementTag_Start<B::Base>(cur())) {
    21802231                        text_if_nonnull_action();
    21812232                        int nameID = Parse_ValidElement();
     
    21842235                        }
    21852236                }
    2186                 else if (at_EndTag_Start<C>(cur())) {
     2237                else if (at_EndTag_Start<B::Base>(cur())) {
    21872238                        text_if_nonnull_action();
    21882239                        return;
    21892240                }
    2190                 else if (at_Comment_Start<C>(cur())) {
     2241                else if (at_Comment_Start<B::Base>(cur())) {
    21912242                        text_if_nonnull_action();
    21922243                        Parse_Comment();
    21932244                }
    2194                 else if (at_CharRef_Start<C>(cur())) {
     2245                else if (at_CharRef_Start<B::Base>(cur())) {
    21952246                        text_if_nonnull_action();
    21962247                        Parse_CharRef();
    21972248                }
    2198                 else if (AtChar<C,'&'>(cur())) {
     2249                else if (AtChar<B::Base,'&'>(cur())) {
    21992250                        text_if_nonnull_action();
    22002251                        Parse_EntityRef();
    22012252                }
    2202                 else if (at_CDATA_Start<C>(cur())) {
     2253                else if (at_CDATA_Start<B::Base>(cur())) {
    22032254                        text_if_nonnull_action();
    22042255                        Parse_CDATA();
    22052256                }
    2206                 else if (at_PI_Start<C>(cur())) {
     2257                else if (at_PI_Start<B::Base>(cur())) {
    22072258                        text_if_nonnull_action();
    22082259                        Parse_PI();
    22092260                }
    2210                 else if (at_CDATA_End<C>(cur())) {
     2261                else if (at_CDATA_End<B::Base>(cur())) {
    22112262                        text_if_nonnull_action();
    22122263                        Advance(3);
     
    22172268                        return;
    22182269                }
    2219                 else if (AtChar<C,'<'>(cur())) {
     2270                else if (AtChar<B::Base,'<'>(cur())) {
    22202271                        Syntax_Error(NT_markupdecl);
    22212272                }
     
    22272278}
    22282279
    2229 template <CodeUnit_Base C>
    2230 inline int ParsingEngine<C>::Parse_Name() {
     2280
     2281template <class B>
     2282inline int ParsingEngine<B>::Parse_Name() {
    22312283        int name_pos = AbsPos();
    22322284        ScanTo(NameFollow);
    22332285        int lgth = AbsPos()-name_pos;
    2234         if (entity_Info->version == XML_1_1){
    2235                 return model_info->symbol_table->UTF8_Lookup_or_Insert_XML11_Name((char *)GetCodeUnitPtr(name_pos),lgth);
    2236         }
    2237         else
    2238                 return model_info->symbol_table->UTF8_Lookup_or_Insert_XML10_Name((char *)GetCodeUnitPtr(name_pos),lgth);
    2239 }
    2240 
    2241 
    2242 template <CodeUnit_Base C>
    2243 inline void ParsingEngine<C>::Parse_DocumentContent() {
     2286        int nameID = model_info->symbol_table->ASCII_Lookup_or_Insert(&((char *) x8data)[buffer_rel_pos-lgth], lgth);
     2287        if (nameID != 0) return nameID;
     2288        else {
     2289                int u8_lgth = byteplex->UTF8_Length(name_pos, lgth);
     2290                char * u8_ptr = model_info->symbol_table->ReserveSymbolSpace(u8_lgth);
     2291                byteplex->to_UTF8(name_pos, lgth, u8_ptr);
     2292                return model_info->symbol_table->LookupOrInsertReserved();
     2293        }
     2294}
     2295
     2296template <>
     2297inline int ParsingEngine< X8_Buffer<EBCDIC> >::Parse_Name() {
     2298        int name_pos = AbsPos();
     2299        ScanTo(NameFollow);
     2300        int lgth = AbsPos()-name_pos;
     2301//      int nameID = local_EBCDIC_table->Lookup_or_Insert(GetCodeUnitPtr(name_pos), lgth);
     2302//      if (nameID != 0) return nameID;
     2303//      else {
     2304                int u8_lgth = byteplex->UTF8_Length(name_pos, lgth);
     2305                char * u8_ptr = model_info->symbol_table->ReserveSymbolSpace(u8_lgth);
     2306                byteplex->to_UTF8(name_pos, lgth, u8_ptr);
     2307                return model_info->symbol_table->LookupOrInsertReserved();
     2308//      }
     2309}
     2310
     2311template <>
     2312inline int ParsingEngine<UTF8_Buffer>::Parse_Name() {
     2313        int name_pos = AbsPos();
     2314        ScanTo(NameFollow);
     2315        int lgth = AbsPos()-name_pos;
     2316        return model_info->symbol_table->UTF8_Lookup_or_Insert(&((char *)x8data)[buffer_rel_pos-lgth], lgth);
     2317}
     2318
     2319
     2320template <class B>
     2321inline void ParsingEngine<B>::Parse_DocumentContent() {
    22442322#if (VALIDATION_MODE == ON)
    22452323        int cur_state = 0;
     
    22522330        Parse_WF_Element();
    22532331        ScanTo(NonWS);
    2254         while(at_Comment_Start<C>(cur()) || at_PI_Start<C>(cur()) ){
    2255                 if (at_Comment_Start<C>(cur()))
     2332        while(at_Comment_Start<B::Base>(cur()) || at_PI_Start<B::Base>(cur()) ){
     2333                if (at_Comment_Start<B::Base>(cur()))
    22562334                        Parse_Comment();
    22572335                else
Note: See TracChangeset for help on using the changeset viewer.