Changeset 19 for trunk/src/engine.c


Ignore:
Timestamp:
Jan 14, 2008, 11:07:46 AM (11 years ago)
Author:
cameron
Message:

Refactoring byte-space lexical recognizers => bytelex.h

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/engine.c

    r17 r19  
    99#include "engine.h"
    1010#include "xmlbuffer.h"
     11#include "bytelex.h"
    1112#include "bitlex.h"
    1213#include "charsets/ext_ascii_8.h"
     
    8081}
    8182
    82 inline unsigned char ParsingEngine::CharAt(int offset) const {
    83   return ((unsigned char *) buf.x8data)[buffer_rel_pos+offset];
    84 }
    85 
    86 inline unsigned char * ParsingEngine::x8dataPtr(int offset) const {
    87   return &((unsigned char *) buf.x8data)[buffer_rel_pos+offset];
     83inline unsigned char * ParsingEngine::cur() const {
     84  return &((unsigned char *) buf.x8data)[buffer_rel_pos];
    8885}
    8986
     
    123120#endif
    124121  switch (item) {
    125     case NonWS: while (ASCII_WS_at(0)) Advance(1); break;
    126     case MarkupStart: while(!AtChar('<') && !AtChar('&') && !at_CDATA_End()) Advance(1); break;
    127     case CD_End_check: while(!at_CDATA_End()) Advance(1); break;
    128     case Hyphen: while(!AtChar('-')) Advance(1); break;
    129     case QMark: while(!AtChar('?')) Advance(1); break;
    130     case DQuote: while(!AtChar('<') && !AtChar('&') && !AtChar('"')) Advance(1); break;
    131     case SQuote: while(!AtChar('<') && !AtChar('&') && !AtChar('\'')) Advance(1); break;
    132     case NameFollow: while(!ASCII_WS_at(0) && !AtChar(';') && !AtChar('/') && !AtChar('>')
    133                       && !AtChar('=') && !AtChar('?')) Advance(1); break;
     122    case NonWS: while (at_WhiteSpace<ASCII>(cur())) Advance(1); break;
     123    case MarkupStart: while(!AtChar<ASCII,'<'>(cur()) && !AtChar<ASCII,'&'>(cur()) && !at_CDATA_End<ASCII>(cur())) Advance(1); break;
     124    case CD_End_check: while(!at_CDATA_End<ASCII>(cur())) Advance(1); break;
     125    case Hyphen: while(!AtChar<ASCII,'-'>(cur())) Advance(1); break;
     126    case QMark: while(!AtChar<ASCII,'?'>(cur())) Advance(1); break;
     127    case DQuote: while(!AtChar<ASCII,'<'>(cur()) && !AtChar<ASCII,'&'>(cur()) && !AtChar<ASCII,'"'>(cur())) Advance(1); break;
     128    case SQuote: while(!AtChar<ASCII,'<'>(cur()) && !AtChar<ASCII,'&'>(cur()) && !AtChar<ASCII,'\''>(cur())) Advance(1); break;
     129    case NameFollow: while(!at_WhiteSpace<ASCII>(cur()) && !AtChar<ASCII,';'>(cur()) && !AtChar<ASCII,'/'>(cur()) && !AtChar<ASCII,'>'>(cur())
     130                      && !AtChar<ASCII,'='>(cur()) && !AtChar<ASCII,'?'>(cur())) Advance(1); break;
    134131  }
    135132#ifdef DEBUG_BYTESCAN
     
    188185
    189186
    190 
    191 inline bool ParsingEngine::AtChar(unsigned char c) const {
    192   return *(x8dataPtr(0)) == c;
    193 }
    194 
    195 inline bool ParsingEngine::ASCII_WS_at(int offset) const {
    196   unsigned char ch = *(x8dataPtr(offset));
    197   return (ch == 0x20) || (ch == 0x0A) || (ch == 0x0D) || (ch == 0x09);
    198 }
    199 
    200 
    201 #include "multiliteral.h"
    202 
    203 /* Now the XML recognizers. */
    204 
    205 inline bool ParsingEngine::at_EndTag_Start() const {
    206   return s2int16(x8dataPtr(0)) == c2int16<ASCII, '<', '/'>::value;
    207 }
    208 
    209 inline bool ParsingEngine::at_Comment_Start() const {
    210   return s4int32(x8dataPtr(0)) == c4int32<ASCII, '<', '!', '-', '-'>::value;
    211 }
    212 
    213 inline bool ParsingEngine::at_DoubleHyphen() const {
    214   return s2int16(x8dataPtr(0)) == c2int16<ASCII, '-', '-'>::value;
    215 }
    216 
    217 inline bool ParsingEngine::at_Comment_End() const {
    218   return s3int32(x8dataPtr(0)) == c3int32<ASCII, '-', '-', '>'>::value;
    219 }
    220 
    221 inline bool ParsingEngine::at_CDATA_Start() const {
    222   return s8int64(x8dataPtr(0)) ==
    223          c8int64<ASCII, '<', '!', '[', 'C', 'D', 'A', 'T', 'A'>::value;
    224 }
    225 
    226 inline bool ParsingEngine::at_CDATA_End() const {
    227   return s3int32(x8dataPtr(0)) == c3int32<ASCII, ']', ']', '>'>::value;
    228 }
    229 
    230 inline bool ParsingEngine::at_PI_Start() const {
    231   return s2int16(x8dataPtr(0)) == c2int16<ASCII, '<', '?'>::value;
    232 }
    233 
    234 inline bool ParsingEngine::at_PI_End() const {
    235   return s2int16(x8dataPtr(0)) == c2int16<ASCII, '?', '>'>::value;
    236 }
    237 
    238 inline bool ParsingEngine::at_EqualsDQuote() const {
    239   return s2int16(x8dataPtr(0)) == c2int16<ASCII, '=', '"'>::value;
    240 }
    241 
    242 inline bool ParsingEngine::at_EqualsSQuote() const {
    243   return s2int16(x8dataPtr(0)) == c2int16<ASCII, '=', '\''>::value;
    244 }
    245 
    246 inline bool ParsingEngine::at_xmlns() const {
    247   return s5int64(x8dataPtr(0)) == c5int64<ASCII, 'x', 'm', 'l', 'n', 's'>::value;
    248 }
    249 
    250 inline bool ParsingEngine::at_EmptyElementDelim() const {
    251   return s2int16(x8dataPtr(0)) == c2int16<ASCII, '/', '>'>::value;
    252 }
    253 
    254 inline bool ParsingEngine::at_XmlDecl_start() const {
    255   return (s5int64(x8dataPtr(0)) == c5int64<ASCII, '<', '?', 'x', 'm', 'l'>::value) &&
    256          ASCII_WS_at(5);
    257 }
    258 
    259 inline bool ParsingEngine::at_version() const {
    260   return s7int64(x8dataPtr(0)) == c7int64<ASCII, 'v', 'e', 'r', 's', 'i', 'o', 'n'>::value;
    261 }
    262 
    263 inline bool ParsingEngine::at_1_0() const {
    264   return (s5int64(x8dataPtr(0)) == c5int64<ASCII, '"', '1', '.', '0', '"'>::value) ||
    265          (s5int64(x8dataPtr(0)) == c5int64<ASCII, '\'', '1', '.', '0', '\''>::value);
    266 }
    267 
    268 inline bool ParsingEngine::at_1_1() const {
    269   return (s5int64(x8dataPtr(0)) == c5int64<ASCII, '"', '1', '.', '1', '"'>::value) ||
    270          (s5int64(x8dataPtr(0)) == c5int64<ASCII, '\'', '1', '.', '1', '\''>::value);
    271 }
    272 
    273 inline bool ParsingEngine::at_encoding() const {
    274   return s8int64(x8dataPtr(0)) == c8int64<ASCII, 'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g'>::value;
    275 }
    276 
    277 inline bool ParsingEngine::at_standalone() const {
    278   return (s8int64(x8dataPtr(0)) == c8int64<ASCII, 's', 't', 'a', 'n', 'd', 'a', 'l', 'o'>::value) &
    279          (s2int16(x8dataPtr(8)) == c2int16<ASCII, 'n', 'e'>::value);
    280 }
    281 
    282 inline bool ParsingEngine::at_yes() const {
    283   return (s5int64(x8dataPtr(0)) == c5int64<ASCII, '"', 'y', 'e', 's', '"'>::value) |
    284          (s5int64(x8dataPtr(0)) == c5int64<ASCII, '\'', 'y', 'e', 's', '\''>::value);
    285 }
    286 
    287 inline bool ParsingEngine::at_no() const {
    288   return (s4int32(x8dataPtr(0)) == c4int32<ASCII, '"', 'n', 'o', '"'>::value) |
    289          (s4int32(x8dataPtr(0)) == c4int32<ASCII, '\'', 'n', 'o', '\''>::value);
    290 }
    291 
    292 
    293 
    294 
    295 
    296 /* The at_ElementTag_Start recognizer rules out '<!', '<?', '</'
    297    combinations while returning true for '<' followed by any NameStrt
    298    character. */
    299 inline bool ParsingEngine::at_ElementTag_Start() const {
    300  
    301   return (*(x8dataPtr(0)) == '<') &
    302          ((*(x8dataPtr(1)) & 0xE1) != 0x21);
    303 }
    304 
    305187/* Parse a markup item beginning '<' */
    306188inline void ParsingEngine::Parse_Markup () {
    307189        int markup_start = AbsPos();
    308         if (at_ElementTag_Start()) {
     190        if (at_ElementTag_Start<ASCII>(cur())) {
    309191                Parse_StartTag();
    310192        }
    311         else if (at_EndTag_Start()) {
     193        else if (at_EndTag_Start<ASCII>(cur())) {
    312194                Parse_EndTag();
    313195        }
    314         else if (at_Comment_Start()) {
     196        else if (at_Comment_Start<ASCII>(cur())) {
    315197                Parse_Comment();
    316198        }
    317         else if (at_CDATA_Start()) {
     199        else if (at_CDATA_Start<ASCII>(cur())) {
    318200                Parse_CDATA();
    319201        }
    320         else if (at_PI_Start()) {
     202        else if (at_PI_Start<ASCII>(cur())) {
    321203                Parse_PI();
    322204        }
     
    332214        Advance(4); /* Skip "<!--". */
    333215        ScanTo(Hyphen);
    334         while (!at_DoubleHyphen()) {
     216        while (!at_DoubleHyphen<ASCII>(cur())) {
    335217                Advance(2); /* Skip hyphen-nonhyphen pair */
    336218                ScanTo(Hyphen);
    337219        }
    338         if (at_Comment_End()) {
     220        if (at_Comment_End<ASCII>(cur())) {
    339221                Advance(3); /* Skip "-->". */
    340222                Comment_action(markup_start, AbsPos());
     
    353235#endif
    354236        ScanTo(NameFollow);
    355         if (AtChar('>')) {
     237        if (AtChar<ASCII,'>'>(cur())) {
    356238                Advance(1);
    357239                EndTag_action(markup_start, AbsPos());
     
    359241        else {
    360242                ScanTo(NonWS);
    361                 if (AtChar('>')) {
     243                if (AtChar<ASCII,'>'>(cur())) {
    362244                        Advance(1);
    363245                        EndTag_action(markup_start, AbsPos());
     
    371253        int markup_start = AbsPos();
    372254        Advance(8); /* Skip "<![CDATA". */
    373         if (!AtChar('[')) {
     255        if (!AtChar<ASCII,'['>(cur())) {
    374256                Error_action(markup_start, AbsPos());
    375257        }
    376258        else {
    377259                ScanTo(CD_End_check);
    378                 while (!at_CDATA_End()) {
     260                while (!at_CDATA_End<ASCII>(cur())) {
    379261                        Advance(1);
    380262                        ScanTo(CD_End_check);
     
    389271        /* Advance(1);  // skip "&" */
    390272        ScanTo(NameFollow);  /* Name delimiter */
    391         if (!AtChar(';')) {
     273        if (!AtChar<ASCII,';'>(cur())) {
    392274                Error_action(markup_start, AbsPos());
    393275        }
     
    402284        Advance(2); /* Skip "<?". */
    403285        int target_start = AbsPos();
    404         ScanTo(NameFollow);  /* Name delimiter */
    405286        // Check for illegal [Xx][Mm][Ll] target.
    406         if ((AbsPos() - markup_start == 5) &&
    407             ((s3int32(x8dataPtr(-3)) | c3int32<ASCII, 0x20, 0x20, 0x20>::value)
    408                 == c3int32<ASCII, 'x', 'm', 'l'>::value)) {
     287        if (at_XxMmLll_WS<ASCII>(cur())) {
     288                Advance(4);
    409289                Error_action(markup_start, AbsPos());
    410290                return;
    411291        }
     292        ScanTo(NameFollow);  /* Name delimiter */
    412293        PI_Target_action(target_start, AbsPos());
    413294        ScanTo(QMark);
    414         while (!at_PI_End()) {
     295        while (!at_PI_End<ASCII>(cur())) {
    415296                Advance(1);
    416297                ScanTo(QMark);
     
    431312        /* The following test optimizes the most common case of a
    432313        start tag with no attributes.  */
    433         if (AtChar('>')) {
     314        if (AtChar<ASCII,'>'>(cur())) {
    434315                Advance(1);
    435316                StartTag_action(markup_start, AbsPos());
     
    437318        else {
    438319                ScanTo(NonWS);
    439                 if (AtChar('>')) {
     320                if (AtChar<ASCII,'>'>(cur())) {
    440321                        Advance(1);
    441322                        StartTag_action(markup_start, AbsPos());
    442323                }
    443                 else if (at_EmptyElementDelim()) {
     324                else if (at_EmptyElementDelim<ASCII>(cur())) {
    444325                        Advance(2);
    445326                        EmptyElement_action(markup_start, AbsPos());
     
    454335                        In many cases, the very first test handles 100% of actual
    455336                        attribute-value pairs encountered. */
    456                         if (at_EqualsDQuote()) {
     337                        if (at_EqualsDQuote<ASCII>(cur())) {
    457338                                Advance(2);
    458339                                att_val_start = AbsPos();
    459340                                Quote_stream = DQuote;
    460341                        }
    461                         else if (at_EqualsSQuote()) {
     342                        else if (at_EqualsSQuote<ASCII>(cur())) {
    462343                                Advance(2);
    463344                                att_val_start = AbsPos();
     
    466347                        else {
    467348                                ScanTo(NonWS);
    468                                 if (!AtChar('=')) {
     349                                if (!AtChar<ASCII,'='>(cur())) {
    469350                                        Error_action(markup_start, AbsPos());
    470351                                        break;
     
    472353                                ScanTo(NonWS);
    473354                                att_val_start = AbsPos()+1;
    474                                 if (AtChar('"')) {
     355                                if (AtChar<ASCII,'"'>(cur())) {
    475356                                        Advance(1);
    476357                                        Quote_stream = DQuote;
    477358                                }
    478                                 else if (AtChar('\'')) {
     359                                else if (AtChar<ASCII,'\''>(cur())) {
    479360                                        Advance(1);
    480361                                        Quote_stream = SQuote;
     
    486367                        }
    487368                        ScanTo(Quote_stream);
    488                         while (AtChar('&')) {
     369                        while (AtChar<ASCII,'&'>(cur())) {
    489370                                Parse_Reference();
    490371                                ScanTo(Quote_stream);
    491372                        }
    492                         if (AtChar('<')) {
     373                        if (AtChar<ASCII,'<'>(cur())) {
    493374                                Error_action(markup_start, AbsPos());
    494375                                break;
     
    496377                        att_val_end = AbsPos();
    497378                        Advance(1);
    498                         if (at_xmlns()) {
     379                        if (at_xmlns<ASCII>(cur())) {
    499380                                Namespace_action(att_name_start, att_name_end,
    500381                                                 att_val_start, att_val_end);
     
    505386                        }
    506387                        /* Now check for end or repeat. Avoid whitespace scan if possible.*/
    507                         if (AtChar('>')) {
     388                        if (AtChar<ASCII,'>'>(cur())) {
    508389                                Advance(1);
    509390                                StartTag_action(markup_start, AbsPos());
    510391                                break;
    511392                        }
    512                         else if (at_EmptyElementDelim()) {
     393                        else if (at_EmptyElementDelim<ASCII>(cur())) {
    513394                                Advance(2);
    514395                                EmptyElement_action(markup_start, AbsPos());
     
    516397                        }
    517398                        ScanTo(NonWS);
    518                         if (AtChar('>')) {
     399                        if (AtChar<ASCII,'>'>(cur())) {
    519400                                Advance(1);
    520401                                StartTag_action(markup_start, AbsPos());
    521402                                break;
    522403                        }
    523                         else if (at_EmptyElementDelim()) {
     404                        else if (at_EmptyElementDelim<ASCII>(cur())) {
    524405                                Advance(2);
    525406                                EmptyElement_action(markup_start, AbsPos());
     
    541422        do {
    542423                ScanTo(MarkupStart); /* '<', '&', or ']' for ']]>' test */
    543 /*              if (AtChar('<')) {
     424/*              if (AtChar<ASCII,'<'>(cur())) {
    544425                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
    545426                        Parse_Markup();
    546427                }*/
    547428                int markup_start = AbsPos();
    548                 if (at_ElementTag_Start()) {
     429                if (at_ElementTag_Start<ASCII>(cur())) {
    549430                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
    550431                        Parse_StartTag();
    551432                }
    552                 else if (at_EndTag_Start()) {
     433                else if (at_EndTag_Start<ASCII>(cur())) {
    553434                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
    554435                        Parse_EndTag();
    555436                }
    556                 else if (at_Comment_Start()) {
     437                else if (at_Comment_Start<ASCII>(cur())) {
    557438                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
    558439                        Parse_Comment();
    559440                }
    560                 else if (AtChar('&')) {
     441                else if (AtChar<ASCII,'&'>(cur())) {
    561442                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
    562443                        Parse_Reference();
    563444                }
    564                 else if (at_CDATA_Start()) {
     445                else if (at_CDATA_Start<ASCII>(cur())) {
    565446                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
    566447                        Parse_CDATA();
    567448                }
    568                 else if (at_PI_Start()) {
     449                else if (at_PI_Start<ASCII>(cur())) {
    569450                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
    570451                        Parse_PI();
    571452                }
    572                 else if (at_CDATA_End()) {
     453                else if (at_CDATA_End<ASCII>(cur())) {
    573454                        if (AbsPos() > text_start) Text_action(text_start, AbsPos());
    574455                        Advance(3);
     
    613494  int decl_start = AbsPos();
    614495  // It is possible that there is no XML declaration.
    615   if (!at_XmlDecl_start()) return;
     496  if (!at_XmlDecl_start<ASCII>(cur())) return;
    616497  // Otherwise, the XML declaration exists and must have
    617498  // at least version information.
     
    619500  Advance(6);
    620501  ASCII_ScanTo(NonWS);
    621   if (!at_version()) {Error_action(decl_start, AbsPos()); return;}
     502  if (!at_version<ASCII>(cur())) {Error_action(decl_start, AbsPos()); return;}
    622503  Advance(7);
    623504  ASCII_ScanTo(NonWS);
    624   if (!AtChar('=')) {Error_action(decl_start, AbsPos()); return;}
     505  if (!AtChar<ASCII,'='>(cur())) {Error_action(decl_start, AbsPos()); return;}
    625506  Advance(1);
    626507  ASCII_ScanTo(NonWS);
    627   if (at_1_0()) xml_info.version = 0;
    628   else if (at_1_1()) xml_info.version = 1;
     508  if (at_1_0<ASCII>(cur())) xml_info.version = 0;
     509  else if (at_1_1<ASCII>(cur())) xml_info.version = 1;
    629510  else {Error_action(decl_start, AbsPos()); return;}
    630511  Advance(5);
    631   if (at_PI_End()) {Advance(2); return;}
    632   if (!ASCII_WS_at(0)) {Error_action(decl_start, AbsPos()); return;}
    633   ASCII_ScanTo(NonWS);
    634   if (at_encoding()) {
     512  if (at_PI_End<ASCII>(cur())) {Advance(2); return;}
     513  if (!at_WhiteSpace<ASCII>(cur())) {Error_action(decl_start, AbsPos()); return;}
     514  ASCII_ScanTo(NonWS);
     515  if (at_encoding<ASCII>(cur())) {
    635516      xml_info.has_encoding_decl = true;
    636517      Advance(8);
    637518      ASCII_ScanTo(NonWS);
    638       if (!AtChar('=')) {Error_action(decl_start, AbsPos()); return;}
     519      if (!AtChar<ASCII,'='>(cur())) {Error_action(decl_start, AbsPos()); return;}
    639520      Advance(1);
    640521      ASCII_ScanTo(NonWS);
    641522      xml_info.encoding_start_pos = AbsPos()+1;
    642       if (AtChar('"')) {
     523      if (AtChar<ASCII,'"'>(cur())) {
    643524        Advance(1);
    644525        ASCII_ScanTo(DQuote);
    645         if (!AtChar('"')) {Error_action(decl_start, AbsPos()); return;}
     526        if (!AtChar<ASCII,'"'>(cur())) {Error_action(decl_start, AbsPos()); return;}
    646527      }
    647       else if (AtChar('\'')) {
     528      else if (AtChar<ASCII,'\''>(cur())) {
    648529        Advance(1);
    649530        ASCII_ScanTo(SQuote);
    650         if (!AtChar('\'')) {Error_action(decl_start, AbsPos()); return;}
     531        if (!AtChar<ASCII,'\''>(cur())) {Error_action(decl_start, AbsPos()); return;}
    651532      }
    652533      else {Error_action(decl_start, AbsPos()); return;}
    653534      xml_info.encoding_end_pos = AbsPos();
    654535      Advance(1);
    655       if (at_PI_End()) {Advance(2); return;}
    656       if (!ASCII_WS_at(0)) {Error_action(decl_start, AbsPos()); return;}
     536      if (at_PI_End<ASCII>(cur())) {Advance(2); return;}
     537      if (!at_WhiteSpace<ASCII>(cur())) {Error_action(decl_start, AbsPos()); return;}
    657538      ASCII_ScanTo(NonWS);
    658539  }
    659   if (at_standalone()) {
     540  if (at_standalone<ASCII>(cur())) {
    660541      xml_info.has_standalone_decl = true;
    661542      Advance(10);
    662543      ASCII_ScanTo(NonWS);
    663       if (!AtChar('=')) {Error_action(decl_start, AbsPos()); return;}
     544      if (!AtChar<ASCII,'='>(cur())) {Error_action(decl_start, AbsPos()); return;}
    664545      Advance(1);
    665546      ASCII_ScanTo(NonWS);
    666       if (at_yes()) {Advance(5); xml_info.standalone = true;}
    667       else if (at_no()) {Advance(4); xml_info.standalone = false;}
     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;}
    668549      else {Error_action(decl_start, AbsPos()); return;}
    669550      ASCII_ScanTo(NonWS);
    670551  }
    671   if (at_PI_End()) {Advance(2); return;}
     552  if (at_PI_End<ASCII>(cur())) {Advance(2); return;}
    672553  else {Error_action(decl_start, AbsPos()); return;}
    673554}
     
    686567  int decl_start = AbsPos();
    687568  // It is possible that there is no XML declaration.
    688   if (!at_XmlDecl_start()) return;
     569  if (!at_XmlDecl_start<ASCII>(cur())) return;
    689570  // Otherwise, the text declaration exists and may have
    690571  // version information.
    691572  Advance(6);
    692573  ASCII_ScanTo(NonWS);
    693   if (at_version()) {
     574  if (at_version<ASCII>(cur())) {
    694575    xml_info.has_version_decl = true;
    695576    Advance(7);
    696577    ASCII_ScanTo(NonWS);
    697     if (!AtChar('=')) {Error_action(decl_start, AbsPos()); return;}
     578    if (!AtChar<ASCII,'='>(cur())) {Error_action(decl_start, AbsPos()); return;}
    698579    Advance(1);
    699580    ASCII_ScanTo(NonWS);
    700     if (at_1_0()) xml_info.version = 0;
    701     else if (at_1_1()) xml_info.version = 1;
     581    if (at_1_0<ASCII>(cur())) xml_info.version = 0;
     582    else if (at_1_1<ASCII>(cur())) xml_info.version = 1;
    702583    else {Error_action(decl_start, AbsPos()); return;}
    703584    Advance(5);
    704585    // Must have whitespace character before declaration.
    705     if (!ASCII_WS_at(0)) {Error_action(decl_start, AbsPos()); return;}
     586    if (!at_WhiteSpace<ASCII>(cur())) {Error_action(decl_start, AbsPos()); return;}
    706587    ASCII_ScanTo(NonWS);
    707588  }
    708   if (!at_encoding()) {Error_action(decl_start, AbsPos()); return;}
     589  if (!at_encoding<ASCII>(cur())) {Error_action(decl_start, AbsPos()); return;}
    709590  xml_info.has_encoding_decl = true;
    710591  Advance(8);
    711592  ASCII_ScanTo(NonWS);
    712   if (!AtChar('=')) {Error_action(decl_start, AbsPos()); return;}
     593  if (!AtChar<ASCII,'='>(cur())) {Error_action(decl_start, AbsPos()); return;}
    713594  Advance(1);
    714595  ASCII_ScanTo(NonWS);
    715596  xml_info.encoding_start_pos = AbsPos()+1;
    716   if (AtChar('"')) {
     597  if (AtChar<ASCII,'"'>(cur())) {
    717598      Advance(1);
    718599      ASCII_ScanTo(DQuote);
    719       if (!AtChar('"')) {Error_action(decl_start, AbsPos()); return;}
    720   }
    721   else if (AtChar('\'')) {
     600      if (!AtChar<ASCII,'"'>(cur())) {Error_action(decl_start, AbsPos()); return;}
     601  }
     602  else if (AtChar<ASCII,'\''>(cur())) {
    722603      Advance(1);
    723604      ASCII_ScanTo(SQuote);
    724       if (!AtChar('\'')) {Error_action(decl_start, AbsPos()); return;}
     605      if (!AtChar<ASCII,'\''>(cur())) {Error_action(decl_start, AbsPos()); return;}
    725606  }
    726607  else {Error_action(decl_start, AbsPos()); return;}
     
    728609  Advance(1);
    729610  ASCII_ScanTo(NonWS);
    730   if (at_PI_End()) {Advance(2); return;}
     611  if (at_PI_End<ASCII>(cur())) {Advance(2); return;}
    731612  else {Error_action(decl_start, AbsPos()); return;}
    732613}
Note: See TracChangeset for help on using the changeset viewer.