Changeset 91 for trunk


Ignore:
Timestamp:
Apr 8, 2008, 8:52:18 AM (11 years ago)
Author:
cameron
Message:

ATTLIST semantics

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/markup_stats.cxx

    r87 r91  
    307307
    308308template <CodeUnit_Base C>
    309 inline void ParsingEngine<C>::Entitydecl_action(int start_pos, int end_pos) {
     309inline void ParsingEngine<C>::Entitydecl_action(int entity_name_start, int entity_name_end, int start_pos, int end_pos) {
    310310#ifdef SHOW_DTD_ACTIONS
    311311        printf("Entitydecl:\n");
  • trunk/src/bitlex.c

    r86 r91  
    134134
    135135template <CodeUnit_Base C>
    136 Lexer<C>::Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer_Interface(m, l) {
     136Lexer<C>::Lexer(Model_Info * m, LexicalStreamSet *l) : Lexer_Interface::Lexer_Interface(m, l) {
    137137}
    138138
     
    149149}
    150150
    151 UTF_16_Lexer::UTF_16_Lexer(Model_Info * m, LexicalStreamSet *l) : U16_Lexer(m, l) {
    152 }
    153 
    154 UCS_2_Lexer::UCS_2_Lexer(Model_Info * m, LexicalStreamSet *l) : U16_Lexer(m, l) {
     151UTF_16_Lexer::UTF_16_Lexer(Model_Info * m, LexicalStreamSet *l) : U16_Lexer::U16_Lexer(m, l) {
     152}
     153
     154UCS_2_Lexer::UCS_2_Lexer(Model_Info * m, LexicalStreamSet *l) : U16_Lexer::U16_Lexer(m, l) {
    155155}
    156156
  • trunk/src/engine.c

    r81 r91  
    1616#include <errno.h>
    1717#include <string.h>
    18 
     18#include <string>
     19#include <iostream>
     20using namespace std;
    1921
    2022Parser_Interface * Parser_Interface::ParserFactory(char * filename) {
     
    8284        byteplex->DoByteplex();
    8385        byteplex->PreparePseudoASCII_Stream();
     86       
     87        LastAttOccurrence.push_back(0);
     88       
    8489        decl_parser = new XML_Decl_Parser<C>(byteplex);
    8590        int content_start = decl_parser->ReadXMLInfo(model_info);
     
    385390                        ScanTo(NameFollow);
    386391                        att_name_end = AbsPos();
     392                        int lgth = att_name_end-att_name_start;
     393               
     394                        int attID = model_info->getOrInsertGlobalAttName(GetCodeUnitPtr(att_name_start), lgth);
     395                        if (attID >= LastAttOccurrence.size()) LastAttOccurrence.push_back(0);
     396                        else {
     397                                if (LastAttOccurrence[attID] > text_or_markup_start) {
     398                                        Error_action(text_or_markup_start, AbsPos()); /* Duplicate attribute. */
     399                                        break;
     400                                }                       
     401                        }
     402                        LastAttOccurrence[attID] = att_name_start;
    387403                        /* The following optimized tests handle the frequently occurring
    388404                        case that there are no blanks on either side of the equals sign.
     
    660676
    661677    requireWS();
     678    int name_start = AbsPos();
    662679        ScanTo(NameFollow);
     680        int lgth = AbsPos() - name_start;
     681        int elemID = model_info->getOrInsertGlobalElement(GetCodeUnitPtr(name_start), lgth);
    663682        requireWS();
    664683       
     
    673692                ScanTo(NonWS);
    674693                if (at_PCDATA<C>(cur()))
    675                         Parse_RemainedMixed();
     694                        Parse_RemainingMixed();
    676695                else
    677                         Parse_RemainedChildren();
     696                        Parse_RemainingChildren();
    678697    }
    679698               
     
    686705}
    687706template <CodeUnit_Base C>
    688 inline void ParsingEngine<C>::Parse_RemainedMixed (){
     707inline void ParsingEngine<C>::Parse_RemainingMixed (){
    689708       
    690709        Advance(7);  /* Skip "#PCDATA". */
     
    712731
    713732template <CodeUnit_Base C>
    714 inline void ParsingEngine<C>::Parse_RemainedChildren (){
     733inline void ParsingEngine<C>::Parse_RemainingChildren (){
    715734        Parse_Cp();
    716735        ScanTo(NonWS);
     
    758777                Advance(1);
    759778                ScanTo(NonWS);
    760                 Parse_RemainedChildren();
     779                Parse_RemainingChildren();
    761780        }
    762781        else{
     
    771790       
    772791        int old_abspos;
     792       
     793        int name_start;
     794        int lgth;
     795       
     796        int elemID;
     797        int attID;
     798       
    773799        Advance(7); /* Skip "ATTLIST. */
    774800        requireWS();
     801       
     802        name_start = AbsPos();
    775803        ScanTo(NameFollow);
     804        lgth = AbsPos()-name_start;
     805        elemID = model_info->getOrInsertGlobalElement(GetCodeUnitPtr(name_start), lgth);
    776806       
    777807        old_abspos = AbsPos();
     
    780810                if(old_abspos == AbsPos())
    781811                Error_action(text_or_markup_start, AbsPos());
    782         ScanTo(NameFollow);
     812               
     813        name_start = AbsPos();
     814                ScanTo(NameFollow);
     815                lgth = AbsPos()-name_start;
     816               
     817                attID = model_info->getOrInsertGlobalAttName(GetCodeUnitPtr(name_start), lgth);
     818                if (attID >= LastAttOccurrence.size()) LastAttOccurrence.push_back(0);
     819        ATT_info * this_info = new ATT_info;
     820        this_info->globalATT_id = attID;
    783821        requireWS();
    784         if (at_CDATA<C>(cur()))
     822        if (at_CDATA<C>(cur())){
    785823                Advance(5);
    786         else if(at_ID<C>(cur()))
     824                this_info->attType = CDATA_att;
     825        }
     826        else if(at_ID<C>(cur())){
    787827                Advance(2);
    788         else if(at_IDREF<C>(cur()))
     828                this_info->attType = ID_att;
     829        }
     830        else if(at_IDREF<C>(cur())){
    789831                Advance(5);
    790         else if(at_IDREFS<C>(cur()))
     832                this_info->attType = IDREF_att;
     833        }
     834        else if(at_IDREFS<C>(cur())){
    791835                Advance(6);
    792         else if(at_ENTITY<C>(cur()))
     836                this_info->attType = IDREFS_att;
     837        }
     838        else if(at_ENTITY<C>(cur())){
    793839                Advance(6);
    794         else if(at_ENTITIES<C>(cur()))
     840                this_info->attType = ENTITY_att;
     841        }
     842        else if(at_ENTITIES<C>(cur())){
    795843                Advance(8);
    796         else if(at_NMTOKEN<C>(cur()))
     844                this_info->attType = ENTITIES_att;
     845        }
     846        else if(at_NMTOKEN<C>(cur())){
    797847                Advance(7);
    798         else if(at_NMTOKENS<C>(cur()))
     848                this_info->attType = NMTOKEN_att;
     849        }
     850        else if(at_NMTOKENS<C>(cur())){
    799851                Advance(8);
     852                this_info->attType = NMTOKENS_att;
     853        }
    800854        else if(at_NOTATION<C>(cur())){ /* NotationType = 'NOTATION' S Enumeration
    801855                                                                         when Nmtoken = Name */
    802856                Advance(8);
    803857                        requireWS();
    804                 Parse_Enumeration();
    805         }
    806         else if(AtChar<C,'('>(cur()))
    807                 Parse_Enumeration();
     858                Parse_Enumeration(this_info);
     859                this_info->attType = NOTATION_att;
     860        }
     861        else if(AtChar<C,'('>(cur())){
     862                Parse_Enumeration(this_info);
     863                this_info->attType = enumeration_att;
     864        }
    808865        else
    809866                Error_action(text_or_markup_start, AbsPos());
    810867        requireWS();
    811         Parse_DefaultDecl();
     868        Parse_DefaultDecl(this_info);
    812869        old_abspos = AbsPos();
    813870                ScanTo(NonWS);
    814         }
     871                model_info->ElementAttributeData[elemID].push_back(this_info);
     872        }
     873
    815874        Advance(1);
    816875        AttlistDecl_action(text_or_markup_start, AbsPos());
     
    818877
    819878template <CodeUnit_Base C>
    820 inline void ParsingEngine<C>::Parse_Enumeration (){
     879inline void ParsingEngine<C>::Parse_Enumeration (ATT_info * this_info){
    821880
    822881        if(AtChar<C,'('>(cur()))
     
    839898
    840899template <CodeUnit_Base C>
    841 inline void ParsingEngine<C>::Parse_DefaultDecl (){
    842         if(at_REQUIRED<C>(cur()))
     900inline void ParsingEngine<C>::Parse_DefaultDecl (ATT_info * this_info){
     901        if(at_REQUIRED<C>(cur())){
    843902                Advance(9);
    844         else if(at_IMPLIED<C>(cur()))
     903                this_info->defaultKind = REQUIRED_att;
     904        }
     905        else if(at_IMPLIED<C>(cur())){
    845906                Advance(8);
    846         else if(at_FIXED<C>(cur())){
    847                 Advance(6);
    848                 requireWS();
    849         }
    850         else if(AtQuote<C>(cur())){
    851                 Parse_AttValue();
    852         }
    853         else
    854                 Error_action(text_or_markup_start, AbsPos());
     907                this_info->defaultKind = IMPLIED_att;
     908        }
     909        else {
     910                if(at_FIXED<C>(cur())){
     911                        Advance(6);
     912                        requireWS();
     913                        this_info->defaultKind = FIXED_att;
     914                }
     915                else this_info->defaultKind = DEFAULT_att;
     916                if(AtQuote<C>(cur())){
     917                        int quot_start = AbsPos()+1;
     918                        Parse_AttValue();
     919                        /* need to normalize */
     920                        this_info->defaultValueLgth = AbsPos() - quot_start - 1;
     921                       
     922                        this_info->defaultValue = new unsigned char[this_info->defaultValueLgth+1];
     923                        memcpy(this_info->defaultValue, GetCodeUnitPtr(quot_start),this_info->defaultValueLgth);
     924                        this_info->defaultValue[this_info->defaultValueLgth] = '\0';
     925                        }
     926                else
     927                        Error_action(text_or_markup_start, AbsPos());
     928        }
    855929}
    856930
     
    858932inline void ParsingEngine<C>::Parse_Entitydecl (){
    859933       
     934        int entity_name_start;
     935        int entity_name_end;
    860936        int old_abspos;
    861937        Advance(6); /* Skip "ENTITY. */
     
    865941                Advance(1);
    866942                requireWS();
     943                entity_name_start = AbsPos();
    867944                ScanTo(NameFollow);
     945                entity_name_end = AbsPos();
    868946                requireWS();
    869947                if(at_SYSTEM<C>(cur())||at_PUBLIC<C>(cur())){
     
    877955        }
    878956        else{
     957                entity_name_start = AbsPos();
    879958                ScanTo(NameFollow);
     959                entity_name_end = AbsPos();
    880960                requireWS();
    881961               
     
    901981        if (AtChar<C,'>'>(cur())){
    902982                Advance(1);
    903                 Entitydecl_action(text_or_markup_start, AbsPos());
     983                Entitydecl_action(entity_name_start, entity_name_end, text_or_markup_start, AbsPos());
    904984        }
    905985        else
  • trunk/src/engine.h

    r81 r91  
    3131        bool has_EncodingDecl();
    3232        unsigned char * get_Encoding();
     33                Model_Info * model_info;
    3334protected:
    3435        /* Co-classes */
    35         Model_Info * model_info;
     36
    3637        Byteplex * byteplex;   
    3738        Bitplex * bitplex;
     
    5354        void ParseContent();
    5455protected:
    55 
     56        vector<int> LastAttOccurrence;
    5657        XML_Decl_Parser<C> * decl_parser;
    5758       
     
    8990        void Parse_PEReference ();
    9091        void Parse_Elementdecl ();
    91         void Parse_RemainedMixed ();
    92         void Parse_RemainedChildren ();
     92        void Parse_RemainingMixed ();
     93        void Parse_RemainingChildren ();
    9394        void Parse_Cp();
    9495        void Parse_AttlistDecl ();
    95         void Parse_Enumeration ();
    96         void Parse_DefaultDecl ();
     96        void Parse_Enumeration (ATT_info * this_info);
     97        void Parse_DefaultDecl (ATT_info * this_info);
    9798        void Parse_Entitydecl ();
    9899        void Parse_Notationdecl ();
     
    166167        void Elementdecl_action(int start_pos, int end_pos);
    167168        void AttlistDecl_action(int start_pos, int end_pos);
    168         void Entitydecl_action(int start_pos, int end_pos);
     169        void Entitydecl_action(int entity_name_start, int entity_name_end, int start_pos, int end_pos);
    169170        void Notationdecl_action(int start_pos, int end_pos);
    170171       
  • trunk/src/multiliteral.h

    r88 r91  
    1919
    2020#include <assert.h>
    21 #ifndef _MSC_VER
    2221#include <stdint.h>
    23 #endif
    24 #ifdef _MSC_VER
    25 #include "../lib/stdint.h"
    26 #endif
    2722#include "xmlmodel.h"
    2823#include "charsets/ASCII_EBCDIC.h"
  • trunk/src/xmldecl.c

    r85 r91  
    7474
    7575template <CodeUnit_Base C>
    76 void XML_Decl_Parser<C>::EncodingAction(Model_Info * m, int start_pos, int end_pos) {
    77         int encoding_lgth = end_pos-start_pos;
    78         m->encoding = (unsigned char *) malloc(encoding_lgth+1);
    79         memcpy(m->encoding, &x8data[start_pos-buffer_base_pos], encoding_lgth);
    80         m->encoding[encoding_lgth] = '\0';
     76int XML_Decl_Parser<C>::EncodingAction(Model_Info * m, int start_pos, int end_pos) {
     77        m->encoding = (unsigned char *) malloc(end_pos-start_pos+1);
     78        memcpy(m->encoding, &x8data[start_pos-buffer_base_pos], end_pos - start_pos);
     79        m->encoding[end_pos - start_pos] = '\0';
    8180}
    8281//
  • trunk/src/xmldecl.h

    r85 r91  
    3434        unsigned char * cur() const;
    3535       
    36         void EncodingAction(Model_Info * m, int start_pos, int end_pos);
     36        int EncodingAction(Model_Info * m, int start_pos, int end_pos);
    3737private:
    3838        /* Bytespace parsing routines for internal use in ReadXMLInfo and
  • trunk/src/xmlmodel.c

    r67 r91  
    99#include "multiliteral.h"
    1010#include "xmlmodel.h"
     11
     12Model_Info::Model_Info() {
     13        ElementAttributeData.push_back(vector<ATT_info *>());
     14        globalElementCount = 0;
     15        globalAttributeCount = 0;
     16}
    1117
    1218Model_Info::~Model_Info() {
     
    7985                BOM_units = B;
    8086 }
     87int Model_Info::getOrInsertGlobalElement(unsigned char * elem_name, int lgth) {
     88        int elemID;
     89        char *s = new char[lgth+1];
     90        memcpy(s, elem_name, lgth);
     91        s[lgth] = '\0';
     92        elemID = GlobalElementTable[s];
     93        if(elemID==0){ 
     94                GlobalElementTable[s]=++(globalElementCount);
     95                elemID = globalElementCount;
     96               
     97                ElementAttributeData.push_back(vector<ATT_info *>());
     98        }
     99        return elemID;
     100}
     101
     102int Model_Info::getOrInsertGlobalAttName(unsigned char * att_name, int lgth){
     103       
     104        char *s = new char[lgth+1];
     105        memcpy(s, att_name, lgth);
     106        s[lgth] = '\0';
     107       
     108        int attID = GlobalAttributeTable[s];
     109        if(attID==0){   
     110                GlobalAttributeTable[s]=++(globalAttributeCount);
     111                attID = globalAttributeCount;
     112        }
     113        return attID;
     114}
  • trunk/src/xmlmodel.h

    r67 r91  
    2222#ifndef XMLMODEL_H
    2323#define XMLMODEL_H
     24#include <vector>
     25#include <iostream>
     26#include <string>
     27#include <ext/hash_map>
    2428
     29using namespace __gnu_cxx;
     30using namespace std;
    2531
    2632enum XML_version {XML_1_0, XML_1_1, no_XML_version_value};
     
    6874
    6975
     76/* Attribute Modeling */
     77
     78enum ATT_type {CDATA_att, ID_att, IDREF_att, IDREFS_att, ENTITY_att, ENTITIES_att,
     79               NMTOKEN_att, NMTOKENS_att, NOTATION_att, enumeration_att};
     80/* Possible attribute types as specified in ATTLIST declarations. */
     81
     82enum ATT_default_kind {REQUIRED_att, IMPLIED_att, FIXED_att, DEFAULT_att};
     83/* Possible kinds of attribute default in ATTLIST declarations. */
     84
     85class ATT_info {
     86public:
     87        int globalATT_id;
     88        ATT_type attType;
     89        vector<string> enumValues; /* For NOTATION_att or enumeration_att.*/
     90        ATT_default_kind defaultKind;
     91        unsigned char * defaultValue;
     92        int defaultValueLgth;
     93};
     94
     95/* The complete Attribute model for a given element is a vector of ATT_info
     96   specifications for particular attribute names. */
     97//typedef vector<ATT_info> ElementAttributeModel;
     98
     99struct eqstr
     100{
     101  bool operator()(const char* s1, const char* s2) const
     102  {
     103    return strcmp(s1, s2) == 0;
     104  }
     105};
     106
    70107class Model_Info {
    71108       
    72109public:
     110        Model_Info();
    73111        ~Model_Info();
    74112
     
    88126        unsigned char * encoding;
    89127        XML_standalone standalone;
    90 
     128       
     129        /* Information computed from ATTLIST declarations. */
     130        hash_map<const char *, int, hash<const char *>, eqstr > GlobalAttributeTable;
     131        hash_map<const char *, int, hash<const char *>, eqstr > GlobalElementTable;
     132        int globalElementCount;
     133        int globalAttributeCount;
     134       
     135    /* For each element, we have an ElementAttributeModel */
     136        vector<vector<ATT_info *> > ElementAttributeData;
     137        int getOrInsertGlobalElement(unsigned char * elem_name, int lgth);
     138        int getOrInsertGlobalAttName(unsigned char * att_name, int lgth);
    91139private:
    92140        void set_charset_family(CodeUnit_Base C, CodeUnit_Size S, CodeUnit_ByteOrder O, int B);
Note: See TracChangeset for help on using the changeset viewer.