Changeset 160 for trunk/src


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

Restructured character set architecture; StringPool? in symbol table.

Location:
trunk/src
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/byteplex.c

    r151 r160  
    325325        return b;
    326326}
     327
     328template <>
     329int X8_Buffer<EBCDIC>::UTF8_Length(int name_pos, int lgth){
     330        int u8_lgth = 0;
     331        for (int i = name_pos; i < name_pos+lgth; i++) {
     332                u8_lgth += /*TEMPORARY - NEED TO USE A TABLE FOR LOOKUP*/ 2;
     333        }
     334        return u8_lgth;
     335}
     336
     337template <>
     338int X8_Buffer<ASCII>::UTF8_Length(int name_pos, int lgth){
     339        int u8_lgth = 0;
     340        for (int i = name_pos; i < name_pos+lgth; i++) {
     341                if (((unsigned char *)x8data)[i] < 0x80) u8_lgth += 1;
     342                else u8_lgth += /*TEMPORARY - NEED TO USE A TABLE FOR LOOKUP*/ 1;
     343        }
     344        return u8_lgth;
     345}
     346
     347int UTF8_Buffer::UTF8_Length(int name_pos, int lgth){
     348        return lgth;
     349}
     350
     351int U16_Buffer::UTF8_Length(int name_pos, int lgth){
     352        int u8_lgth = 0;
     353        for (int i = name_pos; i < name_pos+lgth; i++) {
     354                if (((unsigned char *)x8data)[i] < 0x80) u8_lgth += 1;
     355                else if(((unsigned char *)x16hi)[i]<=0x7 || (((unsigned char *)x16hi)[i] >= 0xD8 &&((unsigned char *)x16hi)[i]<= 0xDF))
     356                        u8_lgth += 2;
     357                else
     358                        u8_lgth += 3;
     359        }
     360        return u8_lgth;
     361}
     362
     363int U32_Buffer::UTF8_Length(int name_pos, int lgth){
     364        int u8_lgth = 0;
     365        unsigned char * u32hl = (unsigned char *) x32hl;
     366        unsigned char * u32lh = (unsigned char *) x32lh;
     367        for (int i = name_pos; i < name_pos+lgth; i++) {
     368                if (((unsigned char *)x8data)[i] < 0x80)  {
     369                        u8_lgth += 1;
     370                }
     371                else if(u32hl[i] > 0)
     372                        u8_lgth += 4;
     373                else if(u32lh[i]<=0x7)
     374                        u8_lgth += 2;
     375                else
     376                        u8_lgth += 3;
     377        }
     378        return u8_lgth;
     379}
     380
     381template <>
     382void X8_Buffer<ASCII>::to_UTF8(int name_pos, int lgth, char * u8_ptr){
     383        memcpy(u8_ptr, &((char *)x8data)[name_pos], lgth);
     384        u8_ptr[lgth] = '\0';
     385//      u8_ptr = copy_name(&((char *)x8data)[name_pos], lgth);
     386}
     387
     388template <>
     389void X8_Buffer<EBCDIC>::to_UTF8(int name_pos, int lgth, char * u8_ptr){
     390       
     391}
     392void U16_Buffer::to_UTF8(int name_pos, int lgth, char * u8_ptr){
     393        int u8_lgth = 0;
     394        unsigned char * u16h = (unsigned char *) x16hi;
     395        unsigned char * u16l = (unsigned char *) x16lo;
     396        for (int i = name_pos; i < name_pos+lgth; i++) {
     397                if (((unsigned char *)x8data)[i] < 0x80) {
     398                        u8_ptr[u8_lgth] = ((unsigned char *)x8data)[i];
     399                        u8_lgth += 1;
     400                }
     401                else if (u16h[i]<=0x7) {
     402                        u8_ptr[u8_lgth] = 0xC0 + (u16h[i] << 2) + (u16l[i] >> 6);
     403                        u8_ptr[u8_lgth+1] = 0x80 + (u16l[i] & 0x3F);
     404                        u8_lgth += 2;
     405                }
     406                else if ((u16h[i] >= 0xD8) && (u16h[i]<= 0xDB)){
     407                        char temp =  ((u16h[i] & 0x03) << 2) + (u16l[i] >> 6) + 1;
     408                        u8_ptr[u8_lgth] = 0xF0 + (temp >> 2);
     409                        u8_ptr[u8_lgth+1] = 0x80 + ((temp & 0x03) << 4) + ((u16l[i] & 0x3F) >> 2);
     410                        u8_ptr[u8_lgth+2] = 0x80 + ((u16l[i] & 0x03) << 4) + ((u16h[i+1] & 0x03) << 2) + (u16l[i+1] >> 6);
     411                        u8_ptr[u8_lgth+3] = 0x80 + (u16l[i+1] & 0x3F);
     412                        i++;
     413                        u8_lgth += 4;
     414                }
     415                else{
     416                        u8_ptr[u8_lgth] = 0xE0 + (u16h[i] >> 4);
     417                        u8_ptr[u8_lgth+1] = 0x80 + ((u16h[i] & 0x0F) << 2) + (u16l[i] >> 6);
     418                        u8_ptr[u8_lgth+2] = 0x80 + (u16l[i] & 0x3F);
     419                        u8_lgth += 3;
     420                }
     421        }
     422        u8_ptr[u8_lgth] = '\0';
     423}
     424
     425
     426
     427void U32_Buffer::to_UTF8(int name_pos, int lgth, char * u8_ptr){
     428        int u8_lgth = 0;
     429        unsigned char * u32hl = (unsigned char *) x32hl;
     430        unsigned char * u32lh = (unsigned char *) x32lh;
     431        unsigned char * u32ll = (unsigned char *) x32ll;
     432        for (int i = name_pos; i < name_pos+lgth; i++) {
     433                if (((unsigned char *)x8data)[i] < 0x80)  {
     434                        u8_ptr[u8_lgth] = ((unsigned char *)x8data)[i];
     435                        u8_lgth += 1;
     436                }
     437                else if(u32hl[i] > 0) {
     438                        u8_ptr[u8_lgth] = 0xF0 + (u32hl[i] >> 2);
     439                        u8_ptr[u8_lgth+1] = 0x80 + ((u32hl[i] & 0x03) << 4) + (u32lh[i] >> 4);
     440                        u8_ptr[u8_lgth+2] = 0x80 + ((u32lh[i] & 0x0F) << 2) + (u32ll[i] >> 6);
     441                        u8_ptr[u8_lgth+3] = 0x80 + (u32ll[i] & 0x3F);           
     442                        u8_lgth += 4;
     443                }
     444                else if(u32lh[i]<=0x7) {
     445                        u8_ptr[u8_lgth] = 0xC0 + (u32lh[i] << 2) + (u32ll[i] >> 6);
     446                        u8_ptr[u8_lgth+1] = 0x80 + (u32ll[i] & 0x3F);
     447                        u8_lgth += 2;
     448                }
     449                else {
     450                        u8_ptr[u8_lgth] = 0xE0 + (u32lh[i] >> 4);
     451                        u8_ptr[u8_lgth+1] = 0x80 + ((u32lh[i] & 0x0F) << 2) + (u32ll[i] >> 6);
     452                        u8_ptr[u8_lgth+2] = 0x80 + (u32ll[i] & 0x3F);
     453                        u8_lgth += 3;
     454                }
     455        }
     456        u8_ptr[u8_lgth] = '\0';
     457}
     458
     459
  • trunk/src/byteplex.h

    r143 r160  
    8080        virtual void InitializeBuffer(unsigned char * src, int lgth) = 0;
    8181        virtual void AdvanceInputBuffer(int advance_amt) = 0;
    82 
     82        virtual int UTF8_Length(int name_pos, int lgth)=0;
     83        virtual void to_UTF8(int name_pos, int lgth, char * u8_ptr)=0;
    8384        /* Source code unit buffer. */
    8485        BytePack * src_buffer;
     
    109110class X8_Buffer : public Byteplex {
    110111public:
     112        static const CodeUnit_Base Base = C;
     113        static const CodeUnit_Size Size = SingleByte;
    111114        X8_Buffer();
    112115        ~X8_Buffer();
     
    116119        void AdvanceInputBuffer(int advance_amt);
    117120        void InitializeBuffer(unsigned char * src, int lgth);
     121        int UTF8_Length(int name_pos, int lgth);
     122        void to_UTF8(int name_pos, int lgth, char * u8_ptr);
     123};
     124
     125class UTF8_Buffer : public Byteplex {
     126public:
     127        static const CodeUnit_Base Base = ASCII;
     128        static const CodeUnit_Size Size = SingleByte;
     129        UTF8_Buffer();
     130        ~UTF8_Buffer();
     131       
     132        void DoByteplex();
     133        void PreparePseudoASCII_Stream();
     134        void AdvanceInputBuffer(int advance_amt);
     135        void InitializeBuffer(unsigned char * src, int lgth);
     136        int UTF8_Length(int name_pos, int lgth);
     137        void to_UTF8(int name_pos, int lgth, char * u8_ptr);
    118138};
    119139
     
    127147class U16_Buffer : public Byteplex {
    128148public:
     149        static const CodeUnit_Base Base = ASCII;
     150        static const CodeUnit_Size Size = DoubleByte;
    129151        U16_Buffer();
    130152        ~U16_Buffer();
     
    133155        void AdvanceInputBuffer(int advance_amt);
    134156        void InitializeBuffer(unsigned char * src, int lgth);
     157        int UTF8_Length(int name_pos, int lgth);
     158        void to_UTF8(int name_pos, int lgth, char * u8_ptr);
    135159protected:
    136160        BytePack * x16hi;
     
    158182class U32_Buffer : public Byteplex {
    159183public:
     184        static const CodeUnit_Base Base = ASCII;
     185        static const CodeUnit_Size Size = QuadByte;
    160186        U32_Buffer();
    161187        ~U32_Buffer();
     
    164190        void AdvanceInputBuffer(int advance_amt);
    165191        void InitializeBuffer(unsigned char * src, int lgth);
     192        int UTF8_Length(int name_pos, int lgth);
     193        void to_UTF8(int name_pos, int lgth, char * u8_ptr);
    166194protected:
    167195        BytePack * x32hh;
     
    195223};
    196224
     225
     226inline char * copy_name (char * s, int lgth){           
     227        char * d = new char[lgth+1];
     228        memcpy(d, s,lgth);
     229        d[lgth] = '\0';
     230        return d;
     231}
     232
    197233#endif
     234
     235
  • 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
  • trunk/src/engine.h

    r156 r160  
    5959};
    6060
    61 template <CodeUnit_Base C>
     61template <class B>
    6262class ParsingEngine : public Parser_Interface {
    6363public:
     
    6969
    7070        vector<int> LastAttOccurrence;
    71         XML_Decl_Parser<C> * decl_parser;
     71        XML_Decl_Parser<B::Base> * decl_parser;
    7272       
    7373        int text_or_markup_start;
     
    7777        int BufferRelPos() const;
    7878        unsigned char * cur() const;
     79        unsigned char * GetCodeUnitPtr(int pos);
    7980
    8081        bool at_EOF () const;
     
    131132        void Parse_WF_Content();
    132133        int Parse_WF_StartTag(bool& is_empty);
    133         void Parse_WF_EndTag(int nameID);       
     134        void Parse_WF_EndTag(int nameID);
    134135
    135136        void Parse_ValidEntityRef(CM_RegExp * cre, int & cur_state);
     
    141142        int Parse_ValidStartTag(bool& is_empty);
    142143       
    143         int Parse_Name();
     144        int Parse_Name(); 
    144145       
    145146        /*Parsing routine for external entities*/
  • trunk/src/symtab.c

    r151 r160  
    11#include "symtab.h"
    22
    3 inline char * copy_name (char * s, int lgth){           
    4         char * d = new char[lgth+1];
    5         memcpy(d, s,lgth);
    6         d[lgth] = '\0';
    7         return d;
    8 }
     3const int INIT_STRINGPOOL_SIZE = 4096;
    94
    105inline bool bit_test(unsigned char * bit_Map, int codepoint) {
     
    121116        else if (bytes[0] <= 0xEF) {
    122117                int codepoint = ((bytes[0] & 0x0F) << 12)| ((bytes[1] & 0x3F) << 6) | (bytes[2] & 0x3F);
    123                 return is_XML10_NameStrt_codepoint(codepoint) ? 3 : 0;
     118                return is_XML10_NameChar_codepoint(codepoint) ? 3 : 0;
    124119        }
    125120        else return 0;
     
    172167                valid_bytes = XML_10_UTF8_NameChar_bytes((unsigned char *) &protoname[pos]);
    173168                pos += valid_bytes;
     169                 
    174170        }
    175171        /* Success requires that every byte sequence processed be valid
    176172           and that the total lgth processed be exactly that provided on
    177173           input. */
     174         
    178175        return (valid_bytes > 0) & (pos == lgth);
    179176}
     
    193190
    194191int Symbol_Table::Insert_Name(char * name, int lgth) {
    195         char * s = copy_name(name,lgth);
     192//      char * s = copy_name(name,lgth);
     193        char * s = pool->Insert(name,lgth);
    196194        UTF8NameMap[s]=++(globalNameCount);
    197195        Name_Data name_data;
     
    202200}
    203201
    204 int Symbol_Table::UTF8_Lookup_or_Insert_XML10_Name(char * name, int lgth) {
     202
     203inline bool Verify_ASCII(char * name_ptr, int name_lgth) {
     204        /* To verify that a name is ASCII, ensure that the high bit
     205           of each byte is 0.  A SIMD compare can verify this for
     206           up to sizeof(BytePack) bytes.  For less than 16 bytes,
     207           first shift out bytes beyond the name length.  For more
     208           than 16 bytes, form the logical "or" of the successive byte
     209           packs together so that a high 1 bit in any byte is preserved
     210           for the final SIMD test. */
     211        BytePack b = sisd_load_unaligned((BytePack *) name_ptr);
     212        if (name_lgth <= sizeof(BytePack)) {
     213                /* Clear bytes beyond the length of the name. */
     214                b = sisd_sfl(b, sisd_from_int(8 * (sizeof(BytePack) - name_lgth)));
     215        }
     216        else {
     217                int offset = name_lgth % sizeof(BytePack);
     218                for (int i = offset; i < name_lgth; i += sizeof(BytePack)) {
     219                        b = simd_or(sisd_load_unaligned((BytePack *) &name_ptr[i]),b);
     220                }
     221        }
     222        return !simd_any_sign_bit_8(b);
     223}
     224
     225
     226/* ASCII_LookupOrInsert determines the nameID for any ASCII name
     227from the global name table, inserting the name and allocating
     228a nameID if necessary.  If the name is non-ASCII, 0 is returned. */
     229
     230inline int Symbol_Table::ASCII_Lookup_or_Insert(char * name_ptr, int name_lgth) {
     231        if (Verify_ASCII(name_ptr, name_lgth)) {
     232                return UTF8_Lookup_or_Insert(name_ptr, name_lgth);
     233        }
     234        return 0;
     235}
     236
     237
     238
     239int Symbol_Table::UTF8_Lookup_or_Insert(char * name, int lgth) {
    205240        char delim = name[lgth];
    206241        name[lgth] = '\0';
    207242        int nameID = UTF8NameMap[name];
    208243        name[lgth] = delim;     
    209         if (nameID == 0){
     244       
     245        if(nameID == 0){
    210246        #if (not defined(OMISSION)) or (OMISSION != NAME_VALIDATION)
    211                 if (!is_XML10_UTF8_Name(name,lgth)) {
     247                if (!is_XML11_UTF8_Name(name,lgth)) {
    212248                        ShowSyntaxError(NT_Name);
    213249                        exit(-1);
    214250                }
    215251        #endif
    216                 char * s = copy_name(name,lgth);
     252//              char * s = copy_name(name,lgth);
     253                char * s = pool->Insert(name,lgth);
    217254                UTF8NameMap[s]=++(globalNameCount);
    218255                nameID = globalNameCount;
     
    226263}
    227264
    228 int Symbol_Table::UTF8_Lookup_or_Insert_XML11_Name(char * name, int lgth) {
    229         char * s = copy_name(name,lgth);
    230         int nameID = UTF8NameMap[s];
     265//char * Symbol_Table::Get_UTF8_name(int nameID) {
     266//      return  UTF8NameTable[nameID];
     267//}
     268
     269char * Symbol_Table::Get_UTF8_name(int nameID) {
     270        return  UTF8NameTable[nameID].name_string;
     271}
     272
     273int Symbol_Table::Get_UTF8_lgth(int nameID) {
     274        return  UTF8NameTable[nameID].lgth;
     275}
     276
     277char * Symbol_Table::ReserveSymbolSpace(int u8_lgth) {
     278        reserved = new char[u8_lgth+1];
     279        reserved_lgth = u8_lgth;
     280        return reserved;
     281}
     282
     283int Symbol_Table::LookupOrInsertReserved(){             
     284        int nameID = UTF8NameMap[reserved];
    231285        if(nameID == 0){
    232286        #if (not defined(OMISSION)) or (OMISSION != NAME_VALIDATION)
    233                 if (!is_XML11_UTF8_Name(name,lgth))  {
     287                if (!is_XML10_UTF8_Name(reserved,reserved_lgth))  {
    234288                        ShowSyntaxError(NT_Name);
    235289                        exit(-1);
    236290                }
    237291        #endif
    238                 UTF8NameMap[s]=++(globalNameCount);
     292                UTF8NameMap[reserved]=++(globalNameCount);
    239293                nameID = globalNameCount;
    240294                Name_Data name_data;
    241                 name_data.name_string = s;
    242                 name_data.lgth = lgth;
     295                name_data.name_string = reserved;
     296                name_data.lgth = reserved_lgth;
    243297                UTF8NameTable.push_back(name_data);
    244298//              UTF8NameTable.push_back(s);
    245299        }
     300        else {
     301                delete [] reserved;
     302        }
    246303        return nameID;
    247 }
    248 
    249 //char * Symbol_Table::Get_UTF8_name(int nameID) {
    250 //      return  UTF8NameTable[nameID];
    251 //}
    252 
    253 char * Symbol_Table::Get_UTF8_name(int nameID) {
    254         return  UTF8NameTable[nameID].name_string;
    255 }
    256 
    257 int Symbol_Table::Get_UTF8_lgth(int nameID) {
    258         return  UTF8NameTable[nameID].lgth;
    259304}
    260305
     
    274319//              UTF8NameTable.push_back(predefined[i]);
    275320        }
    276 }
    277 
    278 
     321        pool = new StringPool;
     322}
     323
     324
     325StringPool::StringPool() {
     326       buffer_capacity = INIT_STRINGPOOL_SIZE;
     327       buffer_space_used = 0;
     328       pool_buffers.push_back(new char [buffer_capacity]);
     329}
     330
     331StringPool::~StringPool() {
     332       vector<char * >::iterator i;
     333       for (i = pool_buffers.begin(); i != pool_buffers.end(); i++) {
     334               delete [] *i;
     335       }
     336}
     337
     338char * StringPool::Insert(char * s, int lgth) {
     339       while (lgth + buffer_space_used >= buffer_capacity) {
     340               buffer_capacity *= 2;
     341               pool_buffers.push_back(new char [buffer_capacity]);
     342               buffer_space_used = 0;
     343       }
     344       char * insertion_ptr = &pool_buffers.back()[buffer_space_used];
     345       memcpy(insertion_ptr, s, lgth);
     346       insertion_ptr[lgth] = '\0';
     347       buffer_space_used += lgth + 1;
     348       return insertion_ptr;
     349}
     350
     351
     352
  • trunk/src/symtab.h

    r141 r160  
    2727char * predefined[] = {"lt", "gt", "amp", "quot", "apos"};
    2828
    29 class Symbol_Table{
     29/*  A StringPool object provides managed storage for strings.
     30   It can grow to accommodate as many strings as desired, subject
     31   to space availability.  It is implemented as a vector of
     32   pool buffers.  Initially a single buffer of size initial_capacity
     33   is allocated.  Strings are inserted into this area until insufficient
     34   space remains, at which point a new buffer is allocated for
     35   subsequent insertions.  */
     36
     37class StringPool {
     38public:
     39       StringPool();
     40       ~StringPool();
     41       char * Insert(char * s, int lgth);
     42private:
     43       int buffer_capacity;
     44       int buffer_space_used;
     45       vector<char *> pool_buffers;
     46};
     47
     48class Symbol_Table {
    3049public:
    3150        Symbol_Table();
     51
     52
    3253        int Insert_Name(char * name, int lgth);
    33         int UTF8_Lookup_or_Insert_XML10_Name(char * name, int lgth);
    34         int UTF8_Lookup_or_Insert_XML11_Name(char * name, int lgth);
     54        int ASCII_Lookup_or_Insert(char * name, int lgth);     
     55        int UTF8_Lookup_or_Insert(char * name, int lgth);
     56
    3557        char * Get_UTF8_name(int nameID);
    3658        int Get_UTF8_lgth(int nameID);
     59       
     60        char * ReserveSymbolSpace(int u8_lgth);
     61        int LookupOrInsertReserved();
     62       
    3763private:
    3864        hash_map<const char *, int, hash<const char *>, eqstr > UTF8NameMap;
     
    4066//      vector<char *> UTF8NameTable;
    4167        vector<Name_Data> UTF8NameTable;
     68        char * reserved;
     69        int reserved_lgth;
     70        StringPool * pool;
    4271};
    4372
    4473
     74
    4575#endif
  • trunk/src/xmldecl.c

    r111 r160  
    7575//
    7676template <CodeUnit_Base C>
    77 int XML_Decl_Parser<C>::ReadXMLInfo(Entity_Info *e) {
     77void XML_Decl_Parser<C>::ReadXMLInfo(Entity_Info *e) {
    7878        e->version = no_XML_version_value;
    7979        e->has_encoding_decl = false;
     
    8282        // It is possible that there is no XML declaration.
    8383        if (!at_XmlDecl_start<C>(cur())) {
    84                 return AbsPos();
     84                e->content_start = AbsPos();
     85                return;
    8586        }
    8687        // Otherwise, the XML declaration exists and must have
     
    9899        else DeclarationError(AbsPos());
    99100        Advance(5);
    100         if (at_PI_End<C>(cur())) return AbsPos()+2;
     101        if (at_PI_End<C>(cur())) {
     102                e->content_start = AbsPos()+2;
     103                return;
     104        }
    101105        if (!at_WhiteSpace<XML_1_0, ASCII>(cur())) DeclarationError(AbsPos());
    102106        Scan_WS();
     
    118122                else DeclarationError(AbsPos());
    119123                Advance(1);
    120                 if (at_PI_End<C>(cur())) return AbsPos()+2;
     124                if (at_PI_End<C>(cur())) {
     125                        e->content_start = AbsPos()+2;
     126                        return;
     127                }
    121128                if (!at_WhiteSpace<XML_1_0, ASCII>(cur())) DeclarationError(AbsPos());
    122129                Scan_WS();
     
    134141        }
    135142        if (!at_PI_End<C>(cur())) DeclarationError(AbsPos());
    136         return AbsPos()+2;
     143        e->content_start = AbsPos()+2;
    137144}
    138145
     
    142149// processing.
    143150template <CodeUnit_Base C>
    144 int XML_Decl_Parser<C>::ReadTextDeclaration(Entity_Info *e) {
     151void XML_Decl_Parser<C>::ReadTextDeclaration(Entity_Info *e) {
    145152        e->version = no_XML_version_value;
    146153        e->has_encoding_decl = false;
     
    149156        // It is possible that there is no XML declaration.
    150157        if (!at_XmlDecl_start<C>(cur())) {
    151                 return AbsPos();
     158                e->content_start = AbsPos();
     159                return;
    152160        }
    153161        // Otherwise, the text declaration exists and may have
     
    188196        Scan_WS();
    189197        if (!at_PI_End<C>(cur())) DeclarationError(AbsPos());
    190         return AbsPos()+2;
    191 }
    192 
     198        e->content_start = AbsPos()+2;
     199}
     200
  • trunk/src/xmldecl.h

    r100 r160  
    1818        ~XML_Decl_Parser ();
    1919       
    20         int ReadXMLInfo(Entity_Info * e);
    21         int ReadTextDeclaration(Entity_Info * e);
     20        void ReadXMLInfo(Entity_Info * e);
     21        void ReadTextDeclaration(Entity_Info * e);
    2222       
    2323
  • trunk/src/xmlmodel.c

    r141 r160  
    3434        globalElementCount = 0;
    3535        globalAttributeCount = 0;
    36         symbol_table = new Symbol_Table();
    37         SimpleEntity("lt", "<");
    38         SimpleEntity("gt", ">");
    39         SimpleEntity("amp", "&");
    40         SimpleEntity("quot", "\"");
    41         SimpleEntity("apos", "'");     
     36//      symbol_table = new Symbol_Table();
     37//      SimpleEntity("lt", "<");
     38//      SimpleEntity("gt", ">");
     39//      SimpleEntity("amp", "&");
     40//      SimpleEntity("quot", "\"");
     41//      SimpleEntity("apos", "'");     
    4242}
    4343
  • trunk/src/xmlmodel.h

    r137 r160  
    151151        unsigned char * encoding;
    152152        XML_standalone standalone;
     153        int content_start;  /* position after BOM and XML/text decl.*/
    153154       
    154155private:
Note: See TracChangeset for help on using the changeset viewer.