Changeset 124 for trunk


Ignore:
Timestamp:
May 1, 2008, 5:06:42 PM (11 years ago)
Author:
lindanl
Message:

Name checking and other well-formedness checking.

Location:
trunk
Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/markup_stats.cxx

    r122 r124  
    3838#include "src/xmldecl.h"
    3939#include "src/bitlex.h"
    40 #include "src/namechars.h"
    4140
    4241
     
    148147        error_item_length += lgth;
    149148        fprintf(stderr, "Error: illegal markup at positions %i of length %i.\n", AbsPos()-lgth, lgth);
    150         cout << string((char *) item, lgth) << endl;
     149        cerr << string((char *) item, lgth) << endl;
    151150}
    152151
     
    256255        cout << string((char *) item, lgth) <<endl;
    257256#endif
    258         printf("Finish parsing ExtSubsetDecl!\n");
    259257}
    260258
     
    321319        parser->Parse_Prolog();
    322320
    323         //#define VALIDATION
    324         #ifdef VALIDATION
    325                 parser->Parse_DocumentContent();
    326         #endif
    327        
    328         #ifndef VALIDATION
    329                 parser->ParseContent();
    330         #endif
     321        parser->Parse_DocumentContent();
    331322
    332323        parser->~Parser_Interface();
  • trunk/src/bitlex.h

    r100 r124  
    1616/* Lexical items are particular characters, character classes
    1717   or character sequences significant for XML parsing.  */
     18
     19#define DIGIT_AND_HEX_ITEMS
    1820
    1921enum lexical_item {
  • trunk/src/bytelex.h

    r119 r124  
    158158
    159159template<CodeUnit_Base C>
    160 inline bool at_XxMmLll_WS(unsigned char x8data[]) {
    161   return caseless_comp<C, 'x', 'm', 'l'>(x8data) &&
    162          at_WhiteSpace<XML_1_0, C>(&x8data[3]);
     160inline bool at_XxMmLll(unsigned char x8data[]) {
     161  return caseless_comp<C, 'x', 'm', 'l'>(x8data);
    163162}
    164163
  • trunk/src/engine.c

    r119 r124  
    3030}
    3131
     32inline char * cat_string (char * s1, char * s2, int lgth1, int lgth2){
     33        char * s = new char[lgth1 + lgth2 + 1];
     34        memcpy(s, s1,lgth1);
     35//      s[lgth1] = '\0';       
     36//      strncat(s, s2, lgth2); 
     37        memcpy(&s[lgth1],s2,lgth2);
     38        s[lgth1 + lgth2] = '\0';
     39        return s;
     40}
     41       
     42       
     43       
    3244Parser_Interface * Parser_Interface::ParserFactory(char * filename) {
    3345       
     
    343355inline void ParsingEngine<C>::Parse_EndTag() {
    344356        Advance(2); /* Skip "</". */
    345         ScanTo(NameFollow);
     357        int nameID = Parse_Name();
    346358        if (AtChar<C,'>'>(cur())) {
    347359                Advance(1);
     
    386398    Advance(1);  // skip "&"
    387399    int ref_start = AbsPos();
    388         ScanTo(NameFollow);  /* Name delimiter */
     400        int nameID = Parse_Name();  /* Name delimiter */
    389401    if (!AtChar<C,';'>(cur())) {
    390402                Syntax_Error(NT_Reference);
     
    408420                        this_info = model_info->GEntityData[entityID-1];
    409421                        if (this_info->is_external){
    410                                 entity_parser = ParserFactory(this_info->systemLiteral, model_info);
    411                                 entity_parser->ParseContent();
    412                                 entity_parser->~Parser_Interface();
     422                               
     423                        if (entity_Info->standalone != Standalone_no)
     424                                WF_Error(wfErr_NoExternalRefs);
     425                        else {
     426                                        entity_parser = ParserFactory(this_info->systemLiteral, model_info);
     427                                        entity_parser->Parse_WF_Content();
     428                                        if(!entity_parser->at_EOF())
     429                                                Syntax_Error(NT_content);
     430                                        entity_parser->~Parser_Interface();
     431                        }
    413432                        }
    414433                        else {
     
    418437//                                      printf("Not a simple text: %s\n",this_info->ReplacementText);
    419438                                        entity_parser = ParserFactory(this_info->ReplacementText, strlen(this_info->ReplacementText),entity_Info, model_info);
    420                                         entity_parser->ParseContent();
     439                                        entity_parser->Parse_WF_Content();
     440                                        if(!entity_parser->at_EOF())
     441                                                Syntax_Error(NT_content);
    421442                                        entity_parser->~Parser_Interface();
    422443                                }
     
    430451inline void ParsingEngine<C>::Parse_CharRef() {
    431452        Advance(2);  // skip "&#"
    432         ScanTo(NameFollow);  /* Name delimiter */
     453        if (AtChar<C,'x'>(cur())) {
     454                Advance(1);
     455                int hex_pos = AbsPos();
     456                ScanTo(NonHex);
     457                if (AbsPos() == hex_pos) Syntax_Error(NT_CharRef);
     458        }
     459        else {
     460                int num_pos = AbsPos();
     461                ScanTo(NonDigit);
     462                if (AbsPos() == num_pos) Syntax_Error(NT_CharRef); 
     463        }       
    433464        if (!AtChar<C,';'>(cur())) {
    434                 Syntax_Error(NT_Reference);
     465                        Syntax_Error(NT_CharRef);
    435466        }
    436467        else {
     
    442473template <CodeUnit_Base C>
    443474inline void ParsingEngine<C>::Parse_PI (){
     475        int nameID;
    444476        Advance(2); /* Skip "<?". */
    445477        int target_start = AbsPos();
    446         // Check for illegal [Xx][Mm][Ll] target.
    447         if (at_XxMmLll_WS<C>(cur())) {
    448                 Advance(4);
    449                 Syntax_Error(NT_PI);
    450                 return;
    451         }
    452         ScanTo(NameFollow);  /* Name delimiter */
     478        if (at_XxMmLll<C>(cur())) {
     479                nameID = Parse_Name();
     480                if (AbsPos() - target_start == 3) Syntax_Error(NT_PI);
     481        }
     482        else nameID = Parse_Name();
    453483        PI_Target_action(GetCodeUnitPtr(target_start), LengthFrom(target_start));
     484        if (!at_PI_End<C>(cur())) requireWS();
    454485        ScanTo(QMark);
    455486        while (!at_PI_End<C>(cur())) {
     
    471502        unsigned char quoteCh;
    472503        Advance(1);
    473         ScanTo(NameFollow);  /* Name delimiter: WS, "/" or ">" */
     504        int nameID = Parse_Name();  /* Name delimiter: WS, "/" or ">" */
    474505        ElementName_action(GetCodeUnitPtr(text_or_markup_start+1), LengthFrom(text_or_markup_start+1));
    475506        /* The following test optimizes the most common case of a
     
    492523                        /* Must be an attribute-value pair or error. */
    493524                        att_name_start = AbsPos();
    494                         ScanTo(NameFollow);
     525                        int nameID = Parse_Name();
     526                        att_name_end = AbsPos();
     527                        int lgth = att_name_end-att_name_start;
     528               
     529                        int attID = model_info->getOrInsertGlobalAttName(GetCodeUnitPtr(att_name_start), lgth);
     530                        if (attID >= LastAttOccurrence.size()) LastAttOccurrence.push_back(0);
     531                        else {
     532                                if (LastAttOccurrence[attID] > text_or_markup_start) {
     533                                        WF_Error(wfErr_uniqattspec); /* Duplicate attribute. */
     534                                        break;
     535                                }                       
     536                        }
     537                        LastAttOccurrence[attID] = att_name_start;
     538                        /* The following optimized tests handle the frequently occurring
     539                        case that there are no blanks on either side of the equals sign.
     540                        In many cases, the very first test handles 100% of actual
     541                        attribute-value pairs encountered. */
     542                        if (at_EqualsQuote<C>(cur())) Advance(1);
     543                        else {
     544                                ScanTo(NonWS);
     545                                if (!AtChar<C,'='>(cur())) {
     546                                        Syntax_Error(NT_STag);
     547                                        break;
     548                                }
     549                                Advance(1);
     550                                ScanTo(NonWS);
     551                                if (!AtQuote<C>(cur())) {
     552                                        Syntax_Error(NT_STag);
     553                                        break;
     554                                }
     555                        }
     556                        att_val_start = AbsPos()+1;
     557                        Parse_AttValue();
     558                        att_val_end = AbsPos()-1;
     559                        if (at_xmlns<C>(cur()+att_name_start-AbsPos())) {
     560                                Namespace_action(GetCodeUnitPtr(att_name_start), att_name_end - att_name_start,
     561                                                 GetCodeUnitPtr(att_val_start), att_val_end - att_val_start);
     562                        }
     563                        else {
     564                                AttributeValue_action(GetCodeUnitPtr(att_name_start), att_name_end - att_name_start,
     565                                                 GetCodeUnitPtr(att_val_start), att_val_end - att_val_start);
     566                        }
     567                        /* Now check for end or repeat. Avoid whitespace scan if possible.*/
     568                        if (AtChar<C,'>'>(cur())) {
     569                                Advance(1);
     570                                StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     571                                break;
     572                        }
     573                        else if (at_EmptyElementDelim<C>(cur())) {
     574                                Advance(2);
     575                                EmptyElement_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     576                                break;
     577                        }
     578                        ScanTo(NonWS);
     579                        if (AtChar<C,'>'>(cur())) {
     580                                Advance(1);
     581                                StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     582                                break;
     583                        }
     584                        else if (at_EmptyElementDelim<C>(cur())) {
     585                                Advance(2);
     586                                EmptyElement_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     587                                break;
     588                        }
     589                        else if (AbsPos() == att_val_end + 1) {
     590                                /* No WS following att value */
     591                                Syntax_Error(NT_STag);
     592                                break;
     593                        }
     594                } while (1);
     595        }
     596}
     597
     598template <CodeUnit_Base C>
     599inline void ParsingEngine<C>::text_if_nonnull_action(){
     600        if (AbsPos() > text_or_markup_start) {
     601                Text_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     602                text_or_markup_start = AbsPos();
     603        }
     604}
     605
     606
     607
     608template <CodeUnit_Base C>
     609inline void ParsingEngine<C>::Parse_WF_EndTag(int nameID) {
     610        Advance(2); /* Skip "</". */
     611       
     612        int name_start = AbsPos();
     613       
     614        int endNameID = Parse_Name();  /* Name delimiter: WS, "/" or ">" */
     615        if (nameID != endNameID)
     616                        WF_Error(wfErr_GIMatch);
     617                       
     618        if (AtChar<C,'>'>(cur())) {
     619                Advance(1);
     620                EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     621        }
     622    else {
     623                ScanTo(NonWS);
     624                if (AtChar<C,'>'>(cur())) {
     625                        Advance(1);
     626                        EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     627                }
     628                else Syntax_Error(NT_ETag);
     629    }
     630}
     631/* Parse a valid start or empty element tag. */
     632template <CodeUnit_Base C>
     633inline int ParsingEngine<C>::Parse_WF_StartTag (bool& is_emptyStartTag){
     634        int att_name_start;
     635        int att_val_start;
     636        int att_name_end, att_val_end;
     637        unsigned char quoteCh;
     638        Advance(1);
     639       
     640        int nameID = Parse_Name();
     641       
     642        ElementName_action(GetCodeUnitPtr(text_or_markup_start+1), LengthFrom(text_or_markup_start+1));
     643        /* The following test optimizes the most common case of a
     644        start tag with no attributes.  */
     645        if (AtChar<C,'>'>(cur())) {
     646                Advance(1);
     647                StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     648        }
     649        else {
     650                ScanTo(NonWS);
     651                if (AtChar<C,'>'>(cur())) {
     652                        Advance(1);
     653                        StartTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     654                }
     655                else if (at_EmptyElementDelim<C>(cur())) {
     656                        Advance(2);
     657                        is_emptyStartTag = true;
     658                        EmptyElement_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     659                }
     660                else do {
     661                        /* Must be an attribute-value pair or error. */
     662                        att_name_start = AbsPos();
     663                        int nameID = Parse_Name();
    495664                        att_name_end = AbsPos();
    496665                        int lgth = att_name_end-att_name_start;
     
    541710                        else if (at_EmptyElementDelim<C>(cur())) {
    542711                                Advance(2);
     712                                is_emptyStartTag = true;       
    543713                                EmptyElement_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    544714                                break;
     
    552722                        else if (at_EmptyElementDelim<C>(cur())) {
    553723                                Advance(2);
     724                                is_emptyStartTag = true;
    554725                                EmptyElement_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    555726                                break;
     
    562733                } while (1);
    563734        }
    564 }
    565 
    566 template <CodeUnit_Base C>
    567 inline void ParsingEngine<C>::text_if_nonnull_action(){
    568         if (AbsPos() > text_or_markup_start) {
    569                 Text_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     735        return nameID;
     736}
     737
     738
     739
     740template <CodeUnit_Base C>
     741inline void ParsingEngine<C>::Parse_WF_Element() {
     742        bool is_emptyStartTag = false;
     743        int nameID = Parse_WF_StartTag(is_emptyStartTag);
     744#ifdef DEBUG
     745        printf("Parse_Element: elemID = %d, is_emptyStartTag=%i\n",elemID, is_emptyStartTag);
     746#endif
     747        if (!is_emptyStartTag) {
     748                Parse_WF_Content();
     749                Parse_WF_EndTag(nameID);
     750        }
     751}
     752
     753
     754template <CodeUnit_Base C>
     755inline void ParsingEngine<C>::Parse_WF_Content() {
     756        do {
    570757                text_or_markup_start = AbsPos();
    571         }
    572 }
     758                ScanToMarkupStart(); /* '<', '&', or ']' for ']]>' test */
     759                if (at_ElementTag_Start<C>(cur())) {
     760                        text_if_nonnull_action();
     761                        Parse_WF_Element();
     762                }
     763                else if (at_EndTag_Start<C>(cur())) {
     764                        text_if_nonnull_action();
     765                        return;
     766                }
     767                else if (at_Comment_Start<C>(cur())) {
     768                        text_if_nonnull_action();
     769                        Parse_Comment();
     770                }
     771                else if (at_CharRef_Start<C>(cur())) {
     772                        text_if_nonnull_action();
     773                        Parse_CharRef();
     774                }
     775                else if (AtChar<C,'&'>(cur())) {
     776                        text_if_nonnull_action();
     777                        Parse_EntityRef();
     778                }
     779                else if (at_CDATA_Start<C>(cur())) {
     780                        text_if_nonnull_action();
     781                        Parse_CDATA();
     782                }
     783                else if (at_PI_Start<C>(cur())) {
     784                        text_if_nonnull_action();
     785                        Parse_PI();
     786                }
     787                else if (at_CDATA_End<C>(cur())) {
     788                        text_if_nonnull_action();
     789                        Advance(3);
     790                        Syntax_Error(NT_CharData);
     791                }
     792                else if (at_EOF()) {
     793                        text_if_nonnull_action();
     794                        return;
     795                }
     796                else if (AtChar<C,'<'>(cur())) {
     797                        Syntax_Error(NT_markupdecl);
     798                }
     799                else {
     800                        Advance(1);
     801                        continue;
     802                }
     803        } while (1);
     804}
     805
    573806
    574807
     
    576809inline void ParsingEngine<C>::ParseContent() {
    577810        DocumentStart_action();
     811        vector<int> elemStack;
     812        int elemID;
     813        bool is_emptyStartTag = false;
    578814        do {
    579815                text_or_markup_start = AbsPos();
     
    586822                        text_if_nonnull_action();
    587823                        Parse_StartTag();
     824//                      elemID = Parse_ValidStartTag(is_emptyStartTag);
     825//                      if(!is_emptyStartTag)
     826//                              elemStack.push_back(elemID);
     827//                      else
     828//                              is_emptyStartTag = false;
    588829                }
    589830                else if (at_EndTag_Start<C>(cur())) {
    590831                        text_if_nonnull_action();
    591832                        Parse_EndTag();
     833//                      elemID = Parse_ValidEndTag();
     834//                      if (elemStack.size()<= 0 || elemID != elemStack[elemStack.size()-1])
     835//                              Syntax_Error(NT_ETag);
     836//                      else
     837//                              elemStack.pop_back();
    592838                }
    593839                else if (at_Comment_Start<C>(cur())) {
     
    619865                        text_if_nonnull_action();
    620866                        break;
     867                }
     868                else if (AtChar<C,'<'>(cur())) {
     869                        Syntax_Error(NT_markupdecl);
    621870                }
    622871                else {
     
    644893        requireWS();
    645894        int root_name_start = AbsPos();
    646         ScanTo(NameFollow);
     895        int nameID = Parse_Name();
    647896        char * s = copy_string(GetCodeUnitPtr(root_name_start),AbsPos()-root_name_start);
    648897
     
    675924                Advance(1);   
    676925                int rootID = model_info->GlobalElementTable[s];
    677                 CRE_Seq * rslt = new CRE_Seq;
     926
     927                CRE_Seq * rslt = new CRE_Seq();
    678928                rslt->subCMs.push_back(new CRE_Name(rootID));
    679929                CM_RegExp * cre = new CM_RegExp();
    680                 cre->content_re = rslt;
    681                
     930                cre->content_re = rslt;         
    682931               
    683932                int id_count = cre->content_re->Set_IDs(0);
     
    694943               
    695944                model_info->rootModel = cre;
     945
    696946        }
    697947        else
    698                 Syntax_Error(NT_doctypedecl);
     948                Syntax_Error(NT_doctypedecl);   
    699949}
    700950
     
    8141064
    8151065        Advance(1); /* Skip "%". */
    816         ScanTo(NameFollow);
     1066        int nameID = Parse_Name();
    8171067        if (AtChar<C,';'>(cur())) {
    8181068                Advance(1);
     
    8311081    requireWS();
    8321082    int name_start = AbsPos();
    833         ScanTo(NameFollow);
     1083        int nameID = Parse_Name();
    8341084        int lgth = AbsPos() - name_start;
    8351085        int elemID = model_info->getOrInsertGlobalElement(GetCodeUnitPtr(name_start), lgth);
     1086
    8361087        requireWS();
    8371088        ContentModel * cm;
     
    8401091        Advance(5);
    8411092        cm = new CM_Empty();
    842         model_info->ContentModelData.push_back(cm);
     1093        model_info->ContentModelData[elemID] = cm;
    8431094        }
    8441095    else if (at_ANY<C>(cur())) {
    8451096        Advance(3);
    8461097        cm = new CM_Any();
    847         model_info->ContentModelData.push_back(cm);
     1098        model_info->ContentModelData[elemID] = cm;
    8481099    }
    8491100    else {
     
    8531104                if (at_PCDATA<C>(cur())){
    8541105                        cm = Parse_RemainingMixed();
    855                         model_info->ContentModelData.push_back(cm);
     1106                        model_info->ContentModelData[elemID] = cm;
    8561107                }
    8571108                else{
     
    8731124                        cre -> transition_map = transition_map;
    8741125                       
    875                         model_info->ContentModelData.push_back(cre);
     1126                        model_info->ContentModelData[elemID] = cre;
    8761127                        cm = cre;
    8771128                }                       
     
    9051156                        ScanTo(NonWS);
    9061157                        int name_start = AbsPos();
    907                         ScanTo(NameFollow);
     1158                        int nameID = Parse_Name();
    9081159                        int lgth = AbsPos() - name_start;
    909                         char * s = copy_string(GetCodeUnitPtr(name_start),lgth);
    910                         int elemID = model_info->GlobalElementTable[s];
    911                         if(elemID==0)
    912                                 Validity_Error(vErr_elementvalid);
     1160                        int elemID = model_info->getOrInsertGlobalElement(GetCodeUnitPtr(name_start), lgth);
    9131161                        r->elements[elemID] = ++k;
    9141162                        ScanTo(NonWS);
     
    10001248        else{
    10011249                int name_start = AbsPos();
    1002                 ScanTo(NameFollow);
     1250                int nameID = Parse_Name();
    10031251                int lgth = AbsPos() - name_start;
    1004                 char * s = copy_string(GetCodeUnitPtr(name_start),lgth);
    1005                 int elemID = model_info->GlobalElementTable[s];
    1006                 if(elemID==0)
    1007                         Validity_Error(vErr_elementvalid);
     1252                int elemID = model_info->getOrInsertGlobalElement(GetCodeUnitPtr(name_start), lgth);
    10081253                CRE_Name * r = new CRE_Name(elemID);
    10091254
     
    10391284       
    10401285        name_start = AbsPos();
    1041         ScanTo(NameFollow);
     1286        int nameID = Parse_Name();
    10421287        lgth = AbsPos()-name_start;
    10431288        elemID = model_info->getOrInsertGlobalElement(GetCodeUnitPtr(name_start), lgth);
     
    10501295               
    10511296        name_start = AbsPos();
    1052                 ScanTo(NameFollow);
     1297                int nameID = Parse_Name();
    10531298                lgth = AbsPos()-name_start;
    10541299               
     
    11251370       
    11261371    int name_start = AbsPos();
    1127         ScanTo(NameFollow);
     1372        int nameID = Parse_Name();
    11281373        int     lgth = AbsPos()-name_start;
    11291374       
     
    11411386                ScanTo(NonWS);         
    11421387                name_start = AbsPos();
    1143                 ScanTo(NameFollow);
     1388                int nameID = Parse_Name();
    11441389                lgth = AbsPos()-name_start;
    11451390       
     
    11701415       
    11711416        int     name_start = AbsPos();
    1172         ScanTo(NameFollow);
     1417        int nameID = Parse_Name();
    11731418        int     lgth = AbsPos()-name_start;
    11741419       
     
    11841429                ScanTo(NonWS);         
    11851430                name_start = AbsPos();
    1186                 ScanTo(NameFollow);
     1431                int nameID = Parse_Name();
    11871432                lgth = AbsPos()-name_start;
    11881433       
     
    12561501               
    12571502                name_start = AbsPos();
    1258                 ScanTo(NameFollow);
     1503                int nameID = Parse_Name();
    12591504                lgth = AbsPos()- name_start;
    12601505                s = new char[lgth+1];
     
    12781523        }
    12791524        else {
     1525                Parse_ExternalID(this_info->systemLiteral, this_info->pubidLiteral);
    12801526                this_info->is_external = true;
    1281                 Parse_ExternalID(this_info->systemLiteral, this_info->pubidLiteral);
    12821527                if (this_info->systemLiteral == NULL) Syntax_Error(NT_EntityDecl);
    12831528        }
     
    12861531        else{
    12871532                name_start = AbsPos();
    1288                 ScanTo(NameFollow);
     1533                int nameID = Parse_Name();
    12891534                lgth = AbsPos()- name_start;
    12901535                s = new char[lgth+1];
     
    12921537                s[lgth] = '\0';
    12931538       
    1294                 GEntity_info * this_info = new GEntity_info;
     1539                GEntity_info * this_info = new GEntity_info();
    12951540                int entityID = model_info->GlobalGEntityTable[s];
    12961541                if(entityID==0){       
     
    13051550               
    13061551                if(AtQuote<C>(cur())){
    1307                 Parse_GEntityValue(this_info);
     1552                Parse_GEntityValue(this_info);                 
    13081553                this_info->is_external = false;
    13091554        }
    13101555        else {
     1556                Parse_ExternalID(this_info->systemLiteral, this_info->pubidLiteral);
    13111557                this_info->is_external = true;
    1312                 Parse_ExternalID(this_info->systemLiteral, this_info->pubidLiteral);
    13131558                if (this_info->systemLiteral == NULL) Syntax_Error(NT_EntityDecl);
    13141559                        old_abspos = AbsPos();
     
    13211566                        requireWS();
    13221567                        name_start = AbsPos();
    1323                         ScanTo(NameFollow);
     1568                        int nameID = Parse_Name();
    13241569                        lgth = AbsPos() - name_start;
    13251570                                this_info->NDataName = copy_string(GetCodeUnitPtr(name_start),lgth);
     
    13441589       
    13451590        int name_start = AbsPos();
    1346         ScanTo(NameFollow);
     1591        int nameID = Parse_Name();
    13471592        int     lgth = AbsPos()-name_start;
    13481593       
     
    14291674                        Advance(1);
    14301675                        ScanTo(Quote);
    1431 
    14321676                }
    14331677                else { /* '<' found */
     
    14361680                        ScanTo(Quote);
    14371681                        this_info->is_simple = false;
    1438                 }
    1439                 strcat (replText,copy_string(GetCodeUnitPtr(quot_start),AbsPos()-quot_start));                 
     1682                       
     1683                }
     1684                char * temp = replText;
     1685                replText = cat_string (temp,(char *)GetCodeUnitPtr(quot_start), strlen(temp), AbsPos()-quot_start);
     1686                free(temp);
    14401687        }
    14411688        this_info->ReplacementText = replText;
     
    14471694        Advance(1);
    14481695        int entity_start = AbsPos();
    1449         ScanTo(NameFollow);
     1696        int nameID = Parse_Name();
    14501697        char * s = copy_string(GetCodeUnitPtr(entity_start),AbsPos()-entity_start);
    14511698        if (AtChar<C,';'>(cur()))
     
    14721719        Advance(1);
    14731720        int entity_start = AbsPos();
    1474         ScanTo(NameFollow);
     1721        int nameID = Parse_Name();
    14751722        char * s = copy_string(GetCodeUnitPtr(entity_start),AbsPos()-entity_start);
    14761723        int entityID = model_info->GlobalGEntityTable[s];
     
    15861833}
    15871834
    1588        
     1835template <CodeUnit_Base C>
     1836inline int ParsingEngine<C>::Parse_ValidEndTag() {
     1837        Advance(2); /* Skip "</". */
     1838       
     1839        int name_start = AbsPos();
     1840        int nameID = Parse_Name();  /* Name delimiter: WS, "/" or ">" */
     1841        char * s = copy_string(GetCodeUnitPtr(name_start),AbsPos()-name_start);
     1842        int elemID = model_info->GlobalElementTable[s];
     1843        if(elemID==0)
     1844                        Validity_Error(vErr_elementvalid);
     1845                       
     1846        if (AtChar<C,'>'>(cur())) {
     1847                Advance(1);
     1848                EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     1849        }
     1850    else {
     1851                ScanTo(NonWS);
     1852                if (AtChar<C,'>'>(cur())) {
     1853                        Advance(1);
     1854                        EndTag_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     1855                }
     1856                else Syntax_Error(NT_ETag);
     1857    }
     1858    return elemID;
     1859}
    15891860/* Parse a valid start or empty element tag. */
    15901861template <CodeUnit_Base C>
     
    15971868       
    15981869        int name_start = AbsPos();
    1599         ScanTo(NameFollow);  /* Name delimiter: WS, "/" or ">" */
     1870        int nameID = Parse_Name();  /* Name delimiter: WS, "/" or ">" */
    16001871        char * s = copy_string(GetCodeUnitPtr(name_start),AbsPos()-name_start);
    16011872        int elemID = model_info->GlobalElementTable[s];
     1873        if(elemID==0)
     1874                        Validity_Error(vErr_elementvalid);
    16021875       
    16031876        ElementName_action(GetCodeUnitPtr(text_or_markup_start+1), LengthFrom(text_or_markup_start+1));
     
    16221895                        /* Must be an attribute-value pair or error. */
    16231896                        att_name_start = AbsPos();
    1624                         ScanTo(NameFollow);
     1897                        int nameID = Parse_Name();
    16251898                        att_name_end = AbsPos();
    16261899                        int lgth = att_name_end-att_name_start;
     
    17041977        printf("Parse_ValidElement: elemID = %d, is_emptyStartTag=%i\n",elemID, is_emptyStartTag);
    17051978#endif
    1706         ContentModel * cm = model_info->ContentModelData[elemID-1];
     1979        ContentModel * cm = model_info->ContentModelData[elemID];
    17071980        switch (cm->cm_type) {
    17081981                case cm_Empty:
    17091982                        if (!is_emptyStartTag) {
    17101983                                if (at_EndTag_Start<C>(cur())) {
    1711                                         Parse_EndTag();
     1984                                        if (Parse_ValidEndTag()!=elemID) Validity_Error(vErr_elementvalid);
     1985//                                      Parse_EndTag();
    17121986                                }
    17131987                                else {
     
    17191993                        if (!is_emptyStartTag) {
    17201994                                Parse_AnyContent();
    1721                                 Parse_EndTag();
     1995                                if (Parse_ValidEndTag()!=elemID) Validity_Error(vErr_elementvalid);
    17221996                        }
    17231997                        break;
     
    17251999                        if (!is_emptyStartTag) {
    17262000                                Parse_MixedContent(((CM_Mixed *) cm)->elements);
    1727                                 Parse_EndTag();
     2001                                if (Parse_ValidEndTag()!=elemID) Validity_Error(vErr_elementvalid);
    17282002                        }
    17292003                        break;
     
    17332007                        if (!is_emptyStartTag) {
    17342008                                content_state = Parse_ValidContent(cre);
    1735                                 Parse_EndTag();                        
     2009                                if (Parse_ValidEndTag()!=elemID) Validity_Error(vErr_elementvalid);                     
    17362010                        }
    17372011                        if (cre->transition_map[content_state][0]==0) {
     
    17732047                        break;
    17742048                }
     2049                else if (AtChar<C,'<'>(cur())) {
     2050                        Syntax_Error(NT_markupdecl);
     2051                }
    17752052                else {
    17762053                        Validity_Error(vErr_elementvalid);
     
    18232100                        return;
    18242101                }
     2102                else if (AtChar<C,'<'>(cur())) {
     2103                        Syntax_Error(NT_markupdecl);
     2104                }
    18252105                else {
    18262106                        Advance(1);
     
    18782158                        return;
    18792159                }
     2160                else if (AtChar<C,'<'>(cur())) {
     2161                        Syntax_Error(NT_markupdecl);
     2162                }
    18802163                else {
    18812164                        Advance(1);
     
    18852168}
    18862169
     2170template <CodeUnit_Base C>
     2171inline int ParsingEngine<C>::Parse_Name() {
     2172        int name_pos = AbsPos();
     2173        ScanTo(NameFollow);
     2174        int lgth = AbsPos()-name_pos;
     2175        char * s = copy_string(GetCodeUnitPtr(name_pos),lgth);
     2176        int nameID = model_info->GlobalNameTable[s];
     2177        if(nameID == 0){
     2178                if (entity_Info->version == XML_1_1){
     2179                        if (!is_XML11_UTF8_Name(GetCodeUnitPtr(name_pos),lgth)) Syntax_Error(NT_Name);
     2180                }
     2181                else if (!is_XML10_UTF8_Name(GetCodeUnitPtr(name_pos),lgth)) Syntax_Error(NT_Name);
     2182                model_info->GlobalNameTable[s]=++model_info->globalNameCount;
     2183                nameID = model_info->globalNameCount;
     2184        }
     2185        return nameID;
     2186}
    18872187
    18882188
    18892189template <CodeUnit_Base C>
    18902190inline void ParsingEngine<C>::Parse_DocumentContent() {
     2191#ifdef VALIDATION
    18912192        int final_state = Parse_ValidContent(model_info->rootModel);
    18922193        if (model_info->rootModel->transition_map[final_state][0]==0) {
    18932194                Validity_Error(vErr_elementvalid);
    18942195        }
    1895 }
    1896 
     2196#endif
     2197#ifndef VALIDATION
     2198        Parse_WF_Element();
     2199        ScanTo(NonWS);
     2200        while(at_Comment_Start<C>(cur()) || at_PI_Start<C>(cur()) ){
     2201                if (at_Comment_Start<C>(cur()))
     2202                        Parse_Comment();
     2203                else
     2204                        Parse_PI();
     2205                ScanTo(NonWS);
     2206        }
     2207        if (!at_EOF()) {
     2208                Syntax_Error(NT_document);
     2209        }       
     2210#endif
     2211}
     2212
  • trunk/src/engine.h

    r115 r124  
    1515#include "xml_error.h"
    1616#include "contentmodel.h"
     17#include "symtab.h"
     18
    1719#define min(x,y) ((x) <(y) ?(x) :(y) )
    1820/* A ParsingEngine is the principal class for parsing XML
     
    2830        virtual void ParseContent() = 0;
    2931        virtual void Parse_DocumentContent() = 0;
     32        virtual void Parse_WF_Content() = 0;
     33        virtual bool at_EOF() const = 0;
    3034        virtual void Parse_ExtSubsetDecl() = 0;
    3135        virtual void Parse_Prolog() = 0;
     
    123127        void Parse_DocumentContent();
    124128       
     129        void Parse_WF_Element();
     130        void Parse_WF_Content();
     131        int Parse_WF_StartTag(bool& is_empty);
     132        void Parse_WF_EndTag(int nameID);       
     133
     134
    125135        int Parse_ValidElement();
    126136        int Parse_ValidContent(CM_RegExp * cre);
     
    129139       
    130140        int Parse_ValidStartTag(bool& is_empty);
    131                
     141        int Parse_ValidEndTag();       
     142       
     143        int Parse_Name();
     144       
    132145        /*Parsing routine for external entities*/
    133146        void Parse_ExtSubsetDecl ();
  • trunk/src/xml_error.c

    r121 r124  
    1313                exit(-1);
    1414        }
    15         else fprintf(stderr, "Violation of validity constraint: %s\n", XML_Constraint_Strings[errCode]);
     15        else {
     16#ifdef VALIDATION
     17                fprintf(stderr, "Violation of validity constraint: %s\n", XML_Constraint_Strings[errCode]);
     18                exit(-1);
     19#endif
     20        }
    1621}
    1722
  • trunk/src/xmlmodel.h

    r115 r124  
    178178        hash_map<const char *, int, hash<const char *>, eqstr > GlobalGEntityTable;
    179179        hash_map<const char *, int, hash<const char *>, eqstr > GlobalPEntityTable;
     180        hash_map<const char *, int, hash<const char *>, eqstr > GlobalNameTable;
    180181        int globalElementCount;
    181182        int globalAttributeCount;
     
    183184        int globalGEntityCount;
    184185        int globalPEntityCount;
    185        
     186        int globalNameCount;
    186187    /* For each element, we have an ElementAttributeModel */
    187188        vector<vector<ATT_info *> > ElementAttributeData;
     
    191192        // of a single occurrence of the element named in the DOCTYPE declaration.
    192193        CM_RegExp * rootModel;
    193         vector<ContentModel *> ContentModelData;
     194//      vector<ContentModel *> ContentModelData;
     195        hash_map<int, ContentModel * > ContentModelData;
    194196       
    195197       
Note: See TracChangeset for help on using the changeset viewer.