Changeset 100 for trunk/src/engine.c


Ignore:
Timestamp:
Apr 14, 2008, 6:34:30 PM (11 years ago)
Author:
lindanl
Message:

Parsers for internal and external entities.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/engine.c

    r99 r100  
    2020#include <iostream>
    2121using namespace std;
    22 
    23 Parser_Interface * Parser_Interface::ParserFactory(char * filename, bool is_external) {
     22       
     23inline char * copy_string (unsigned char * s, int lgth){               
     24        char * d = new char[lgth+1];
     25        memcpy(d, (char *)s,lgth);
     26        d[lgth] = '\0';
     27        return d;
     28}
     29
     30Parser_Interface * Parser_Interface::ParserFactory(char * filename) {
    2431       
    2532        int chars_read;
     
    3239        }
    3340        fread(signature,1,4,infile);
     41        Entity_Info * e = new Entity_Info;
    3442        Model_Info * m = new Model_Info;
    35         m->AnalyzeSignature(signature);
    36         Byteplex * b = Byteplex::ByteplexFactory(m, infile);
     43        e->AnalyzeSignature(signature);
     44        Byteplex * b = Byteplex::ByteplexFactory(e, infile);
    3745        b->InitializeBuffer(signature,4);
    3846
    39         if (m->code_unit_base == ASCII) {
    40                 return new ParsingEngine<ASCII>(m, b, is_external);
    41         }
    42         else /* if (m->code_unit_base == EBCDIC) */ {
    43                 return new ParsingEngine<EBCDIC>(m, b, is_external);
     47        if (e->code_unit_base == ASCII) {
     48                return new ParsingEngine<ASCII>(e, m, b, false);
     49        }
     50        else /* if (e->code_unit_base == EBCDIC) */ {
     51                return new ParsingEngine<EBCDIC>(e, m, b, false);
    4452        }       
    4553}
    4654
    47 Parser_Interface * Parser_Interface::ParserFactory(unsigned char * byte_buffer, int byte_count, Model_Info * m);
    48         Byteplex * b = Byteplex::ByteplexFactory(m, byte_buffer, byte_count);
    49         if (m->code_unit_base == ASCII) {
    50                 return new ParsingEngine<ASCII>(m, b, false);
    51         }
    52         else /* if (m->code_unit_base == EBCDIC) */ {
    53                 return new ParsingEngine<EBCDIC>(m, b, false);
     55Parser_Interface * Parser_Interface::ParserFactory(char * filename, Model_Info * m) {
     56       
     57        int chars_read;
     58        unsigned char signature[4];
     59        FILE * infile;
     60        infile = fopen(filename, "rb");
     61        if (!infile) {
     62                fprintf(stderr, "Error: cannot open %s for input.\n", filename);
     63                exit(-1);
     64        }
     65        fread(signature,1,4,infile);
     66        Entity_Info * e = new Entity_Info;
     67        e->AnalyzeSignature(signature);
     68        Byteplex * b = Byteplex::ByteplexFactory(e, infile);
     69        b->InitializeBuffer(signature,4);
     70
     71        if (e->code_unit_base == ASCII) {
     72                return new ParsingEngine<ASCII>(e, m, b, true);
     73        }
     74        else /* if (e->code_unit_base == EBCDIC) */ {
     75                return new ParsingEngine<EBCDIC>(e, m, b, true);
    5476        }       
    5577}
    5678
     79Parser_Interface * Parser_Interface::ParserFactory(char * byte_buffer, int byte_count, Entity_Info * e, Model_Info * m){
     80        Byteplex * b = Byteplex::ByteplexFactory(e, (unsigned char *) byte_buffer, byte_count);
     81        if (e->code_unit_base == ASCII) {
     82                return new ParsingEngine<ASCII>(e, m, b, false);
     83        }
     84        else {
     85                return new ParsingEngine<EBCDIC>(e, m, b, false);
     86        }       
     87}
    5788
    5889Parser_Interface::~Parser_Interface() {
     
    6192
    6293bool Parser_Interface::has_ByteOrderMark() {
    63         return model_info->BOM_units > 0;
     94        return entity_Info->BOM_units > 0;
    6495}
    6596
    6697XML_version Parser_Interface::get_version() {
    67         return model_info->version;
     98        return entity_Info->version;
    6899}
    69100
    70101XML_standalone Parser_Interface::standalone_status() {
    71         return model_info->standalone;
     102        return entity_Info->standalone;
    72103}
    73104
    74105bool Parser_Interface::has_EncodingDecl() {
    75         return model_info->has_encoding_decl;
     106        return entity_Info->has_encoding_decl;
    76107}
    77108
    78109unsigned char * Parser_Interface::get_Encoding() {
    79         return model_info->encoding;
     110        return entity_Info->encoding;
    80111}
    81112
    82113unsigned char * Parser_Interface::GetCodeUnitPtr(int pos) {
    83114        int rel_pos = pos - buffer_base_pos;
    84         return &((unsigned char *) (byteplex->src_buffer))[rel_pos * (int) model_info->code_unit_size];
    85 }
    86 
    87 
    88 
    89 
    90 template <CodeUnit_Base C>
    91 ParsingEngine<C>::ParsingEngine(Model_Info * m, Byteplex * b, bool is_external) : Parser_Interface () {
    92 
     115        return &((unsigned char *) (byteplex->src_buffer))[rel_pos * (int) entity_Info->code_unit_size];
     116}
     117
     118
     119
     120
     121template <CodeUnit_Base C>
     122ParsingEngine<C>::ParsingEngine(Entity_Info * e, Model_Info * m, Byteplex * b, bool is_external) : Parser_Interface () {
     123        entity_Info = e;
    93124        model_info = m;
    94125        byteplex = b;
     
    97128        byteplex->PreparePseudoASCII_Stream();
    98129         StrictWellFormedness=false;
    99         LastAttOccurrence.push_back(0);
     130        LastAttOccurrence.assign(m->globalAttributeCount+1, 0);
     131//      LastAttOccurrence.push_back(0);
    100132       
    101133        decl_parser = new XML_Decl_Parser<C>(byteplex);
    102134        int content_start = 0;
    103135        if(is_external == true)
    104                 content_start = decl_parser->ReadTextDeclaration(model_info);
     136                content_start = decl_parser->ReadTextDeclaration(entity_Info);
    105137        else
    106                 content_start = decl_parser->ReadXMLInfo(model_info);
     138                content_start = decl_parser->ReadXMLInfo(entity_Info);
    107139       
    108140        bitplex = new Bitplex;
     
    125157        int blocks_in_buffer = (buffer_limit_pos + BLOCKSIZE - 1)/BLOCKSIZE;
    126158        x8data = byteplex->x8data;
    127         lexer = Lexer<C>::LexerFactory(m, buf);
     159        lexer = Lexer<C>::LexerFactory(e, buf);
    128160        bitplex->TransposeToBitStreams(byteplex->x8data, blocks_in_buffer);
    129161        lexer->AnalyzeBuffer(bitplex->x8basis, buffer_limit_pos);
     
    132164template <CodeUnit_Base C>
    133165ParsingEngine<C>::~ParsingEngine() {
    134   model_info->~Model_Info();
     166  // How do we do this?  model_info->~Model_Info();
     167  entity_Info->~Entity_Info();
    135168  byteplex->~Byteplex();
    136169  decl_parser->~XML_Decl_Parser<C>();
     
    343376template <CodeUnit_Base C>
    344377inline void ParsingEngine<C>::Parse_EntityRef() {
    345         Advance(1);  // skip "&"
     378    Advance(1);  // skip "&"
     379    int ref_start = AbsPos();
    346380        ScanTo(NameFollow);  /* Name delimiter */
    347         if (!AtChar<C,';'>(cur())) {
     381    if (!AtChar<C,';'>(cur())) {
    348382                Syntax_Error(NT_Reference);
    349         }
     383    }
    350384        else {
     385                int lgth = AbsPos()-ref_start;
     386                char * s = new char[lgth+1];
     387                memcpy(s, GetCodeUnitPtr(ref_start),lgth);
     388                s[lgth] = '\0';
     389               
    351390                Advance(1);
    352391                Reference_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    353 //      The following code will replace Reference_Action.
    354 //              entity_info = LookupEntity();
    355 //              ParserInterface * entity_parser;
    356 //              if (entity_info->is_external) {
    357 //                      entity_parser = ParserFactory(filename, model_info);
    358 //              }
    359 //              else {
    360 //                      replText = GetReplacementText(LookupEntity());
    361 //                      entity_parser = ParserFactory(replText, strlen(replText), model_info);
    362 //              }
    363 //              entity_parser->ParseContent();
    364 //              entity_parser->~ParserInterface();
     392               
     393                //      The following code will replace Reference_Action.
     394                GEntity_info * this_info;
     395                Parser_Interface * entity_parser;
     396                int entityID = model_info->GlobalGEntityTable[s];
     397                if (entityID == 0)
     398                        WF_Error(wfErr_wf_entdeclared);
     399                else{
     400                        this_info = model_info->GEntityData[entityID-1];
     401                        if (this_info->is_external){
     402                                entity_parser = ParserFactory(this_info->systemLiteral, model_info);
     403                                entity_parser->ParseContent();
     404                                entity_parser->~Parser_Interface();
     405                        }
     406                        else {
     407                                if (this_info->is_simple == true)
     408                                        printf("Entity is %s\n",this_info->ReplacementText);
     409                                else{
     410                                        printf("Not a simple text: %s\n",this_info->ReplacementText);
     411                                        entity_parser = ParserFactory(this_info->ReplacementText, strlen(this_info->ReplacementText),entity_Info, model_info);
     412                                        entity_parser->ParseContent();
     413                                        entity_parser->~Parser_Interface();
     414                                }
     415                        }
     416                }
     417               
    365418        }
    366419}
     
    10341087       
    10351088        int name_start;
     1089        int quot_start;
    10361090        int lgth;
    10371091        int old_abspos;
     1092        char * s;
     1093       
    10381094        Advance(6); /* Skip "ENTITY. */
    10391095        requireWS();
     
    10461102                ScanTo(NameFollow);
    10471103                lgth = AbsPos()- name_start;
    1048                 char *s = new char[lgth+1];
    1049                 memcpy(s, GetCodeUnitPtr(name_start), lgth);
     1104                s = new char[lgth+1];
     1105                memcpy(s, GetCodeUnitPtr(name_start),lgth);
    10501106                s[lgth] = '\0';
    10511107       
    1052                 int entityID = model_info->GlobalEntityTable[s];
     1108                PEntity_info * this_info = new PEntity_info;
     1109                int entityID = model_info->GlobalPEntityTable[s];
    10531110                if(entityID==0){       
    1054                         model_info->GlobalEntityTable[s]=++(model_info->globalEntityCount);
    1055                         entityID = model_info->globalEntityCount;
     1111                        model_info->GlobalPEntityTable[s]=++(model_info->globalPEntityCount);
     1112                        entityID = model_info->globalPEntityCount;
     1113                        this_info->globalPEntity_id = entityID;
    10561114                }
    10571115                else
     
    10591117       
    10601118                requireWS();
    1061                 if(at_SYSTEM<C>(cur())||at_PUBLIC<C>(cur())){
    1062                 Parse_ExternalID();     
    1063         }
     1119                if(at_SYSTEM<C>(cur())){
     1120                        Advance(6);
     1121                        requireWS();
     1122                        quot_start = AbsPos()+1;
     1123                        Parse_MatchedQuote (); /*  SystemLiteral */
     1124                        lgth = AbsPos() - quot_start - 1;                       
     1125                        this_info->systemLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
     1126                        this_info->is_external = true;
     1127                }
     1128                else if (at_PUBLIC<C>(cur())){
     1129                        Advance(6);
     1130                        requireWS();
     1131                       
     1132                        quot_start = AbsPos()+1;
     1133                        Parse_MatchedQuote ();/*  PubidLiteral */               
     1134                        lgth = AbsPos() - quot_start - 1;                       
     1135                        this_info->pubidLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
     1136                        this_info->is_external = true; 
     1137                       
     1138                        requireWS();
     1139                       
     1140                        quot_start = AbsPos()+1;
     1141                        Parse_MatchedQuote (); /*  SystemLiteral */
     1142                        lgth = AbsPos() - quot_start - 1;                       
     1143                        this_info->systemLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
     1144                        this_info->is_external = true;
     1145                }
    10641146        else if(AtQuote<C>(cur())){
    1065                 Parse_AttValue(); /* Not parse PEReference*/
     1147                Parse_PEntityValue(this_info);
     1148                this_info->is_external = false;
    10661149        }
    10671150        else
    10681151                Syntax_Error(NT_EntityDecl);
     1152        model_info->PEntityData.push_back(this_info);
    10691153        }
    10701154        else{
     
    10721156                ScanTo(NameFollow);
    10731157                lgth = AbsPos()- name_start;
    1074                 char *s = new char[lgth+1];
    1075                 memcpy(s, GetCodeUnitPtr(name_start), lgth);
     1158                s = new char[lgth+1];
     1159                memcpy(s, GetCodeUnitPtr(name_start),lgth);
    10761160                s[lgth] = '\0';
    10771161       
    1078                 int entityID = model_info->GlobalEntityTable[s];
     1162                GEntity_info * this_info = new GEntity_info;
     1163                int entityID = model_info->GlobalGEntityTable[s];
    10791164                if(entityID==0){       
    1080                         model_info->GlobalEntityTable[s]=++(model_info->globalEntityCount);
    1081                         entityID = model_info->globalEntityCount;
     1165                        model_info->GlobalGEntityTable[s]=++(model_info->globalGEntityCount);
     1166                        entityID = model_info->globalGEntityCount;
     1167                        this_info->globalGEntity_id = entityID;
    10821168                }
    10831169                else
     
    10861172                requireWS();
    10871173               
    1088                 if(at_SYSTEM<C>(cur())||at_PUBLIC<C>(cur())){
    1089                 Parse_ExternalID();
    1090                 ScanTo(NonWS);
     1174                if(at_SYSTEM<C>(cur())){
     1175                        Advance(6);
     1176                        requireWS();
     1177                        quot_start = AbsPos()+1;
     1178                        Parse_MatchedQuote (); /*  SystemLiteral */
     1179                        lgth = AbsPos() - quot_start - 1;                       
     1180                        this_info->systemLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
     1181                        this_info->is_external = true;
     1182                       
     1183                        old_abspos = AbsPos();
     1184                        ScanTo(NonWS);
    10911185                if(at_NDATA<C>(cur())){
    10921186                        if(old_abspos == AbsPos())
     
    10951189                                Advance(5);
    10961190                        requireWS();
     1191                        name_start = AbsPos();
    10971192                        ScanTo(NameFollow);
     1193                        lgth = AbsPos() - name_start;
     1194                                this_info->NDataName = copy_string(GetCodeUnitPtr(name_start),lgth);
    10981195                }
    1099         }
    1100         else if(AtQuote<C>(cur())){
    1101                 Parse_AttValue(); /* Not parse PEReference*/
     1196                }
     1197                else if (at_PUBLIC<C>(cur())){
     1198                        Advance(6);
     1199                        requireWS();
     1200                       
     1201                        quot_start = AbsPos()+1;
     1202                        Parse_MatchedQuote ();/*  PubidLiteral */               
     1203                        lgth = AbsPos() - quot_start - 1;                       
     1204                        this_info->pubidLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
     1205                        this_info->is_external = true; 
     1206                       
     1207                        requireWS();
     1208                       
     1209                        quot_start = AbsPos()+1;
     1210                        Parse_MatchedQuote (); /*  SystemLiteral */
     1211                        lgth = AbsPos() - quot_start - 1;                       
     1212                        this_info->systemLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
     1213                        this_info->is_external = true;
     1214                       
     1215                        old_abspos = AbsPos();
     1216                        ScanTo(NonWS);
     1217                if(at_NDATA<C>(cur())){
     1218                        if(old_abspos == AbsPos())
     1219                                Syntax_Error(NT_EntityDecl);
     1220                        else
     1221                                Advance(5);
     1222                        requireWS();
     1223                        name_start = AbsPos();
     1224                        ScanTo(NameFollow);
     1225                        lgth = AbsPos() - name_start;
     1226                        this_info->NDataName = copy_string(GetCodeUnitPtr(name_start),lgth);
     1227                }
     1228                }
     1229                else if(AtQuote<C>(cur())){
     1230                Parse_GEntityValue(this_info);
     1231                this_info->is_external = false;
    11021232        }
    11031233        else
    11041234                Syntax_Error(NT_EntityDecl);
     1235        model_info->GEntityData.push_back(this_info);
    11051236        }
    11061237        ScanTo(NonWS);
     
    11131244                Syntax_Error(NT_EntityDecl);
    11141245}
    1115 
     1246       
    11161247template <CodeUnit_Base C>
    11171248inline void ParsingEngine<C>::Parse_Notationdecl (){
     
    11981329        }
    11991330        Advance(1);
     1331}
     1332
     1333template <CodeUnit_Base C>
     1334inline void ParsingEngine<C>::Parse_GEntityValue(GEntity_info * this_info){
     1335       
     1336        int     quoteCh = cur()[0];
     1337        Advance(1); /* Skip " or ' */
     1338        this_info->is_simple = true;
     1339        int quot_start = AbsPos();
     1340        ScanTo(Quote);         
     1341        char *  replText = copy_string(GetCodeUnitPtr(quot_start),AbsPos()-quot_start);
     1342
     1343        while (cur()[0] != quoteCh){
     1344                if (at_CharRef_Start<C>(cur())){
     1345                        strcat (replText,Replace_CharRef());
     1346                        quot_start = AbsPos();
     1347                        ScanTo(Quote);
     1348                }
     1349                else if (AtChar<C,'&'>(cur())){
     1350                        strcat (replText,Replace_EntityRef(this_info->is_simple));
     1351                        quot_start = AbsPos();
     1352                        ScanTo(Quote);
     1353                }
     1354                else if (AtQuote<C>(cur())) {
     1355                        quot_start = AbsPos();
     1356                        Advance(1);
     1357                        ScanTo(Quote);
     1358
     1359                }
     1360                else { /* '<' found */
     1361                        quot_start = AbsPos();
     1362                        Advance(1);
     1363                        ScanTo(Quote);
     1364                        this_info->is_simple = false;
     1365                }
     1366                strcat (replText,copy_string(GetCodeUnitPtr(quot_start),AbsPos()-quot_start));                 
     1367        }
     1368        this_info->ReplacementText = replText;
     1369        Advance(1);
     1370}
     1371
     1372template <CodeUnit_Base C>
     1373inline char * ParsingEngine<C>::Replace_EntityRef(bool& is_simple){
     1374        Advance(1);
     1375        int entity_start = AbsPos();
     1376        ScanTo(NameFollow);
     1377        char * s = copy_string(GetCodeUnitPtr(entity_start),AbsPos()-entity_start);
     1378        if (AtChar<C,';'>(cur()))
     1379                Advance(1);
     1380        else
     1381                Syntax_Error(NT_EntityValue);
     1382        int entityID = model_info->GlobalGEntityTable[s];
     1383        if (entityID == 0)
     1384                WF_Error(wfErr_wf_entdeclared);
     1385        else{
     1386                if (model_info->GEntityData[entityID-1]->is_simple == false)
     1387                        is_simple = false;
     1388                return model_info->GEntityData[entityID-1]->ReplacementText;
     1389        }
     1390       
     1391}
     1392
     1393template <CodeUnit_Base C>
     1394inline void ParsingEngine<C>::Parse_PEntityValue(PEntity_info * this_info){
     1395}
     1396
     1397template <CodeUnit_Base C>
     1398inline char * ParsingEngine<C>::Replace_CharRef(){
     1399        Advance(1);
     1400        int entity_start = AbsPos();
     1401        ScanTo(NameFollow);
     1402        char * s = copy_string(GetCodeUnitPtr(entity_start),AbsPos()-entity_start);
     1403        int entityID = model_info->GlobalGEntityTable[s];
     1404        if (entityID == 0)
     1405                WF_Error(wfErr_wf_entdeclared);
     1406        else
     1407                return model_info->GEntityData[entityID-1]->ReplacementText;
     1408       
     1409       
    12001410}
    12011411
     
    12251435        }
    12261436        Prolog_action(GetCodeUnitPtr(old_pos), LengthFrom(old_pos));
    1227 }
    1228 
    1229 template <CodeUnit_Base C>
    1230 inline void ParsingEngine<C>::ExtSubsetDecl_action(unsigned char * item, int lgth) {
    12311437}
    12321438
Note: See TracChangeset for help on using the changeset viewer.