Changeset 97 for trunk/src/engine.c


Ignore:
Timestamp:
Apr 10, 2008, 3:35:13 PM (11 years ago)
Author:
lindanl
Message:

External Subset and error messages and global entity table.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/engine.c

    r94 r97  
    1111#include "bytelex.h"
    1212#include "bitlex.h"
     13#include "errcodes.h"
    1314
    1415#include <assert.h>
     
    2021using namespace std;
    2122
    22 Parser_Interface * Parser_Interface::ParserFactory(char * filename) {
     23Parser_Interface * Parser_Interface::ParserFactory(char * filename, bool is_external) {
    2324       
    2425        int chars_read;
     
    3738
    3839        if (m->code_unit_base == ASCII) {
    39                 return new ParsingEngine<ASCII>(m, b);
     40                return new ParsingEngine<ASCII>(m, b, is_external);
    4041        }
    4142        else /* if (m->code_unit_base == EBCDIC) */ {
    42                 return new ParsingEngine<EBCDIC>(m, b);
     43                return new ParsingEngine<EBCDIC>(m, b, is_external);
    4344        }       
    4445}
     
    7778
    7879template <CodeUnit_Base C>
    79 ParsingEngine<C>::ParsingEngine(Model_Info * m, Byteplex * b) : Parser_Interface () {
     80ParsingEngine<C>::ParsingEngine(Model_Info * m, Byteplex * b, bool is_external) : Parser_Interface () {
    8081
    8182        model_info = m;
     
    8889       
    8990        decl_parser = new XML_Decl_Parser<C>(byteplex);
    90         int content_start = decl_parser->ReadXMLInfo(model_info);
     91        int content_start = 0;
     92        if(is_external == true)
     93                content_start = decl_parser->ReadTextDeclaration(model_info);
     94        else
     95                content_start = decl_parser->ReadXMLInfo(model_info);
    9196
    9297    bitplex = new Bitplex;
     
    244249#endif
    245250
     251template <CodeUnit_Base C>
     252inline void ParsingEngine<C>::WF_Error (XML_Error errCode) {
     253        ShowConstraintError(errCode);
     254        Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     255}
     256       
     257
     258template <CodeUnit_Base C>
     259inline void ParsingEngine<C>::Validity_Error (XML_Error errCode) {
     260        ShowConstraintError(errCode);
     261        Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     262}
     263       
     264template <CodeUnit_Base C>
     265inline void ParsingEngine<C>::Syntax_Error (XML_NonTerminal errNT) {
     266        ShowSyntaxError(errNT);
     267        Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     268}
     269       
     270
     271
     272
    246273
    247274/* Parse a markup item beginning '<' */
     
    266293        else {
    267294                Advance(1);
    268                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     295                Syntax_Error(NT_content);
    269296        }
    270297}
     
    286313        else {
    287314                Advance(2);  /* "--" */
    288                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     315                Syntax_Error(NT_Comment);
    289316        }
    290317}
     
    305332                        EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    306333                }
    307                 else Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     334                else Syntax_Error(NT_ETag);
    308335        }
    309336}
     
    314341        Advance(8); /* Skip "<![CDATA". */
    315342        if (!AtChar<C,'['>(cur())) {
    316                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     343                Syntax_Error(NT_CDStart);
    317344        }
    318345        else { 
     
    336363        ScanTo(NameFollow);  /* Name delimiter */
    337364        if (!AtChar<C,';'>(cur())) {
    338                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     365                Syntax_Error(NT_Reference);
    339366        }
    340367        else {
     
    351378        if (at_XxMmLll_WS<C>(cur())) {
    352379                Advance(4);
    353                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     380                Syntax_Error(NT_PI);
    354381                return;
    355382        }
     
    402429                        else {
    403430                                if (LastAttOccurrence[attID] > text_or_markup_start) {
    404                                         Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start)); /* Duplicate attribute. */
     431                                        WF_Error(wfErr_uniqattspec); /* Duplicate attribute. */
    405432                                        break;
    406433                                }                       
     
    418445                                ScanTo(NonWS);
    419446                                if (!AtChar<C,'='>(cur())) {
    420                                         Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     447                                        Syntax_Error(NT_STag);
    421448                                        break;
    422449                                }
     
    424451                                quoteCh = cur()[0];
    425452                                if (!AtQuote<C>(cur())) {
    426                                         Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     453                                        Syntax_Error(NT_STag);
    427454                                        break;
    428455                                }
     
    440467                                }
    441468                                else /* if (AtChar<C,'<'>(cur())) */{
    442                                         Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     469                                        WF_Error(wfErr_CleanAttrVals);
    443470                                        break;
    444471                                }
     
    478505                        else if (AbsPos() == att_val_end + 1) {
    479506                                /* No WS following att value */
    480                                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     507                                Syntax_Error(NT_STag);
    481508                                break;
    482509                        }
     
    530557                        text_if_nonnull_action();
    531558                        Advance(3);
    532                         Error_action(GetCodeUnitPtr(AbsPos()-3), 3);
     559                        Syntax_Error(NT_CharData);
    533560                }
    534561                else if (at_EOF()) {
     
    566593    if(at_SYSTEM<C>(cur())||at_PUBLIC<C>(cur())){
    567594        if(old_abspos == AbsPos())
    568                 Error_action(GetCodeUnitPtr(start_pos), LengthFrom(start_pos));
     595                Syntax_Error(NT_doctypedecl);
    569596        Parse_ExternalID();
    570597    }
     
    578605                        Advance(1);
    579606                else
    580                         Error_action(GetCodeUnitPtr(start_pos), LengthFrom(start_pos));
     607                Syntax_Error(NT_doctypedecl);
    581608                ScanTo(NonWS);
    582609        }
     
    604631        }
    605632        else
    606                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     633                Syntax_Error(NT_ExternalID);
    607634}
    608635
     
    647674                                        Parse_Entitydecl();
    648675                                else if(at_NOTATION<C>(cur()))
    649                                         Parse_Notationdecl();                   
    650                                        
     676                                        Parse_Notationdecl();
     677                                else{
     678                                        Syntax_Error(NT_markupdecl);           
     679                                }                                                               
    651680                        }
    652681                        else
    653                                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     682                                Syntax_Error(NT_markupdecl);
    654683                }
    655684                else if (AtChar<C,']'>(cur())){
     
    657686                }
    658687                else
    659                         Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     688                        Syntax_Error(NT_intSubset);
    660689        }
    661690}
     
    672701        }
    673702        else
    674                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     703                Syntax_Error(NT_PEReference);
    675704}
    676705
     
    708737        }
    709738        else
    710                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     739                Syntax_Error(NT_elementdecl);
    711740}
    712741template <CodeUnit_Base C>
     
    772801        }
    773802        else
    774                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     803                Syntax_Error(NT_children);
    775804               
    776805        if (AtChar<C,'?'>(cur())||AtChar<C,'*'>(cur())||AtChar<C,'+'>(cur()))
     
    815844        while(!AtChar<C,'>'>(cur())) {
    816845                if(old_abspos == AbsPos())
    817                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     846                Syntax_Error(NT_AttlistDecl);
    818847               
    819848        name_start = AbsPos();
     
    834863                this_info->attType = ID_att;
    835864        }
     865        /* Make sure to check IDREFS before IDREF*/
     866        else if(at_IDREFS<C>(cur())){
     867                Advance(6);
     868                this_info->attType = IDREFS_att;
     869        }
    836870        else if(at_IDREF<C>(cur())){
    837871                Advance(5);
    838872                this_info->attType = IDREF_att;
    839873        }
    840         else if(at_IDREFS<C>(cur())){
    841                 Advance(6);
    842                 this_info->attType = IDREFS_att;
    843         }
    844874        else if(at_ENTITY<C>(cur())){
    845875                Advance(6);
     
    850880                this_info->attType = ENTITIES_att;
    851881        }
     882        /* Make sure to check NMTOKENS before NMTOKEN*/
     883        else if(at_NMTOKENS<C>(cur())){
     884                Advance(8);
     885                this_info->attType = NMTOKENS_att;
     886        }
    852887        else if(at_NMTOKEN<C>(cur())){
    853888                Advance(7);
    854889                this_info->attType = NMTOKEN_att;
    855         }
    856         else if(at_NMTOKENS<C>(cur())){
    857                 Advance(8);
    858                 this_info->attType = NMTOKENS_att;
    859890        }
    860891        else if(at_NOTATION<C>(cur())){ /* NotationType = 'NOTATION' S Enumeration
     
    870901        }
    871902        else
    872                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     903                Syntax_Error(NT_AttlistDecl);
    873904        requireWS();
    874905        Parse_DefaultDecl(this_info);
     
    888919                Advance(1);
    889920        else
    890                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     921                Syntax_Error(NT_NotationType);
    891922        ScanTo(NonWS);
    892923       
     
    901932        /*Notation name is not in the global table!*/
    902933        if(model_info->GlobalNotationTable[s]==0)
    903                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     934                Validity_Error(vErr_notatn);
    904935       
    905936        ScanTo(NonWS);
     
    916947       
    917948                if(model_info->GlobalNotationTable[s]==0)
    918                         Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     949                        Validity_Error(vErr_notatn);
    919950                       
    920951                ScanTo(NonWS);
     
    923954                Advance(1);
    924955        else
    925                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     956                Syntax_Error(NT_NotationType);
    926957}
    927958
     
    933964                Advance(1);
    934965        else
    935                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     966                Syntax_Error(NT_Enumeration);
    936967        ScanTo(NonWS);
    937968       
     
    964995                }
    965996                else if(!StrictWellFormedness){
    966                         Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     997                        Validity_Error(vErr_NoDuplicateTokens);
    967998                }
    968999                ScanTo(NonWS);
     
    9711002                Advance(1);
    9721003        else
    973                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     1004                Syntax_Error(NT_Enumeration);
    9741005}
    9751006
     
    10021033                        }
    10031034                else
    1004                         Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     1035                        Syntax_Error(NT_DefaultDecl);
    10051036        }
    10061037}
     
    10091040inline void ParsingEngine<C>::Parse_Entitydecl (){
    10101041       
    1011         int entity_name_start;
    1012         int entity_name_end;
     1042        int name_start;
     1043        int lgth;
    10131044        int old_abspos;
    10141045        Advance(6); /* Skip "ENTITY. */
     
    10181049                Advance(1);
    10191050                requireWS();
    1020                 entity_name_start = AbsPos();
     1051               
     1052                name_start = AbsPos();
    10211053                ScanTo(NameFollow);
    1022                 entity_name_end = AbsPos();
     1054                lgth = AbsPos()- name_start;
     1055                char *s = new char[lgth+1];
     1056                memcpy(s, GetCodeUnitPtr(name_start), lgth);
     1057                s[lgth] = '\0';
     1058       
     1059                int entityID = model_info->GlobalEntityTable[s];
     1060                if(entityID==0){       
     1061                        model_info->GlobalEntityTable[s]=++(model_info->globalEntityCount);
     1062                        entityID = model_info->globalEntityCount;
     1063                }
     1064                else
     1065                        printf("Warning: Entity definition already exist!\n");
     1066       
    10231067                requireWS();
    10241068                if(at_SYSTEM<C>(cur())||at_PUBLIC<C>(cur())){
     
    10291073        }
    10301074        else
    1031                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     1075                Syntax_Error(NT_EntityDecl);
    10321076        }
    10331077        else{
    1034                 entity_name_start = AbsPos();
     1078                name_start = AbsPos();
    10351079                ScanTo(NameFollow);
    1036                 entity_name_end = AbsPos();
     1080                lgth = AbsPos()- name_start;
     1081                char *s = new char[lgth+1];
     1082                memcpy(s, GetCodeUnitPtr(name_start), lgth);
     1083                s[lgth] = '\0';
     1084       
     1085                int entityID = model_info->GlobalEntityTable[s];
     1086                if(entityID==0){       
     1087                        model_info->GlobalEntityTable[s]=++(model_info->globalEntityCount);
     1088                        entityID = model_info->globalEntityCount;
     1089                }
     1090                else
     1091                        printf("Warning: Entity definition already exist!\n");
     1092                       
    10371093                requireWS();
    10381094               
     
    10401096                Parse_ExternalID();
    10411097                ScanTo(NonWS);
    1042                 if(at_NOTATION<C>(cur())){
     1098                if(at_NDATA<C>(cur())){
    10431099                        if(old_abspos == AbsPos())
    1044                                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     1100                                Syntax_Error(NT_EntityDecl);
    10451101                        else
    10461102                                Advance(5);
     
    10531109        }
    10541110        else
    1055                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     1111                Syntax_Error(NT_EntityDecl);
    10561112        }
    10571113        ScanTo(NonWS);
    10581114        if (AtChar<C,'>'>(cur())){
    10591115                Advance(1);
    1060                 Entitydecl_action(GetCodeUnitPtr(entity_name_start), entity_name_end - entity_name_start,
     1116                Entitydecl_action(GetCodeUnitPtr(name_start), lgth,
    10611117                                  GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    10621118        }
    10631119        else
    1064                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     1120                Syntax_Error(NT_EntityDecl);
    10651121}
    10661122
     
    10861142        }
    10871143        else /*Duplicate notation name!*/
    1088                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     1144                Validity_Error(vErr_NoDuplicateTokens);
    10891145               
    10901146        requireWS();
     
    11011157                if (!AtChar<C,'>'>(cur())){
    11021158                        if (old_abspos == AbsPos())
    1103                                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     1159                                Syntax_Error(NT_NotationDecl);
    11041160                        Parse_MatchedQuote (); /*  SystemLiteral */
    11051161                }
    11061162        }
    11071163        else
    1108                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     1164                Syntax_Error(NT_NotationDecl);
    11091165        ScanTo(NonWS);
    11101166        if (AtChar<C,'>'>(cur())) {
     
    11131169        }
    11141170        else
    1115                 Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     1171                Syntax_Error(NT_NotationDecl);
    11161172}
    11171173
     
    11221178    ScanTo(NonWS);
    11231179    if(old_abspos == AbsPos())
    1124         Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     1180        Syntax_Error(NT_S);
    11251181}
    11261182
     
    11421198                }
    11431199                else /* if (AtChar<C,'<'>(cur())) */
    1144                         Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     1200                        WF_Error(wfErr_CleanAttrVals);
    11451201        }
    11461202        Advance(1);
     
    11741230}
    11751231
    1176 
    1177 
     1232template <CodeUnit_Base C>
     1233inline void ParsingEngine<C>::Parse_ExtSubsetDecl() {
     1234        int start_pos=AbsPos();
     1235        while(!at_EOF()){
     1236                if(at_condSect_start<C>(cur())){               
     1237                        Advance(3);
     1238                        ScanTo(NonWS);
     1239                        if (at_INCLUDE<C>(cur())){
     1240                                Advance(7);
     1241                                ScanTo(NonWS);
     1242                                if(AtChar<C,'['>(cur())){
     1243                                        Advance(1);
     1244                                        Parse_ExtSubsetDecl();
     1245                                        if(at_CDATA_End<C>(cur()))
     1246                                                Advance(3);
     1247                                        else Syntax_Error(NT_includeSect);
     1248                                }
     1249                                else Syntax_Error(NT_includeSect);
     1250                        }
     1251                        else if (at_IGNORE<C>(cur())){
     1252                                Advance(6);
     1253                                ScanTo(NonWS);         
     1254                                if(AtChar<C,'['>(cur())){
     1255                                        int section_depth=1;
     1256                                        Advance(1);
     1257                                        while(!at_EOF()){
     1258                                                ScanToMarkupStart();
     1259                                                if(at_condSect_start<C>(cur())){
     1260                                                        Advance(3);
     1261                                                        section_depth++;
     1262                                                }
     1263                                                else if(at_CDATA_End<C>(cur())){
     1264                                                        Advance(3);
     1265                                                        section_depth--;
     1266                                                }
     1267                                                if(section_depth==0) return;                                   
     1268                                        }
     1269                                        Syntax_Error(NT_ignoreSectContents);   
     1270                                }
     1271                                else Syntax_Error(NT_ignoreSect);
     1272                        }
     1273                        else Syntax_Error(NT_conditionalSect);
     1274                }
     1275                else if (AtChar<C,'%'>(cur()))
     1276                        Parse_PEReference();   
     1277                else if (AtChar<C,'<'>(cur())){
     1278                        Advance(1);
     1279
     1280                        if (AtChar<C,'?'>(cur())){
     1281                                Parse_PI();
     1282                        }
     1283                        else if(AtChar<C,'!'>(cur())){
     1284                                Advance(1);
     1285                                if(at_DoubleHyphen<C>(cur()))
     1286                                        Parse_Comment();
     1287                                else if(at_ELEMENT<C>(cur()))
     1288                                        Parse_Elementdecl();
     1289                                else if(at_ATTLIST<C>(cur()))
     1290                                        Parse_AttlistDecl();
     1291                                else if(at_ENTITY<C>(cur()))
     1292                                        Parse_Entitydecl();
     1293                                else if(at_NOTATION<C>(cur()))
     1294                                        Parse_Notationdecl();                                   
     1295                                else{
     1296                                        Syntax_Error(NT_markupdecl);   
     1297                                }                                                               
     1298                        }
     1299                        else
     1300                                Syntax_Error(NT_markupdecl);
     1301                }
     1302                else
     1303                        Syntax_Error(NT_extSubsetDecl);
     1304                ScanTo(NonWS);
     1305        }
     1306        ExtSubsetDecl_action(GetCodeUnitPtr(start_pos), LengthFrom(start_pos));
     1307}
Note: See TracChangeset for help on using the changeset viewer.