Changeset 29 for tags


Ignore:
Timestamp:
Jan 26, 2008, 7:23:35 AM (11 years ago)
Author:
cameron
Message:

Parameterizing ParsingEngine? for ASCII/EBCDIC

Location:
tags/parabix-0.39
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • tags/parabix-0.39/markup_stats.cxx

    r19 r29  
    189189  Entity_Declaration_Info xml_info;
    190190
    191   ParsingEngine parser = ParsingEngine(filename);
     191  ParsingEngine<ASCII> parser = ParsingEngine<ASCII>(filename);
    192192  parser.InitLexer();
    193193
  • tags/parabix-0.39/src/engine.c

    r27 r29  
    11/*  engine.c - Parabix XML parsing engine.
    2     Copyright (c) 2007, Robert D. Cameron.
     2    Copyright (c) 2007, 2008, Robert D. Cameron.
    33    Licensed to the public under the Open Software License 3.0.
    44    Licensed to International Characters, Inc., under the Academic
     
    1919#include <string.h>
    2020
    21 ParsingEngine::ParsingEngine (char * filename) {
     21
     22template <CodeUnit_Base C>
     23ParsingEngine<C>::ParsingEngine (char * filename) {
    2224#ifdef BUFFER_PROFILING
    2325        bitstream_timer = init_BOM_timer(BUFFER_BLOCKS * BLOCKSIZE);
     
    4345}
    4446
    45 void ParsingEngine::InitLexer() {
     47
     48template <CodeUnit_Base C>
     49void ParsingEngine<C>::InitLexer() {
    4650  unsigned char * sentinel = (unsigned char *) "<![--?>]]>/'>\"><!";
    4751  if (xml_buf->PrepareBytes(0, 4) < 4) {
     
    7680
    7781
    78 inline void ParsingEngine::AdvanceToNewBasePosn(int advance_amt) {
     82
     83template <CodeUnit_Base C>
     84inline void ParsingEngine<C>::AdvanceToNewBasePosn(int advance_amt) {
    7985  buffer_base_pos += advance_amt;
    8086  buffer_rel_pos = 0;
    8187}
    8288
    83 inline unsigned char * ParsingEngine::cur() const {
     89template <CodeUnit_Base C>
     90inline unsigned char * ParsingEngine<C>::cur() const {
    8491  return &((unsigned char *) buf.x8data)[buffer_rel_pos];
    8592}
    8693
    87 
    88 inline int ParsingEngine::AbsPos() const {
     94template <CodeUnit_Base C>
     95inline int ParsingEngine<C>::AbsPos() const {
    8996  return buffer_base_pos + buffer_rel_pos;
    9097}
    9198
    9299
    93 inline int ParsingEngine::BufferRelPos() const {
     100template <CodeUnit_Base C>
     101inline int ParsingEngine<C>::BufferRelPos() const {
    94102  return buffer_rel_pos;
    95103}
    96104
    97105
    98 inline bool ParsingEngine::at_EOF () const {
     106template <CodeUnit_Base C>
     107inline bool ParsingEngine<C>::at_EOF() const {
    99108  return (buffer_rel_pos >= avail_code_units) &&
    100109         (avail_code_units < BUFFER_BLOCKS * BLOCKSIZE + LOOKAHEAD_POSITIONS);
    101110}
    102111
    103 inline void ParsingEngine::Advance(int n) {
     112template <CodeUnit_Base C>
     113inline void ParsingEngine<C>::Advance(int n) {
    104114  buffer_rel_pos += n;
    105115#ifndef OMIT_BITBUFFER_LIMIT_TEST_IN_ADVANCE
    106116  if (buffer_rel_pos >= BUFFER_BLOCKS * BLOCKSIZE) {
    107     FinalizeBuffer_action();
    108117#ifdef BUFFER_PROFILING
    109118    end_BOM_interval(scanner_timer);
     
    115124}
    116125
    117 inline void ParsingEngine::ASCII_ScanTo(int item) {
     126template <CodeUnit_Base C>
     127inline void ParsingEngine<C>::ASCII_ScanTo(int item) {
    118128#ifdef DEBUG_BYTESCAN
    119129  int p1 = AbsPos();
     
    135145}
    136146
     147
    137148#ifndef OPTIMIZE_SHORT_SCAN
    138 #ifdef BYTESPACE_SCAN
    139 inline void ParsingEngine::ScanTo(int item) {
    140   ASCII_ScanTo(item);
    141 }
    142 #endif
    143 
    144 #ifndef BYTESPACE_SCAN
    145 inline void ParsingEngine::ScanTo(int item) {
     149template <CodeUnit_Base C>
     150inline void ParsingEngine<C>::ScanTo(int item) {
    146151  buffer_rel_pos = bitstream_scan(buf.item_stream[item],
    147152                                      buffer_rel_pos);
    148153  while (buffer_rel_pos >= BUFFER_BLOCKS * BLOCKSIZE) {
    149     FinalizeBuffer_action();
    150154#ifdef BUFFER_PROFILING
    151155    end_BOM_interval(scanner_timer);
     
    157161}
    158162#endif
    159 #endif
    160163
    161164#ifdef OPTIMIZE_SHORT_SCAN
    162 inline void ParsingEngine::ScanTo(int item) {
     165template <CodeUnit_Base C>
     166inline void ParsingEngine<C>::ScanTo(int item) {
    163167  SIMD_type * stream = buf.item_stream[item];
    164168  unsigned long * bitstream_ptr = (unsigned long *) (((intptr_t) stream) + buffer_rel_pos/8);
     
    172176    while (buffer_rel_pos >= BUFFER_BLOCKS * BLOCKSIZE) {
    173177      buffer_rel_pos = BUFFER_BLOCKS * BLOCKSIZE;
    174       FinalizeBuffer_action();
    175178#ifdef BUFFER_PROFILING
    176179      end_BOM_interval(scanner_timer);
     
    184187#endif
    185188
    186 
    187189/* Parse a markup item beginning '<' */
    188 inline void ParsingEngine::Parse_Markup () {
     190template <CodeUnit_Base C>
     191inline void ParsingEngine<C>::Parse_Markup() {
    189192        int markup_start = AbsPos();
    190         if (at_ElementTag_Start<ASCII>(cur())) {
     193        if (at_ElementTag_Start<C>(cur())) {
    191194                Parse_StartTag();
    192195        }
    193         else if (at_EndTag_Start<ASCII>(cur())) {
     196        else if (at_EndTag_Start<C>(cur())) {
    194197                Parse_EndTag();
    195198        }
    196         else if (at_Comment_Start<ASCII>(cur())) {
     199        else if (at_Comment_Start<C>(cur())) {
    197200                Parse_Comment();
    198201        }
    199         else if (at_CDATA_Start<ASCII>(cur())) {
     202        else if (at_CDATA_Start<C>(cur())) {
    200203                Parse_CDATA();
    201204        }
    202         else if (at_PI_Start<ASCII>(cur())) {
     205        else if (at_PI_Start<C>(cur())) {
    203206                Parse_PI();
    204207        }
     
    210213
    211214/* Parse a comment beginning "<!--" */
    212 inline void ParsingEngine::Parse_Comment () {
     215template <CodeUnit_Base C>
     216inline void ParsingEngine<C>::Parse_Comment() {
    213217        int markup_start = AbsPos();
    214218        Advance(4); /* Skip "<!--". */
    215219        ScanTo(Hyphen);
    216         while (!at_DoubleHyphen<ASCII>(cur())) {
     220        while (!at_DoubleHyphen<C>(cur())) {
    217221                Advance(2); /* Skip hyphen-nonhyphen pair */
    218222                ScanTo(Hyphen);
    219223        }
    220         if (at_Comment_End<ASCII>(cur())) {
     224        if (at_Comment_End<C>(cur())) {
    221225                Advance(3); /* Skip "-->". */
    222226                Comment_action(markup_start, AbsPos());
     
    229233
    230234/* Parse an end tag beginning "</" */
    231 inline void ParsingEngine::Parse_EndTag () {
     235template <CodeUnit_Base C>
     236inline void ParsingEngine<C>::Parse_EndTag() {
    232237        int markup_start = AbsPos();
    233238#ifndef OMIT_ADVANCE_PRIOR_TO_EXCLUSIVE_SCAN
     
    235240#endif
    236241        ScanTo(NameFollow);
    237         if (AtChar<ASCII,'>'>(cur())) {
     242        if (AtChar<C,'>'>(cur())) {
    238243                Advance(1);
    239244                EndTag_action(markup_start, AbsPos());
     
    241246        else {
    242247                ScanTo(NonWS);
    243                 if (AtChar<ASCII,'>'>(cur())) {
     248                if (AtChar<C,'>'>(cur())) {
    244249                        Advance(1);
    245250                        EndTag_action(markup_start, AbsPos());
     
    250255
    251256/* Parse a CDATA section beginning "<![CDATA". */
    252 inline void ParsingEngine::Parse_CDATA () {
     257template <CodeUnit_Base C>
     258inline void ParsingEngine<C>::Parse_CDATA() {
    253259        int markup_start = AbsPos();
    254260        Advance(8); /* Skip "<![CDATA". */
    255         if (!AtChar<ASCII,'['>(cur())) {
     261        if (!AtChar<C,'['>(cur())) {
    256262                Error_action(markup_start, AbsPos());
    257263        }
    258264        else {
    259265                ScanTo(CD_End_check);
    260                 while (!at_CDATA_End<ASCII>(cur())) {
     266                while (!at_CDATA_End<C>(cur())) {
    261267                        Advance(1);
    262268                        ScanTo(CD_End_check);
     
    267273}
    268274
    269 inline void ParsingEngine::Parse_Reference () {
     275template <CodeUnit_Base C>
     276inline void ParsingEngine<C>::Parse_Reference() {
    270277        int markup_start = AbsPos();
    271278        /* Advance(1);  // skip "&" */
    272279        ScanTo(NameFollow);  /* Name delimiter */
    273         if (!AtChar<ASCII,';'>(cur())) {
     280        if (!AtChar<C,';'>(cur())) {
    274281                Error_action(markup_start, AbsPos());
    275282        }
     
    280287}
    281288
    282 inline void ParsingEngine::Parse_PI () {
     289template <CodeUnit_Base C>
     290inline void ParsingEngine<C>::Parse_PI () {
    283291        int markup_start = AbsPos();
    284292        Advance(2); /* Skip "<?". */
    285293        int target_start = AbsPos();
    286294        // Check for illegal [Xx][Mm][Ll] target.
    287         if (at_XxMmLll_WS<ASCII>(cur())) {
     295        if (at_XxMmLll_WS<C>(cur())) {
    288296                Advance(4);
    289297                Error_action(markup_start, AbsPos());
     
    293301        PI_Target_action(target_start, AbsPos());
    294302        ScanTo(QMark);
    295         while (!at_PI_End<ASCII>(cur())) {
     303        while (!at_PI_End<C>(cur())) {
    296304                Advance(1);
    297305                ScanTo(QMark);
     
    302310 
    303311/* Parse a start or empty element tag. */
    304 inline void ParsingEngine::Parse_StartTag () {
     312template <CodeUnit_Base C>
     313inline void ParsingEngine<C>::Parse_StartTag () {
    305314        int markup_start = AbsPos();
    306315        int att_name_start;
     
    312321        /* The following test optimizes the most common case of a
    313322        start tag with no attributes.  */
    314         if (AtChar<ASCII,'>'>(cur())) {
     323        if (AtChar<C,'>'>(cur())) {
    315324                Advance(1);
    316325                StartTag_action(markup_start, AbsPos());
     
    318327        else {
    319328                ScanTo(NonWS);
    320                 if (AtChar<ASCII,'>'>(cur())) {
     329                if (AtChar<C,'>'>(cur())) {
    321330                        Advance(1);
    322331                        StartTag_action(markup_start, AbsPos());
    323332                }
    324                 else if (at_EmptyElementDelim<ASCII>(cur())) {
     333                else if (at_EmptyElementDelim<C>(cur())) {
    325334                        Advance(2);
    326335                        EmptyElement_action(markup_start, AbsPos());
     
    335344                        In many cases, the very first test handles 100% of actual
    336345                        attribute-value pairs encountered. */
    337                         if (at_EqualsDQuote<ASCII>(cur())) {
     346                        if (at_EqualsDQuote<C>(cur())) {
    338347                                Advance(2);
    339348                                att_val_start = AbsPos();
    340349                                Quote_stream = DQuote;
    341350                        }
    342                         else if (at_EqualsSQuote<ASCII>(cur())) {
     351                        else if (at_EqualsSQuote<C>(cur())) {
    343352                                Advance(2);
    344353                                att_val_start = AbsPos();
     
    347356                        else {
    348357                                ScanTo(NonWS);
    349                                 if (!AtChar<ASCII,'='>(cur())) {
     358                                if (!AtChar<C,'='>(cur())) {
    350359                                        Error_action(markup_start, AbsPos());
    351360                                        break;
     
    353362                                ScanTo(NonWS);
    354363                                att_val_start = AbsPos()+1;
    355                                 if (AtChar<ASCII,'"'>(cur())) {
     364                                if (AtChar<C,'"'>(cur())) {
    356365                                        Advance(1);
    357366                                        Quote_stream = DQuote;
    358367                                }
    359                                 else if (AtChar<ASCII,'\''>(cur())) {
     368                                else if (AtChar<C,'\''>(cur())) {
    360369                                        Advance(1);
    361370                                        Quote_stream = SQuote;
     
    367376                        }
    368377                        ScanTo(Quote_stream);
    369                         while (AtChar<ASCII,'&'>(cur())) {
     378                        while (AtChar<C,'&'>(cur())) {
    370379                                Parse_Reference();
    371380                                ScanTo(Quote_stream);
    372381                        }
    373                         if (AtChar<ASCII,'<'>(cur())) {
     382                        if (AtChar<C,'<'>(cur())) {
    374383                                Error_action(markup_start, AbsPos());
    375384                                break;
     
    377386                        att_val_end = AbsPos();
    378387                        Advance(1);
    379                         if (at_xmlns<ASCII>(cur())) {
     388                        if (at_xmlns<C>(cur())) {
    380389                                Namespace_action(att_name_start, att_name_end,
    381390                                                 att_val_start, att_val_end);
     
    386395                        }
    387396                        /* Now check for end or repeat. Avoid whitespace scan if possible.*/
    388                         if (AtChar<ASCII,'>'>(cur())) {
     397                        if (AtChar<C,'>'>(cur())) {
    389398                                Advance(1);
    390399                                StartTag_action(markup_start, AbsPos());
    391400                                break;
    392401                        }
    393                         else if (at_EmptyElementDelim<ASCII>(cur())) {
     402                        else if (at_EmptyElementDelim<C>(cur())) {
    394403                                Advance(2);
    395404                                EmptyElement_action(markup_start, AbsPos());
     
    397406                        }
    398407                        ScanTo(NonWS);
    399                         if (AtChar<ASCII,'>'>(cur())) {
     408                        if (AtChar<C,'>'>(cur())) {
    400409                                Advance(1);
    401410                                StartTag_action(markup_start, AbsPos());
    402411                                break;
    403412                        }
    404                         else if (at_EmptyElementDelim<ASCII>(cur())) {
     413                        else if (at_EmptyElementDelim<C>(cur())) {
    405414                                Advance(2);
    406415                                EmptyElement_action(markup_start, AbsPos());
     
    417426
    418427
    419 inline void ParsingEngine::ParseContent () {
    420 
     428template <CodeUnit_Base C>
     429inline void ParsingEngine<C>::ParseContent () {
    421430        int text_start = AbsPos();
    422431        do {
    423432                ScanTo(MarkupStart); /* '<', '&', or ']' for ']]>' test */
    424 /*              if (AtChar<ASCII,'<'>(cur())) {
    425                         if (AbsPos() > text_start) Text_action(text_start, AbsPos());
    426                         Parse_Markup();
     433/*              if (AtChar<C,'<'>(cur())) {
     434                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
     435                        Parse_Markup<C>();
    427436                }*/
    428437                int markup_start = AbsPos();
    429                 if (at_ElementTag_Start<ASCII>(cur())) {
     438                if (at_ElementTag_Start<C>(cur())) {
    430439                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
    431440                        Parse_StartTag();
    432441                }
    433                 else if (at_EndTag_Start<ASCII>(cur())) {
     442                else if (at_EndTag_Start<C>(cur())) {
    434443                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
    435444                        Parse_EndTag();
    436445                }
    437                 else if (at_Comment_Start<ASCII>(cur())) {
     446                else if (at_Comment_Start<C>(cur())) {
    438447                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
    439448                        Parse_Comment();
    440449                }
    441                 else if (AtChar<ASCII,'&'>(cur())) {
     450                else if (AtChar<C,'&'>(cur())) {
    442451                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
    443452                        Parse_Reference();
    444453                }
    445                 else if (at_CDATA_Start<ASCII>(cur())) {
     454                else if (at_CDATA_Start<C>(cur())) {
    446455                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
    447456                        Parse_CDATA();
    448457                }
    449                 else if (at_PI_Start<ASCII>(cur())) {
     458                else if (at_PI_Start<C>(cur())) {
    450459                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
    451460                        Parse_PI();
    452461                }
    453                 else if (at_CDATA_End<ASCII>(cur())) {
     462                else if (at_CDATA_End<C>(cur())) {
    454463                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
    455464                        Advance(3);
     
    485494//           report error or EncName unknown.
    486495//
    487 void ParsingEngine::ReadXmlInfo(Entity_Declaration_Info& xml_info) {
     496template <CodeUnit_Base C>
     497void ParsingEngine<C>::ReadXmlInfo(Entity_Declaration_Info& xml_info) {
    488498  int BOM = lex->BOM_size(0);
    489499  xml_info.has_ByteOrderMark = BOM > 0;
     
    494504  int decl_start = AbsPos();
    495505  // It is possible that there is no XML declaration.
    496   if (!at_XmlDecl_start<ASCII>(cur())) return;
     506  if (!at_XmlDecl_start<C>(cur())) return;
    497507  // Otherwise, the XML declaration exists and must have
    498508  // at least version information.
     
    500510  Advance(6);
    501511  ASCII_ScanTo(NonWS);
    502   if (!at_version<ASCII>(cur())) {Error_action(decl_start, AbsPos()); return;}
     512  if (!at_version<C>(cur())) {Error_action(decl_start, AbsPos()); return;}
    503513  Advance(7);
    504514  ASCII_ScanTo(NonWS);
    505   if (!AtChar<ASCII,'='>(cur())) {Error_action(decl_start, AbsPos()); return;}
     515  if (!AtChar<C,'='>(cur())) {Error_action(decl_start, AbsPos()); return;}
    506516  Advance(1);
    507517  ASCII_ScanTo(NonWS);
    508   if (at_1_0<ASCII>(cur())) xml_info.version = 0;
    509   else if (at_1_1<ASCII>(cur())) xml_info.version = 1;
     518  if (at_1_0<C>(cur())) xml_info.version = 0;
     519  else if (at_1_1<C>(cur())) xml_info.version = 1;
    510520  else {Error_action(decl_start, AbsPos()); return;}
    511521  Advance(5);
    512   if (at_PI_End<ASCII>(cur())) {Advance(2); return;}
    513   if (!at_WhiteSpace<XML_1_0, ASCII>(cur())) {Error_action(decl_start, AbsPos()); return;}
    514   ASCII_ScanTo(NonWS);
    515   if (at_encoding<ASCII>(cur())) {
     522  if (at_PI_End<C>(cur())) {Advance(2); return;}
     523  if (!at_WhiteSpace<XML_1_0, C>(cur())) {Error_action(decl_start, AbsPos()); return
     524;}
     525  ASCII_ScanTo(NonWS);
     526  if (at_encoding<C>(cur())) {
    516527      xml_info.has_encoding_decl = true;
    517528      Advance(8);
    518529      ASCII_ScanTo(NonWS);
    519       if (!AtChar<ASCII,'='>(cur())) {Error_action(decl_start, AbsPos()); return;}
     530      if (!AtChar<C,'='>(cur())) {Error_action(decl_start, AbsPos()); return;}
    520531      Advance(1);
    521532      ASCII_ScanTo(NonWS);
    522533      xml_info.encoding_start_pos = AbsPos()+1;
    523       if (AtChar<ASCII,'"'>(cur())) {
     534      if (AtChar<C,'"'>(cur())) {
    524535        Advance(1);
    525536        ASCII_ScanTo(DQuote);
    526         if (!AtChar<ASCII,'"'>(cur())) {Error_action(decl_start, AbsPos()); return;}
     537        if (!AtChar<C,'"'>(cur())) {Error_action(decl_start, AbsPos()); return;}
    527538      }
    528       else if (AtChar<ASCII,'\''>(cur())) {
     539      else if (AtChar<C,'\''>(cur())) {
    529540        Advance(1);
    530541        ASCII_ScanTo(SQuote);
    531         if (!AtChar<ASCII,'\''>(cur())) {Error_action(decl_start, AbsPos()); return;}
     542        if (!AtChar<C,'\''>(cur())) {Error_action(decl_start, AbsPos()); return;}
    532543      }
    533544      else {Error_action(decl_start, AbsPos()); return;}
    534545      xml_info.encoding_end_pos = AbsPos();
    535546      Advance(1);
    536       if (at_PI_End<ASCII>(cur())) {Advance(2); return;}
    537       if (!at_WhiteSpace<XML_1_0, ASCII>(cur())) {Error_action(decl_start, AbsPos()); return;}
     547      if (at_PI_End<C>(cur())) {Advance(2); return;}
     548      if (!at_WhiteSpace<XML_1_0, C>(cur()))
     549                {Error_action(decl_start, AbsPos()); return;}
    538550      ASCII_ScanTo(NonWS);
    539551  }
    540   if (at_standalone<ASCII>(cur())) {
     552  if (at_standalone<C>(cur())) {
    541553      xml_info.has_standalone_decl = true;
    542554      Advance(10);
    543555      ASCII_ScanTo(NonWS);
    544       if (!AtChar<ASCII,'='>(cur())) {Error_action(decl_start, AbsPos()); return;}
     556      if (!AtChar<C,'='>(cur())) {Error_action(decl_start, AbsPos()); return;}
    545557      Advance(1);
    546558      ASCII_ScanTo(NonWS);
    547       if (at_yes<ASCII>(cur())) {Advance(5); xml_info.standalone = true;}
    548       else if (at_no<ASCII>(cur())) {Advance(4); xml_info.standalone = false;}
     559      if (at_yes<C>(cur())) {Advance(5); xml_info.standalone = true;}
     560      else if (at_no<C>(cur())) {Advance(4); xml_info.standalone = false;}
    549561      else {Error_action(decl_start, AbsPos()); return;}
    550562      ASCII_ScanTo(NonWS);
    551563  }
    552   if (at_PI_End<ASCII>(cur())) {Advance(2); return;}
     564  if (at_PI_End<C>(cur())) {Advance(2); return;}
    553565  else {Error_action(decl_start, AbsPos()); return;}
    554566}
     
    558570// parsed entity.  This is not really needed at present, for DTDless
    559571// processing.
    560 void ParsingEngine::ReadTextDeclaration(Entity_Declaration_Info& xml_info) {
     572template <CodeUnit_Base C>
     573void ParsingEngine<C>::ReadTextDeclaration(Entity_Declaration_Info& xml_info) {
    561574  int BOM = lex->BOM_size(0);
    562575  xml_info.has_ByteOrderMark = BOM > 0;
     
    567580  int decl_start = AbsPos();
    568581  // It is possible that there is no XML declaration.
    569   if (!at_XmlDecl_start<ASCII>(cur())) return;
     582  if (!at_XmlDecl_start<C>(cur())) return;
    570583  // Otherwise, the text declaration exists and may have
    571584  // version information.
    572585  Advance(6);
    573586  ASCII_ScanTo(NonWS);
    574   if (at_version<ASCII>(cur())) {
     587  if (at_version<C>(cur())) {
    575588    xml_info.has_version_decl = true;
    576589    Advance(7);
    577590    ASCII_ScanTo(NonWS);
    578     if (!AtChar<ASCII,'='>(cur())) {Error_action(decl_start, AbsPos()); return;}
     591    if (!AtChar<C,'='>(cur())) {Error_action(decl_start, AbsPos()); return;}
    579592    Advance(1);
    580593    ASCII_ScanTo(NonWS);
    581     if (at_1_0<ASCII>(cur())) xml_info.version = 0;
    582     else if (at_1_1<ASCII>(cur())) xml_info.version = 1;
     594    if (at_1_0<C>(cur())) xml_info.version = 0;
     595    else if (at_1_1<C>(cur())) xml_info.version = 1;
    583596    else {Error_action(decl_start, AbsPos()); return;}
    584597    Advance(5);
    585598    // Must have whitespace character before declaration.
    586     if (!at_WhiteSpace<XML_1_0, ASCII>(cur())) {Error_action(decl_start, AbsPos()); return;}
     599    if (!at_WhiteSpace<XML_1_0, C>(cur()))
     600        {Error_action(decl_start, AbsPos()); return;}
    587601    ASCII_ScanTo(NonWS);
    588602  }
    589   if (!at_encoding<ASCII>(cur())) {Error_action(decl_start, AbsPos()); return;}
     603  if (!at_encoding<C>(cur())) {Error_action(decl_start, AbsPos()); return;}
    590604  xml_info.has_encoding_decl = true;
    591605  Advance(8);
    592606  ASCII_ScanTo(NonWS);
    593   if (!AtChar<ASCII,'='>(cur())) {Error_action(decl_start, AbsPos()); return;}
     607  if (!AtChar<C,'='>(cur())) {Error_action(decl_start, AbsPos()); return;}
    594608  Advance(1);
    595609  ASCII_ScanTo(NonWS);
    596610  xml_info.encoding_start_pos = AbsPos()+1;
    597   if (AtChar<ASCII,'"'>(cur())) {
     611  if (AtChar<C,'"'>(cur())) {
    598612      Advance(1);
    599613      ASCII_ScanTo(DQuote);
    600       if (!AtChar<ASCII,'"'>(cur())) {Error_action(decl_start, AbsPos()); return;}
    601   }
    602   else if (AtChar<ASCII,'\''>(cur())) {
     614      if (!AtChar<C,'"'>(cur())) {Error_action(decl_start, AbsPos()); return;}
     615  }
     616  else if (AtChar<C,'\''>(cur())) {
    603617      Advance(1);
    604618      ASCII_ScanTo(SQuote);
    605       if (!AtChar<ASCII,'\''>(cur())) {Error_action(decl_start, AbsPos()); return;}
     619      if (!AtChar<C,'\''>(cur())) {Error_action(decl_start, AbsPos()); return;}
    606620  }
    607621  else {Error_action(decl_start, AbsPos()); return;}
     
    609623  Advance(1);
    610624  ASCII_ScanTo(NonWS);
    611   if (at_PI_End<ASCII>(cur())) {Advance(2); return;}
     625  if (at_PI_End<C>(cur())) {Advance(2); return;}
    612626  else {Error_action(decl_start, AbsPos()); return;}
    613627}
  • tags/parabix-0.39/src/engine.h

    r19 r29  
    99#define ENGINE_H
    1010
     11#include "xmlparam.h"
    1112#include "bitlex.h"
     13
    1214
    1315// Information about the character set encoding, XML version and
     
    2426};
    2527
    26 
    2728/* A ParsingEngine is the principal class for parsing XML
    2829data.  */
    2930
    30   class ParsingEngine {
     31template <CodeUnit_Base C>
     32class ParsingEngine {
    3133          public:
    3234                  ParsingEngine(char * filename);
     
    5052                  void ScanTo(int lex_item);
    5153                  void AdvanceToNewBasePosn(int advance_amt);
    52 
     54               
    5355                  /* Parsing routines. */
    5456
     
    6062                  void Parse_PI ();
    6163                  void Parse_Reference ();
    62 
     64 
    6365                  /* Co-classes */
    6466                  XML_Buffer *xml_buf;
     
    7173                 /* Parallel data streams for current buffer full of XML data. */
    7274                  ParallelStreamSet buf;
    73 
    74   };
     75};
    7576
    7677
Note: See TracChangeset for help on using the changeset viewer.