Changeset 78 for trunk/src


Ignore:
Timestamp:
Mar 28, 2008, 1:21:54 PM (11 years ago)
Author:
lindanl
Message:

DTD parsing.

Location:
trunk/src
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/bytelex.h

    r72 r78  
    235235}
    236236
    237 
     237template<CodeUnit_Base C>
     238inline bool at_DOCTYPE_start(unsigned char x8data[]) {
     239        return s8int64(x8data) == c8int64<C, '<', '!','D', 'O', 'C', 'T', 'Y', 'P'>::value & AtChar<C,'E'>(&x8data[8]);
     240}
     241
     242template<CodeUnit_Base C>
     243inline bool at_SYSTEM(unsigned char x8data[]) {
     244        return s6int64(x8data) == c6int64<C, 'S', 'Y', 'S', 'T', 'E', 'M'>::value;
     245}
     246
     247template<CodeUnit_Base C>
     248inline bool at_PUBLIC(unsigned char x8data[]) {
     249        return s6int64(x8data) == c6int64<C, 'P', 'U', 'B', 'L', 'I', 'C'>::value;
     250}
     251
     252template<CodeUnit_Base C>
     253inline bool at_ELEMENT(unsigned char x8data[]) {
     254        return s7int64(x8data) == c7int64<C, 'E', 'L', 'E', 'M', 'E', 'N', 'T'>::value;
     255}
     256
     257template<CodeUnit_Base C>
     258inline bool at_ATTLIST(unsigned char x8data[]) {
     259        return s7int64(x8data) == c7int64<C, 'A', 'T', 'T', 'L', 'I', 'S', 'T'>::value;
     260}
     261
     262template<CodeUnit_Base C>
     263inline bool at_ENTITY(unsigned char x8data[]) {
     264        return s6int64(x8data) == c6int64<C, 'E', 'N', 'T', 'I', 'T', 'Y'>::value;
     265}
     266
     267template<CodeUnit_Base C>
     268inline bool at_NOTATION(unsigned char x8data[]) {
     269        return s8int64(x8data) == c8int64<C, 'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N'>::value;
     270}
     271
     272template<CodeUnit_Base C>
     273inline bool at_EMPTY(unsigned char x8data[]) {
     274        return s5int64(x8data) == c5int64<C, 'E', 'M', 'P', 'T', 'Y'>::value;
     275}
     276
     277template<CodeUnit_Base C>
     278inline bool at_PCDATA(unsigned char x8data[]) {
     279        return s7int64(x8data) == c7int64<C, '#', 'P', 'C', 'D', 'A', 'T', 'A'>::value;
     280}
     281
     282template<CodeUnit_Base C>
     283inline bool at_Para_star(unsigned char x8data[]) {
     284        return s2int16(x8data) == c2int16<C, ')', '*'>::value;
     285}
     286
     287template<CodeUnit_Base C>
     288inline bool at_CDATA(unsigned char x8data[]) {
     289        return s5int64(x8data) == c5int64<C, 'C', 'D', 'A', 'T', 'A'>::value;
     290}
     291
     292template<CodeUnit_Base C>
     293inline bool at_ID(unsigned char x8data[]) {
     294        return s2int16(x8data) == c2int16<C, 'I', 'D'>::value;
     295}
     296
     297template<CodeUnit_Base C>
     298inline bool at_IDREF(unsigned char x8data[]) {
     299        return s5int64(x8data) == c5int64<C, 'I', 'D', 'R', 'E', 'F'>::value;
     300}
     301
     302template<CodeUnit_Base C>
     303inline bool at_IDREFS(unsigned char x8data[]) {
     304        return s6int64(x8data) == c6int64<C, 'I', 'D', 'R', 'E', 'F', 'S'>::value;
     305}
     306
     307template<CodeUnit_Base C>
     308inline bool at_ENTITIES(unsigned char x8data[]) {
     309        return s8int64(x8data) == c8int64<C, 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S'>::value;
     310}
     311
     312template<CodeUnit_Base C>
     313inline bool at_NMTOKEN(unsigned char x8data[]) {
     314        return s7int64(x8data) == c7int64<C, 'N', 'M', 'T', 'O', 'K', 'E', 'N'>::value;
     315}
     316
     317template<CodeUnit_Base C>
     318inline bool at_NMTOKENS(unsigned char x8data[]) {
     319        return s8int64(x8data) == c8int64<C, 'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S'>::value;
     320}
     321
     322template<CodeUnit_Base C>
     323inline bool at_REQUIRED(unsigned char x8data[]) {
     324        return s8int64(x8data) == c8int64<C, '#', 'R', 'E', 'Q', 'U', 'I', 'R', 'E'>::value
     325          & AtChar<C,'D'>(&x8data[8]);
     326}
     327
     328template<CodeUnit_Base C>
     329inline bool at_IMPLIED(unsigned char x8data[]) {
     330        return s8int64(x8data) == c8int64<C, '#', 'I', 'M', 'P', 'L', 'I', 'E', 'D'>::value;
     331}
     332
     333template<CodeUnit_Base C>
     334inline bool at_FIXED(unsigned char x8data[]) {
     335        return s6int64(x8data) == c6int64<C, '#', 'F', 'I', 'X', 'E', 'D'>::value;
     336}
     337
     338template<CodeUnit_Base C>
     339inline bool at_ANY(unsigned char x8data[]) {
     340        return s3int32(x8data) == c3int32<C, 'A', 'N', 'Y'>::value;
     341}
    238342
    239343#endif
  • trunk/src/engine.c

    r73 r78  
    11/*  engine.c - Parabix XML parsing engine.
    2     Copyright (c) 2007, 2008, Robert D. Cameron.
     2    Copyright (c) 2007, 2008, Robert D. Cameron and Dan Lin.
    33    Licensed to the public under the Open Software License 3.0.
    44    Licensed to International Characters, Inc., under the Academic
     
    8585        int content_start = decl_parser->ReadXMLInfo(model_info);
    8686
    87         bitplex = new Bitplex;
     87    bitplex = new Bitplex;
    8888        buf = (LexicalStreamSet *) simd_new(sizeof(LexicalStreamSet)/PACKSIZE);
    8989
     
    491491}
    492492
     493
     494template <CodeUnit_Base C>
     495inline void ParsingEngine<C>::Parse_DocType (){
     496
     497        int old_abspos, start_pos;
     498        ScanTo(NonWS);
     499        start_pos = AbsPos();
     500       
     501        if (at_DOCTYPE_start<C>(cur()))
     502        Advance(9);
     503        else{
     504//              printf("No Document definition!\n");
     505                return;
     506        }
     507        requireWS();
     508       
     509        ScanTo(NameFollow);
     510       
     511        old_abspos = AbsPos(); 
     512    ScanTo(NonWS);
     513    if(at_SYSTEM<C>(cur())||at_PUBLIC<C>(cur())){
     514        if(old_abspos == AbsPos())
     515                Error_action(start_pos, AbsPos());
     516        Parse_ExternalID();
     517    }
     518   
     519    ScanTo(NonWS);     
     520
     521        if (AtChar<C,'['>(cur())){
     522                Advance(1);
     523                Parse_IntSubset();
     524                if (AtChar<C,']'>(cur()))
     525                        Advance(1);
     526                else
     527                        Error_action(start_pos, AbsPos());
     528                ScanTo(NonWS);
     529        }
     530       
     531        if (AtChar<C,'>'>(cur())){
     532                Advance(1);   
     533                Doctype_action(start_pos, AbsPos());
     534        }
     535}
     536
     537template <CodeUnit_Base C>
     538inline void ParsingEngine<C>::Parse_ExternalID (){
     539
     540        if(at_SYSTEM<C>(cur())){
     541                Advance(6);
     542                requireWS();
     543                Parse_MatchedQuote (); /*  SystemLiteral */
     544        }
     545        else if (at_PUBLIC<C>(cur())){
     546                Advance(6);
     547                requireWS();
     548                Parse_MatchedQuote ();/*  PubidLiteral */
     549                requireWS();
     550                Parse_MatchedQuote ();/*  SystemLiteral */
     551        }
     552        else
     553                Error_action(text_or_markup_start, AbsPos());
     554}
     555
     556template <CodeUnit_Base C>
     557inline void ParsingEngine<C>::Parse_MatchedQuote (){
     558        unsigned char quoteCh;
     559        if(AtQuote<C>(cur())){
     560                quoteCh = cur()[0];
     561                Advance(1);
     562        }
     563        ScanTo(Quote);                 
     564        while (cur()[0] != quoteCh){
     565                Advance(1);
     566                ScanTo(Quote);
     567        }
     568        Advance(1);
     569}
     570
     571template <CodeUnit_Base C>
     572inline void ParsingEngine<C>::Parse_IntSubset (){
     573       
     574        while(1){
     575                ScanTo(NonWS); 
     576                text_or_markup_start = AbsPos();
     577                if (AtChar<C,'%'>(cur()))
     578                        Parse_PEReference();   
     579                else if (AtChar<C,'<'>(cur())){
     580                        Advance(1);
     581
     582                        if (AtChar<C,'?'>(cur())){
     583                                Parse_PI();
     584                        }
     585                        else if(AtChar<C,'!'>(cur())){
     586                                Advance(1);
     587                                if(at_DoubleHyphen<C>(cur()))
     588                                        Parse_Comment();
     589                                else if(at_ELEMENT<C>(cur()))
     590                                        Parse_Elementdecl();
     591                                else if(at_ATTLIST<C>(cur()))
     592                                        Parse_AttlistDecl();
     593                                else if(at_ENTITY<C>(cur()))
     594                                        Parse_Entitydecl();
     595                                else if(at_NOTATION<C>(cur()))
     596                                        Parse_Notationdecl();                   
     597                                       
     598                        }
     599                        else
     600                                Error_action(text_or_markup_start, AbsPos());
     601                }
     602                else if (AtChar<C,']'>(cur())){
     603                        break;
     604                }
     605                else
     606                        Error_action(text_or_markup_start, AbsPos());
     607        }
     608}
     609
     610
     611template <CodeUnit_Base C>
     612inline void ParsingEngine<C>::Parse_PEReference (){
     613
     614        Advance(1); /* Skip "%". */
     615        ScanTo(NameFollow);
     616        if (AtChar<C,';'>(cur())) {
     617                Advance(1);
     618                PEReference_action(text_or_markup_start, AbsPos());
     619        }
     620        else
     621                Error_action(text_or_markup_start, AbsPos());
     622}
     623
     624
     625template <CodeUnit_Base C>
     626inline void ParsingEngine<C>::Parse_Elementdecl (){
     627
     628        Advance(7); /* Skip "<!ELEMENT". */
     629
     630    requireWS();
     631        ScanTo(NameFollow);
     632        requireWS();
     633       
     634        /* Start parsing "contentspec"*/
     635        if (at_EMPTY<C>(cur()))
     636        Advance(5);
     637    else if (at_ANY<C>(cur()))
     638        Advance(3);
     639    else {
     640        if (AtChar<C,'('>(cur()))
     641                        Advance(1);
     642                ScanTo(NonWS);
     643                if (at_PCDATA<C>(cur()))
     644                        Parse_RemainedMixed();
     645                else
     646                        Parse_RemainedChildren();
     647    }
     648               
     649        if (AtChar<C,'>'>(cur())) {
     650                Advance(1);
     651                Elementdecl_action(text_or_markup_start, AbsPos());
     652        }
     653        else
     654                Error_action(text_or_markup_start, AbsPos());
     655}
     656template <CodeUnit_Base C>
     657inline void ParsingEngine<C>::Parse_RemainedMixed (){
     658       
     659        Advance(7);  /* Skip "#PCDATA". */
     660   
     661    if (AtChar<C,')'>(cur())){
     662        if (AtChar<C,'*'>(cur()))
     663                Advance(2);
     664                else
     665                        Advance(1);
     666    }
     667    else{
     668        ScanTo(NonWS);
     669        while(!at_Para_star<C>(cur())){
     670                if (AtChar<C,'|'>(cur())){
     671                                Advance(1);
     672                                ScanTo(NonWS);
     673                                ScanTo(NameFollow);
     674                                ScanTo(NonWS);
     675                }
     676        }
     677        Advance(2);
     678    }
     679}
     680
     681
     682template <CodeUnit_Base C>
     683inline void ParsingEngine<C>::Parse_RemainedChildren (){
     684        Parse_Cp();
     685        ScanTo(NonWS);
     686        if(AtChar<C,'|'>(cur())){
     687                Advance(1);
     688                ScanTo(NonWS);
     689                Parse_Cp();
     690                ScanTo(NonWS);
     691                while(!AtChar<C,')'>(cur())){
     692                        if(AtChar<C,'|'>(cur()))
     693                                Advance(1);
     694                        ScanTo(NonWS);
     695                        Parse_Cp();
     696                        ScanTo(NonWS);
     697                }
     698                Advance(1);
     699        }
     700        else if(AtChar<C,','>(cur())){
     701                Advance(1);
     702                ScanTo(NonWS);
     703                Parse_Cp();
     704                ScanTo(NonWS);
     705                while(!AtChar<C,')'>(cur())){
     706                        if(AtChar<C,','>(cur()))
     707                                Advance(1);
     708                        ScanTo(NonWS);
     709                        Parse_Cp();
     710                        ScanTo(NonWS);
     711                }
     712                Advance(1);
     713        }       
     714        else if(AtChar<C,')'>(cur())){
     715                Advance(1);
     716        }
     717        else
     718                Error_action(text_or_markup_start, AbsPos());
     719               
     720        if (AtChar<C,'?'>(cur())||AtChar<C,'*'>(cur())||AtChar<C,'+'>(cur()))
     721                Advance(1);
     722}
     723
     724template <CodeUnit_Base C>
     725inline void ParsingEngine<C>::Parse_Cp (){
     726        if (AtChar<C,'('>(cur())){
     727                Advance(1);
     728                ScanTo(NonWS);
     729                Parse_RemainedChildren();
     730        }
     731        else{
     732                ScanTo(NameFollow);
     733                if (AtChar<C,'?'>(cur())||AtChar<C,'*'>(cur())||AtChar<C,'+'>(cur()))
     734                        Advance(1);
     735        }
     736}
     737
     738template <CodeUnit_Base C>
     739inline void ParsingEngine<C>::Parse_AttlistDecl (){
     740       
     741        int old_abspos;
     742        Advance(7); /* Skip "ATTLIST. */
     743        requireWS();
     744        ScanTo(NameFollow);
     745       
     746        old_abspos = AbsPos();
     747        ScanTo(NonWS);
     748        while(!AtChar<C,'>'>(cur())) {
     749                if(old_abspos == AbsPos())
     750                Error_action(text_or_markup_start, AbsPos());
     751        ScanTo(NameFollow);
     752        requireWS();
     753        if (at_CDATA<C>(cur()))
     754                Advance(5);
     755        else if(at_ID<C>(cur()))
     756                Advance(2);
     757        else if(at_IDREF<C>(cur()))
     758                Advance(5);
     759        else if(at_IDREFS<C>(cur()))
     760                Advance(6);
     761        else if(at_ENTITY<C>(cur()))
     762                Advance(6);
     763        else if(at_ENTITIES<C>(cur()))
     764                Advance(8);
     765        else if(at_NMTOKEN<C>(cur()))
     766                Advance(7);
     767        else if(at_NMTOKENS<C>(cur()))
     768                Advance(8);
     769        else if(at_NOTATION<C>(cur())){ /* NotationType = 'NOTATION' S Enumeration
     770                                                                         when Nmtoken = Name */
     771                Advance(8);
     772                        requireWS();
     773                Parse_Enumeration();
     774        }
     775        else if(AtChar<C,'('>(cur()))
     776                Parse_Enumeration();
     777        else
     778                Error_action(text_or_markup_start, AbsPos());
     779        requireWS();
     780        Parse_DefaultDecl();
     781        old_abspos = AbsPos();
     782                ScanTo(NonWS);
     783        }
     784        Advance(1);
     785        AttlistDecl_action(text_or_markup_start, AbsPos());
     786}
     787
     788template <CodeUnit_Base C>
     789inline void ParsingEngine<C>::Parse_Enumeration (){
     790
     791        if(AtChar<C,'('>(cur()))
     792                Advance(1);
     793        else
     794                Error_action(text_or_markup_start, AbsPos());
     795        ScanTo(NonWS);
     796        ScanTo(NameFollow);
     797        ScanTo(NonWS);
     798        while(AtChar<C,'|'>(cur())){
     799                Advance(1);
     800                ScanTo(NameFollow);
     801                ScanTo(NonWS);
     802        }
     803        if (AtChar<C,')'>(cur()))
     804                Advance(1);
     805        else
     806                Error_action(text_or_markup_start, AbsPos());
     807}
     808
     809template <CodeUnit_Base C>
     810inline void ParsingEngine<C>::Parse_DefaultDecl (){
     811        if(at_REQUIRED<C>(cur()))
     812                Advance(9);
     813        else if(at_IMPLIED<C>(cur()))
     814                Advance(8);
     815        else if(at_FIXED<C>(cur())){
     816                Advance(6);
     817                requireWS();
     818        }
     819        else if(AtQuote<C>(cur())){
     820                Parse_AttValue();
     821        }
     822        else
     823                Error_action(text_or_markup_start, AbsPos());
     824}
     825
     826template <CodeUnit_Base C>
     827inline void ParsingEngine<C>::Parse_Entitydecl (){
     828       
     829        int old_abspos;
     830        Advance(6); /* Skip "ENTITY. */
     831        requireWS();
     832       
     833        if (AtChar<C,'%'>(cur())){
     834                Advance(1);
     835                requireWS();
     836                ScanTo(NameFollow);
     837                requireWS();
     838                if(at_SYSTEM<C>(cur())||at_PUBLIC<C>(cur())){
     839                Parse_ExternalID();             
     840        }
     841        else if(AtQuote<C>(cur())){
     842                Parse_AttValue(); /* Not parse PEReference*/
     843        }
     844        else
     845                Error_action(text_or_markup_start, AbsPos());
     846        }
     847        else{
     848                ScanTo(NameFollow);
     849                requireWS();
     850               
     851                if(at_SYSTEM<C>(cur())||at_PUBLIC<C>(cur())){
     852                Parse_ExternalID();
     853                ScanTo(NonWS);
     854                if(at_NOTATION<C>(cur())){
     855                        if(old_abspos == AbsPos())
     856                                Error_action(text_or_markup_start, AbsPos());
     857                        else
     858                                Advance(5);
     859                        requireWS();
     860                        ScanTo(NameFollow);
     861                }
     862        }
     863        else if(AtQuote<C>(cur())){
     864                Parse_AttValue(); /* Not parse PEReference*/
     865        }
     866        else
     867                Error_action(text_or_markup_start, AbsPos());
     868        }
     869        ScanTo(NonWS);
     870        if (AtChar<C,'>'>(cur())){
     871                Advance(1);
     872                Entitydecl_action(text_or_markup_start, AbsPos());
     873        }
     874        else
     875                Error_action(text_or_markup_start, AbsPos());
     876}
     877
     878template <CodeUnit_Base C>
     879inline void ParsingEngine<C>::Parse_Notationdecl (){
     880       
     881        int old_abspos;
     882        Advance(8); /* Skip "NOTATION. */
     883        requireWS();
     884        ScanTo(NameFollow);
     885        requireWS();
     886        if(at_SYSTEM<C>(cur())){
     887                Advance(6);
     888                requireWS();
     889                Parse_MatchedQuote (); /*  SystemLiteral */
     890        }
     891        else if (at_PUBLIC<C>(cur())){
     892                Advance(6);
     893                requireWS();
     894                Parse_MatchedQuote (); /*  PubidLiteral */
     895                ScanTo(NonWS);
     896                if (!AtChar<C,'>'>(cur())){
     897                        if (old_abspos == AbsPos())
     898                                Error_action(text_or_markup_start, AbsPos());
     899                        Parse_MatchedQuote (); /*  SystemLiteral */
     900                }
     901        }
     902        else
     903                Error_action(text_or_markup_start, AbsPos());
     904        ScanTo(NonWS);
     905        if (AtChar<C,'>'>(cur())) {
     906                Advance(1);
     907                Notationdecl_action(text_or_markup_start, AbsPos());
     908        }
     909        else
     910                Error_action(text_or_markup_start, AbsPos());
     911}
     912
     913template <CodeUnit_Base C>
     914inline void ParsingEngine<C>::requireWS(){
     915       
     916    int old_abspos = AbsPos(); 
     917    ScanTo(NonWS);
     918    if(old_abspos == AbsPos())
     919        Error_action(text_or_markup_start, AbsPos());
     920}
     921
     922template <CodeUnit_Base C>
     923inline void ParsingEngine<C>::Parse_AttValue(){
     924       
     925        int     quoteCh = cur()[0];
     926        Advance(1); /* Skip " or ' */
     927
     928        ScanTo(Quote);                 
     929        while (cur()[0] != quoteCh){
     930                if (AtChar<C,'&'>(cur())){
     931                        Parse_Reference();
     932                        ScanTo(Quote);
     933                }
     934                else if (AtQuote<C>(cur())) {
     935                        Advance(1);
     936                        ScanTo(Quote);
     937                }
     938                else /* if (AtChar<C,'<'>(cur())) */
     939                        Error_action(text_or_markup_start, AbsPos());
     940        }
     941        Advance(1);
     942}
     943
     944template <CodeUnit_Base C>
     945inline void ParsingEngine<C>::Parse_Prolog(){
     946        ScanTo(NonWS);
     947        int old_pos = AbsPos();
     948        while (!at_DOCTYPE_start<C>(cur())) {
     949                if (at_Comment_Start<C>(cur()))
     950                        Parse_Comment();
     951                else if (at_PI_Start<C>(cur()))
     952                                Parse_PI();
     953                else{
     954                        Prolog_action(old_pos, AbsPos());
     955                        return;
     956                }
     957                ScanTo(NonWS);
     958        }
     959        Parse_DocType();
     960        ScanTo(NonWS);
     961        while(at_Comment_Start<C>(cur()) || at_PI_Start<C>(cur()) ){
     962                if (at_Comment_Start<C>(cur()))
     963                        Parse_Comment();
     964                else
     965                        Parse_PI();
     966                ScanTo(NonWS);
     967        }
     968        Prolog_action(old_pos, AbsPos());
     969}
     970
     971
     972
  • trunk/src/engine.h

    r73 r78  
    11/*  engine.h - parabix parsing engine
    2     Copyright (c) 2007, 2008 Robert D. Cameron
     2    Copyright (c) 2007, 2008 Robert D. Cameron and Dan Lin
    33    Licensed to the public under the Open Software License 3.0.
    44    Licensed to International Characters, Inc., under the Academic
     
    2323        static Parser_Interface * ParserFactory(char * filename);
    2424        virtual void ParseContent() = 0;
     25        virtual void Parse_DocType() = 0;
     26        virtual void Parse_Prolog() = 0;
    2527        unsigned char * GetCodeUnitPtr(int pos);
    2628        bool has_ByteOrderMark();
     
    7779        void Parse_PI ();
    7880        void Parse_Reference ();       
     81       
     82        /* Parsing routine for Document Type*/
     83        void Parse_DocType ();
     84        void Parse_ExternalID ();
     85        void Parse_MatchedQuote ();
     86        void Parse_IntSubset ();
     87        void Parse_PEReference ();
     88        void Parse_Elementdecl ();
     89        void Parse_RemainedMixed ();
     90        void Parse_RemainedChildren ();
     91        void Parse_Cp();
     92        void Parse_AttlistDecl ();
     93        void Parse_Enumeration ();
     94        void Parse_DefaultDecl ();
     95        void Parse_Entitydecl ();
     96        void Parse_Notationdecl ();
     97        void requireWS ();
     98        void Parse_AttValue ();
     99       
     100        void Parse_Prolog();
    79101       
    80102        /* Action routine for document start. */
     
    133155         of data that must be copied into the new buffer.*/
    134156        void FinalizeBuffer_action(int& preserve_pos);
    135 
     157       
     158        /*Document Type actions.*/
     159        void Doctype_action(int start_pos, int end_pos);
     160        void PEReference_action(int start_pos, int end_pos);
     161        void Elementdecl_action(int start_pos, int end_pos);
     162        void AttlistDecl_action(int start_pos, int end_pos);
     163        void Entitydecl_action(int start_pos, int end_pos);
     164        void Notationdecl_action(int start_pos, int end_pos);
     165       
     166        void Prolog_action(int start_pos, int end_pos);
    136167};
    137168
Note: See TracChangeset for help on using the changeset viewer.