Changeset 115 for trunk


Ignore:
Timestamp:
Apr 28, 2008, 4:46:06 PM (11 years ago)
Author:
lindanl
Message:

various error checks in parsing

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/markup_stats.cxx

    r111 r115  
    259259}
    260260
    261 template <CodeUnit_Base C>
    262 inline void ParsingEngine<C>::AttlistDecl_action(unsigned char * item, int lgth) {
    263 #ifdef SHOW_DTD_ACTIONS
    264         printf("AttlistDecl:\n");
    265         cout << string((char *) item, lgth) <<endl;
    266 #endif
    267 }
    268 
    269 template <CodeUnit_Base C>
    270 inline void ParsingEngine<C>::Entitydecl_action(unsigned char * entity_name, int entity_name_lgth, unsigned char * item, int lgth) {
    271 #ifdef SHOW_DTD_ACTIONS
    272         printf("Entitydecl:\n");
    273         cout << string((char *) item, lgth) <<endl;
    274 #endif
    275 }
    276 
    277 template <CodeUnit_Base C>
    278 inline void ParsingEngine<C>::Notationdecl_action(unsigned char * item, int lgth) {
    279 #ifdef SHOW_DTD_ACTIONS
    280         printf("Notationdecl:\n");
    281         cout << string((char *) item, lgth) <<endl;
    282 #endif
    283 }
    284261
    285262template <CodeUnit_Base C>
     
    347324       
    348325        parser->Parse_Prolog();
    349 //      parser->Parse_ExtSubsetDecl();
    350326
    351327//#define VALIDATION
  • trunk/src/bytelex.h

    r98 r115  
    366366        return s3int32(x8data) == c3int32<C, '<', '!', '['>::value;
    367367}
    368 
     368template<CodeUnit_Base C>
     369inline bool at_xml(unsigned char x8data[]) {
     370  return (s4int32(x8data) == c4int32<C, '?', 'x', 'm', 'l'>::value);
     371}
    369372#endif
  • trunk/src/engine.c

    r111 r115  
    324324        ScanTo(Hyphen);
    325325        while (!at_DoubleHyphen<C>(cur())) {
     326                if(at_EOF())
     327                        Syntax_Error(NT_CDSect);
    326328                Advance(2); /* Skip hyphen-nonhyphen pair */
    327329                ScanTo(Hyphen);
     
    369371                ScanTo(CD_End_check);
    370372                while (!at_CDATA_End<C>(cur())) {
     373                        if(at_EOF())
     374                                Syntax_Error(NT_CDSect);
    371375                        Advance(1);
    372376                        ScanTo(CD_End_check);
     
    450454        ScanTo(QMark);
    451455        while (!at_PI_End<C>(cur())) {
     456                if(at_EOF())
     457                        Syntax_Error(NT_PI);
    452458                Advance(1);
    453459                ScanTo(QMark);
     
    644650    ScanTo(NonWS);
    645651    if(at_SYSTEM<C>(cur())||at_PUBLIC<C>(cur())){
     652        model_info->has_external_DTD = true;
    646653        if(old_abspos == AbsPos())
    647654                Syntax_Error(NT_doctypedecl);
    648         Parse_ExternalID();
     655        Parse_ExternalID(model_info->external_DTD_systemLiteral, model_info->external_DTD_pubidLiteral);
     656        Parser_Interface * entity_parser;
     657        entity_parser = ParserFactory(model_info->external_DTD_systemLiteral, model_info);
     658                entity_parser->Parse_ExtSubsetDecl();
     659                entity_parser->~Parser_Interface();
    649660    }
    650    
     661    else model_info->has_external_DTD = false;
    651662    ScanTo(NonWS);     
    652663
     
    684695                model_info->rootModel = cre;
    685696        }
    686 }
    687 
    688 template <CodeUnit_Base C>
    689 inline void ParsingEngine<C>::Parse_ExternalID (){
    690 
     697        else
     698                Syntax_Error(NT_doctypedecl);
     699}
     700
     701template <CodeUnit_Base C>
     702inline void ParsingEngine<C>::Parse_ExternalID (char *& systemLiteral, char *& pubidLiteral){
     703        int quot_start, lgth;
    691704        if(at_SYSTEM<C>(cur())){
    692705                Advance(6);
     706                pubidLiteral = NULL;
    693707                requireWS();
    694                 Parse_MatchedQuote (); /*  SystemLiteral */
     708                if (!AtQuote<C>(cur())) Syntax_Error(NT_ExternalID);
     709                quot_start = AbsPos()+1;
     710                Parse_SystemLiteral (); /*  SystemLiteral */
     711                lgth = AbsPos() - quot_start - 1;                       
     712                systemLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
    695713        }
    696714        else if (at_PUBLIC<C>(cur())){
    697715                Advance(6);
    698716                requireWS();
    699                 Parse_MatchedQuote ();/*  PubidLiteral */
     717                if (!AtQuote<C>(cur())) Syntax_Error(NT_ExternalID);
     718                quot_start = AbsPos()+1;
     719                Parse_PubidLiteral ();/*  PubidLiteral */
     720                lgth = AbsPos() - quot_start - 1;                       
     721                pubidLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
     722                systemLiteral = NULL;
     723                if (AtChar<C, '>'>(cur())) return;
    700724                requireWS();
    701                 Parse_MatchedQuote ();/*  SystemLiteral */
     725                if (AtQuote<C>(cur())) {
     726                        quot_start = AbsPos()+1;       
     727                        Parse_SystemLiteral ();/*  SystemLiteral */
     728                        lgth = AbsPos() - quot_start - 1;                       
     729                        systemLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
     730                }
    702731        }
    703732        else
     
    706735
    707736template <CodeUnit_Base C>
    708 inline void ParsingEngine<C>::Parse_MatchedQuote (){
     737inline void ParsingEngine<C>::Parse_SystemLiteral (){
    709738        unsigned char quoteCh;
    710739        if(AtQuote<C>(cur())){
    711740                quoteCh = cur()[0];
    712741                Advance(1);
    713         }
     742        }       
    714743        ScanTo(Quote);                 
    715744        while (cur()[0] != quoteCh){
     745                if(at_EOF())
     746                        Syntax_Error(NT_SystemLiteral);
     747                Advance(1);
     748                ScanTo(Quote);
     749        }
     750        Advance(1);
     751}
     752
     753template <CodeUnit_Base C>
     754inline void ParsingEngine<C>::Parse_PubidLiteral (){
     755        unsigned char quoteCh;
     756        if(AtQuote<C>(cur())){
     757                quoteCh = cur()[0];
     758                Advance(1);
     759        }       
     760        ScanTo(Quote);                 
     761        while (cur()[0] != quoteCh){
     762                if(at_EOF())
     763                        Syntax_Error(NT_PubidLiteral);
    716764                Advance(1);
    717765                ScanTo(Quote);
     
    732780
    733781                        if (AtChar<C,'?'>(cur())){
    734                                 Parse_PI();
     782                                if (at_xml<C>(cur()))
     783                                        Syntax_Error(NT_intSubset);
     784                                else
     785                                        Parse_PI();
    735786                        }
    736787                        else if(AtChar<C,'!'>(cur())){
     
    811862                        CM_RegExp * cre = new CM_RegExp;
    812863                        cre->content_re = Parse_RemainingChildren();
    813                        
     864
    814865                        int id_count = cre->content_re->Set_IDs(0);
    815                         cre->content_re->Set_First_Map();              
     866                        cre->content_re->Set_First_Map();       
    816867                        symbol_set_t * transition_map = new symbol_set_t[id_count+1];
    817868                        cre->content_re->follow_map[0] = id_count+1;
     
    827878                        model_info->ContentModelData.push_back(cre);
    828879                        cm = cre;
    829                 }
    830                        
     880                }                       
    831881    }
    832                
     882    ScanTo(NonWS);   
     883
    833884        if (AtChar<C,'>'>(cur())) {
    834 
    835                 Advance(1);
    836                        
    837 
     885                Advance(1);
    838886        }
    839887        else
     
    882930inline Content_RE * ParsingEngine<C>::Parse_RemainingChildren (){
    883931        Content_RE * c1 = Parse_Cp();
    884         Content_RE * r;
     932        Content_RE * r = c1;
    885933        ScanTo(NonWS);
    886934        if(AtChar<C,'|'>(cur())){
     
    894942                        if(AtChar<C,'|'>(cur()))
    895943                                Advance(1);
     944                        else
     945                                Syntax_Error(NT_children);
    896946                        ScanTo(NonWS);
    897947                        rslt->subCMs.push_back(Parse_Cp());
     
    912962                        if(AtChar<C,','>(cur()))
    913963                                Advance(1);
     964                        else
     965                                Syntax_Error(NT_children);
    914966                        ScanTo(NonWS);
    915967                        rslt->subCMs.push_back(Parse_Cp());
     
    10641116
    10651117        Advance(1);
    1066         AttlistDecl_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    10671118}
    10681119
     
    12251276       
    12261277                requireWS();
    1227                 if(at_SYSTEM<C>(cur())){
    1228                         Advance(6);
    1229                         requireWS();
    1230                         quot_start = AbsPos()+1;
    1231                         Parse_MatchedQuote (); /*  SystemLiteral */
    1232                         lgth = AbsPos() - quot_start - 1;                       
    1233                         this_info->systemLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
    1234                         this_info->is_external = true;
    1235                 }
    1236                 else if (at_PUBLIC<C>(cur())){
    1237                         Advance(6);
    1238                         requireWS();
    1239                        
    1240                         quot_start = AbsPos()+1;
    1241                         Parse_MatchedQuote ();/*  PubidLiteral */               
    1242                         lgth = AbsPos() - quot_start - 1;                       
    1243                         this_info->pubidLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
    1244                         this_info->is_external = true; 
    1245                        
    1246                         requireWS();
    1247                        
    1248                         quot_start = AbsPos()+1;
    1249                         Parse_MatchedQuote (); /*  SystemLiteral */
    1250                         lgth = AbsPos() - quot_start - 1;                       
    1251                         this_info->systemLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
    1252                         this_info->is_external = true;
    1253                 }
    1254         else if(AtQuote<C>(cur())){
     1278                if(AtQuote<C>(cur())){
    12551279                Parse_PEntityValue(this_info);
    12561280                this_info->is_external = false;
    12571281        }
    1258         else
    1259                 Syntax_Error(NT_EntityDecl);
    1260         model_info->PEntityData.push_back(this_info);
     1282        else {
     1283                this_info->is_external = true;
     1284                Parse_ExternalID(this_info->systemLiteral, this_info->pubidLiteral);
     1285                if (this_info->systemLiteral == NULL) Syntax_Error(NT_EntityDecl);
     1286        }
     1287        model_info->PEntityData.push_back(this_info);
    12611288        }
    12621289        else{
     
    12801307                requireWS();
    12811308               
    1282                 if(at_SYSTEM<C>(cur())){
    1283                         Advance(6);
    1284                         requireWS();
    1285                         quot_start = AbsPos()+1;
    1286                         Parse_MatchedQuote (); /*  SystemLiteral */
    1287                         lgth = AbsPos() - quot_start - 1;                       
    1288                         this_info->systemLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
    1289                         this_info->is_external = true;
    1290                        
     1309                if(AtQuote<C>(cur())){
     1310                Parse_GEntityValue(this_info);
     1311                this_info->is_external = false;
     1312        }
     1313        else {
     1314                this_info->is_external = true;
     1315                Parse_ExternalID(this_info->systemLiteral, this_info->pubidLiteral);
     1316                if (this_info->systemLiteral == NULL) Syntax_Error(NT_EntityDecl);
    12911317                        old_abspos = AbsPos();
    12921318                        ScanTo(NonWS);
     
    13031329                }
    13041330                }
    1305                 else if (at_PUBLIC<C>(cur())){
    1306                         Advance(6);
    1307                         requireWS();
    1308                        
    1309                         quot_start = AbsPos()+1;
    1310                         Parse_MatchedQuote ();/*  PubidLiteral */               
    1311                         lgth = AbsPos() - quot_start - 1;                       
    1312                         this_info->pubidLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
    1313                         this_info->is_external = true; 
    1314                        
    1315                         requireWS();
    1316                        
    1317                         quot_start = AbsPos()+1;
    1318                         Parse_MatchedQuote (); /*  SystemLiteral */
    1319                         lgth = AbsPos() - quot_start - 1;                       
    1320                         this_info->systemLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
    1321                         this_info->is_external = true;
    1322                        
    1323                         old_abspos = AbsPos();
    1324                         ScanTo(NonWS);
    1325                 if(at_NDATA<C>(cur())){
    1326                         if(old_abspos == AbsPos())
    1327                                 Syntax_Error(NT_EntityDecl);
    1328                         else
    1329                                 Advance(5);
    1330                         requireWS();
    1331                         name_start = AbsPos();
    1332                         ScanTo(NameFollow);
    1333                         lgth = AbsPos() - name_start;
    1334                         this_info->NDataName = copy_string(GetCodeUnitPtr(name_start),lgth);
    1335                 }
    1336                 }
    1337                 else if(AtQuote<C>(cur())){
    1338                 Parse_GEntityValue(this_info);
    1339                 this_info->is_external = false;
    1340         }
    1341         else
    1342                 Syntax_Error(NT_EntityDecl);
    13431331        model_info->GEntityData.push_back(this_info);
    13441332        }
     
    13461334        if (AtChar<C,'>'>(cur())){
    13471335                Advance(1);
    1348                 Entitydecl_action(GetCodeUnitPtr(name_start), lgth,
    1349                                   GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    13501336        }
    13511337        else
    13521338                Syntax_Error(NT_EntityDecl);
    13531339}
    1354        
     1340
    13551341template <CodeUnit_Base C>
    13561342inline void ParsingEngine<C>::Parse_Notationdecl (){
     
    13751361        else /*Duplicate notation name!*/
    13761362                Validity_Error(vErr_NoDuplicateTokens);
    1377                
    1378         requireWS();
    1379         if(at_SYSTEM<C>(cur())){
    1380                 Advance(6);
    1381                 requireWS();
    1382                 Parse_MatchedQuote (); /*  SystemLiteral */
    1383         }
    1384         else if (at_PUBLIC<C>(cur())){
    1385                 Advance(6);
    1386                 requireWS();
    1387                 Parse_MatchedQuote (); /*  PubidLiteral */
    1388                 ScanTo(NonWS);
    1389                 if (!AtChar<C,'>'>(cur())){
    1390                         if (old_abspos == AbsPos())
    1391                                 Syntax_Error(NT_NotationDecl);
    1392                         Parse_MatchedQuote (); /*  SystemLiteral */
    1393                 }
    1394         }
    1395         else
    1396                 Syntax_Error(NT_NotationDecl);
     1363        Notation_info * this_info = new Notation_info;
     1364                       
     1365    Parse_ExternalID(this_info->systemLiteral, this_info->pubidLiteral);
    13971366        ScanTo(NonWS);
    13981367        if (AtChar<C,'>'>(cur())) {
    13991368                Advance(1);
    1400                 Notationdecl_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    14011369        }
    14021370        else
  • trunk/src/engine.h

    r110 r115  
    9999        /* Parsing routine for Document Type*/
    100100        void Parse_DocType ();
    101         void Parse_ExternalID ();
    102         void Parse_MatchedQuote ();
     101        void Parse_ExternalID (char *& SystemLiteral, char *& PubidLiteral);
     102        void Parse_SystemLiteral ();
     103        void Parse_PubidLiteral ();
    103104        void Parse_IntSubset ();
    104105        void Parse_PEReference ();
     
    194195        void Doctype_action(unsigned char * item, int lgth);
    195196        void PEReference_action(unsigned char * item, int lgth);
    196         void AttlistDecl_action(unsigned char * item, int lgth);
    197         void Entitydecl_action(unsigned char * entity_name, int entity_name_lgth, unsigned char * item, int lgth);
    198         void Notationdecl_action(unsigned char * item, int lgth);
    199197       
    200198        void Prolog_action(unsigned char * item, int lgth);
  • trunk/src/xmlmodel.h

    r108 r115  
    129129
    130130
     131class Notation_info {
     132public:
     133        char * systemLiteral;
     134        char * pubidLiteral;   
     135};
     136
    131137
    132138class Entity_Info {
     
    161167        Model_Info();
    162168        ~Model_Info();
     169        bool has_external_DTD;
     170        char * external_DTD_systemLiteral;
     171        char * external_DTD_pubidLiteral;       
     172
    163173   
    164174        /* Information computed from ATTLIST, ELEMENT, NOTATION and ENTITY declarations. */
     
    186196        vector<GEntity_info *> GEntityData;
    187197        vector<PEntity_info *> PEntityData;
     198        vector<Notation_info *> NotationData;
     199       
    188200        void SimpleEntity(char * entity_Name, char * replText);
    189201};
Note: See TracChangeset for help on using the changeset viewer.