Changeset 106 for trunk/src


Ignore:
Timestamp:
Apr 22, 2008, 2:17:50 PM (11 years ago)
Author:
lindanl
Message:

Content Models.

Location:
trunk/src
Files:
2 added
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/engine.c

    r102 r106  
    1212#include "bitlex.h"
    1313#include "errcodes.h"
     14#include "contentmodel.h"
     15#include "contentmodel.c"
    1416
    1517#include <assert.h>
     
    562564}
    563565
     566
    564567template <CodeUnit_Base C>
    565568inline void ParsingEngine<C>::ParseContent() {
     
    762765        int elemID = model_info->getOrInsertGlobalElement(GetCodeUnitPtr(name_start), lgth);
    763766        requireWS();
    764        
     767        ContentModel * cm;
    765768        /* Start parsing "contentspec"*/
    766         if (at_EMPTY<C>(cur()))
     769        if (at_EMPTY<C>(cur())) {
    767770        Advance(5);
    768     else if (at_ANY<C>(cur()))
     771        cm = new CM_Empty();
     772        }
     773    else if (at_ANY<C>(cur())) {
    769774        Advance(3);
     775        cm = new CM_Any();
     776    }
    770777    else {
    771778        if (AtChar<C,'('>(cur()))
     
    773780                ScanTo(NonWS);
    774781                if (at_PCDATA<C>(cur()))
    775                         Parse_RemainingMixed();
    776                 else
    777                         Parse_RemainingChildren();
     782                        cm = Parse_RemainingMixed();
     783                else{
     784
     785                        CM_RegExp * cre = new CM_RegExp;
     786                        cre->content_re = Parse_RemainingChildren();
     787                       
     788                        int id_count = cre->content_re->Set_IDs(0);
     789                        cre->content_re->Set_First_Map();               
     790                        symbol_set_t * transition_map = new symbol_set_t[id_count+1];
     791                        cre->content_re->follow_map[0] = id_count+1;
     792                       
     793                        cre->content_re->Set_Follow_Map(transition_map);                       
     794                        cre -> transition_map = transition_map;
     795                       
     796                        model_info->ContentModelData.push_back(cre);
     797                        cm = cre;
     798                }
     799                       
    778800    }
    779801               
    780802        if (AtChar<C,'>'>(cur())) {
    781                 Advance(1);
    782                 Elementdecl_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
     803
     804                Advance(1);
     805                       
     806
    783807        }
    784808        else
     
    786810}
    787811template <CodeUnit_Base C>
    788 inline void ParsingEngine<C>::Parse_RemainingMixed (){
    789        
     812inline ContentModel * ParsingEngine<C>::Parse_RemainingMixed (){
     813        CM_Mixed * r = new CM_Mixed();
    790814        Advance(7);  /* Skip "#PCDATA". */
    791815   
    792816    if (AtChar<C,')'>(cur())){
    793         if (AtChar<C,'*'>(cur()))
     817        if (AtChar<C,'*'>(cur())) {
    794818                Advance(2);
    795                 else
     819                return r;  /* Or ??? new CM_Star(r);*/
     820        }
     821                else {
    796822                        Advance(1);
     823                        return r;
     824                }
    797825    }
    798826    else{
    799827        ScanTo(NonWS);
     828        int k = 0;
    800829        while(!at_Para_star<C>(cur())){
     830               
    801831                if (AtChar<C,'|'>(cur())){
    802832                                Advance(1);
    803833                                ScanTo(NonWS);
     834                                int name_start = AbsPos();
    804835                                ScanTo(NameFollow);
     836                                int lgth = AbsPos() - name_start;
     837                                char * s = copy_string(GetCodeUnitPtr(name_start),lgth);
     838                                int elemID = model_info->GlobalElementTable[s];
     839                                if(elemID==0)
     840                                        Validity_Error(vErr_elementvalid);
     841//                              r->first_map[elemID] = ++k;
    805842                                ScanTo(NonWS);
    806843                }
    807844        }
    808845        Advance(2);
     846//      return new CM_Star(r);
    809847    }
    810848}
     
    812850
    813851template <CodeUnit_Base C>
    814 inline void ParsingEngine<C>::Parse_RemainingChildren (){
    815         Parse_Cp();
     852inline Content_RE * ParsingEngine<C>::Parse_RemainingChildren (){
     853        Content_RE * c1 = Parse_Cp();
     854        Content_RE * r;
    816855        ScanTo(NonWS);
    817856        if(AtChar<C,'|'>(cur())){
     857                CRE_Choice * rslt = new CRE_Choice;
     858                rslt->subCMs.push_back(c1);
    818859                Advance(1);
    819860                ScanTo(NonWS);
    820                 Parse_Cp();
     861                rslt->subCMs.push_back(Parse_Cp());
    821862                ScanTo(NonWS);
    822863                while(!AtChar<C,')'>(cur())){
     
    824865                                Advance(1);
    825866                        ScanTo(NonWS);
    826                         Parse_Cp();
     867                        rslt->subCMs.push_back(Parse_Cp());
    827868                        ScanTo(NonWS);
    828869                }
    829870                Advance(1);
     871                rslt->Compile();
     872                r = rslt;
    830873        }
    831874        else if(AtChar<C,','>(cur())){
     875                CRE_Seq * rslt = new CRE_Seq;
     876                rslt->subCMs.push_back(c1);
    832877                Advance(1);
    833878                ScanTo(NonWS);
    834                 Parse_Cp();
     879                rslt->subCMs.push_back(Parse_Cp());
    835880                ScanTo(NonWS);
    836881                while(!AtChar<C,')'>(cur())){
     
    838883                                Advance(1);
    839884                        ScanTo(NonWS);
    840                         Parse_Cp();
     885                        rslt->subCMs.push_back(Parse_Cp());
    841886                        ScanTo(NonWS);
    842887                }
    843888                Advance(1);
     889                rslt->Compile();
     890                r = rslt;
    844891        }       
    845892        else if(AtChar<C,')'>(cur())){
     
    849896                Syntax_Error(NT_children);
    850897               
    851         if (AtChar<C,'?'>(cur())||AtChar<C,'*'>(cur())||AtChar<C,'+'>(cur()))
    852                 Advance(1);
    853 }
    854 
    855 template <CodeUnit_Base C>
    856 inline void ParsingEngine<C>::Parse_Cp (){
     898        if (AtChar<C,'?'>(cur())) {
     899                Advance(1);
     900                r = new CRE_Opt(r);
     901        }
     902        else if (AtChar<C,'*'>(cur())) {
     903                Advance(1);
     904                r = new CRE_Star(r);
     905        }
     906        else if (AtChar<C,'+'>(cur())) {
     907                Advance(1);
     908                r = new CRE_Plus(r);
     909        }
     910
     911        return r;
     912}
     913
     914template <CodeUnit_Base C>
     915inline Content_RE * ParsingEngine<C>::Parse_Cp (){
    857916        if (AtChar<C,'('>(cur())){
    858917                Advance(1);
     
    861920        }
    862921        else{
     922                int name_start = AbsPos();
    863923                ScanTo(NameFollow);
    864                 if (AtChar<C,'?'>(cur())||AtChar<C,'*'>(cur())||AtChar<C,'+'>(cur()))
     924                int lgth = AbsPos() - name_start;
     925                char * s = copy_string(GetCodeUnitPtr(name_start),lgth);
     926                int elemID = model_info->GlobalElementTable[s];
     927                if(elemID==0)
     928                        Validity_Error(vErr_elementvalid);
     929                CRE_Name * r = new CRE_Name(elemID);
     930
     931                if (AtChar<C,'?'>(cur())) {
    865932                        Advance(1);
     933                        return new CRE_Opt(r);
     934                }
     935                else if (AtChar<C,'*'>(cur())) {
     936                        Advance(1);
     937                        return new CRE_Star(r);
     938                }
     939                else if (AtChar<C,'+'>(cur())) {
     940                        Advance(1);
     941                        return new CRE_Plus(r);
     942                }
     943                else return r;
    866944        }
    867945}
     
    14051483                WF_Error(wfErr_wf_entdeclared);
    14061484        else
    1407                 return model_info->GEntityData[entityID-1]->ReplacementText;
    1408        
     1485                return model_info->GEntityData[entityID-1]->ReplacementText;   
    14091486       
    14101487}
  • trunk/src/engine.h

    r100 r106  
    1414#include "bitlex.h"
    1515#include "errcodes.h"
     16#include "contentmodel.h"
    1617#define min(x,y) ((x) <(y) ?(x) :(y) )
    1718/* A ParsingEngine is the principal class for parsing XML
     
    102103        void Parse_PEReference ();
    103104        void Parse_Elementdecl ();
    104         void Parse_RemainingMixed ();
    105         void Parse_RemainingChildren ();
    106         void Parse_Cp();
     105        ContentModel * Parse_RemainingMixed ();
     106        Content_RE * Parse_RemainingChildren ();
     107        Content_RE * Parse_Cp();
    107108        void Parse_AttlistDecl ();
    108109        void Parse_Notation (ATT_info * this_info);
     
    118119        char * Replace_CharRef();
    119120        void Parse_Prolog();
     121               
    120122               
    121123        /*Parsing routine for external entities*/
     
    184186        void Doctype_action(unsigned char * item, int lgth);
    185187        void PEReference_action(unsigned char * item, int lgth);
    186         void Elementdecl_action(unsigned char * item, int lgth);
    187188        void AttlistDecl_action(unsigned char * item, int lgth);
    188189        void Entitydecl_action(unsigned char * entity_name, int entity_name_lgth, unsigned char * item, int lgth);
  • trunk/src/xmlmodel.h

    r102 r106  
    3030using namespace std;
    3131
     32#include "contentmodel.h"
    3233enum XML_version {XML_1_0, XML_1_1, no_XML_version_value};
    3334/* Documents may be encoded in accord with either XML 1.0 or XML 1.1,
     
    177178        int getOrInsertGlobalElement(unsigned char * elem_name, int lgth);
    178179        int getOrInsertGlobalAttName(unsigned char * att_name, int lgth);
     180        vector<ContentModel *> ContentModelData;
     181       
    179182       
    180183        vector<GEntity_info *> GEntityData;
Note: See TracChangeset for help on using the changeset viewer.