Changeset 267 for trunk/src/engine.c


Ignore:
Timestamp:
Mar 20, 2009, 12:18:53 PM (10 years ago)
Author:
ksherdy
Message:

Construct and pass string literals as read only (const char *) types.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/engine.c

    r266 r267  
    2222#include <iostream>
    2323using namespace std;
    24        
    25 inline char * copy_string (unsigned char * s, int lgth){               
     24
     25inline char * copy_string (unsigned char * s, int lgth){
    2626        char * d = new char[lgth+1];
    27         memcpy(d, (char *)s,lgth); 
    28         d[lgth] = '\0'; 
     27        memcpy(d, (char *)s,lgth);
     28        d[lgth] = '\0';
    2929        return d;
    3030}
     
    3737        return s;
    3838}
    39        
    40        
    41 template <WorkingCharacterSet W>       
    42 Parser_Interface<W> * Parser_Interface<W>::ParserFactory(char * filename) {
    43        
     39
     40
     41template <WorkingCharacterSet W>
     42Parser_Interface<W> * Parser_Interface<W>::ParserFactory(const char * filename) {
     43
    4444        int chars_read;
    4545        unsigned char signature[4];
     
    5858        b->DoByteplex();
    5959        b->PreparePseudoASCII_Stream();
    60        
     60
    6161        if (e->code_unit_base == ASCII) {
    6262                XML_Decl_Parser<ASCII> decl_parser(b);
     
    6464                if (e->code_unit_size == SingleByte) {
    6565                        if (!(e->has_encoding_decl) || at_UTF_8(e->encoding))
    66                                 return new ParsingEngine< UTF8_Buffer, W>(e, m, b, false);             
     66                                return new ParsingEngine< UTF8_Buffer, W>(e, m, b, false);
    6767                        else return new ParsingEngine< X8_Buffer<ASCII>, W>(e, m, b, false);
    6868                }
     
    7878                decl_parser.ReadXMLInfo(*e);
    7979                return new ParsingEngine< X8_Buffer<EBCDIC>, W>(e, m, b, false);
    80         }       
     80        }
    8181}
    8282
    8383template <WorkingCharacterSet W>
    84 Parser_Interface<W> * Parser_Interface<W>::ParserFactory(char * filename, Model_Info * m) {
    85        
     84Parser_Interface<W> * Parser_Interface<W>::ParserFactory(const char * filename, Model_Info * m) {
     85
    8686        int chars_read;
    8787        unsigned char signature[4];
     
    116116                decl_parser.ReadXMLInfo(*e);
    117117                return new ParsingEngine< X8_Buffer<EBCDIC>, W>(e, m, b, true);
    118         }       
     118        }
    119119}
    120120
    121121template <WorkingCharacterSet W>
    122 Parser_Interface<W> * Parser_Interface<W>::ParserFactory(char * byte_buffer, int byte_count, Entity_Info * e1, Model_Info * m){
     122Parser_Interface<W> * Parser_Interface<W>::ParserFactory(const char * byte_buffer, int byte_count, Entity_Info * e1, Model_Info * m){
    123123        Entity_Info * e = new Entity_Info;
    124124        e->BOM_units = 0;
     
    144144        else /* if (e->code_unit_base == EBCDIC) */ {
    145145                return new ParsingEngine< X8_Buffer<EBCDIC>, W>(e, m, b, false);
    146         }       
     146        }
    147147}
    148148
     
    199199
    200200//      m->symbol_table = new Symbol_Table();
    201 //      m->SimpleEntity("lt", "<"); 
    202 //      m->SimpleEntity("gt", ">"); 
    203 //      m->SimpleEntity("amp", "&"); 
    204 //      m->SimpleEntity("quot", "\""); 
    205 //      m->SimpleEntity("apos", "'");   
     201//      m->SimpleEntity("lt", "<");
     202//      m->SimpleEntity("gt", ">");
     203//      m->SimpleEntity("amp", "&");
     204//      m->SimpleEntity("quot", "\"");
     205//      m->SimpleEntity("apos", "'");
    206206        m->symbol_table->version = e->version;
    207207
    208208        StrictWellFormedness=false;
    209209        LastAttOccurrence.assign(m->globalAttributeCount+1, 0);
    210        
    211        
     210
     211
    212212        bitplex = new Bitplex;
    213213        buf = (LexicalStreamSet *) simd_new(sizeof(LexicalStreamSet)/PACKSIZE);
     
    345345template <class B, WorkingCharacterSet W>
    346346inline bool ParsingEngine<B, W>::at_EOF() const {
    347   return (buffer_rel_pos >= buffer_limit_pos) && 
     347  return (buffer_rel_pos >= buffer_limit_pos) &&
    348348         (buffer_limit_pos < BUFFER_SIZE);
    349349}
     
    352352//inline void ParsingEngine<B, W>::Advance(int n) {
    353353//      buffer_rel_pos += n;
    354 //  if (buffer_rel_pos >= BUFFER_SIZE) {       
     354//  if (buffer_rel_pos >= BUFFER_SIZE) {
    355355//      Parser_Interface<W>::FinalizeBuffer_action();
    356356//      AdvanceBuffers();
     
    368368
    369369
    370 template <class B, WorkingCharacterSet W> 
     370template <class B, WorkingCharacterSet W>
    371371void ParsingEngine<B, W>::AdjustBufferEndForIncompleteSequences() {
    372372}
    373373
    374 template <> 
     374template <>
    375375void ParsingEngine<UTF8_Buffer, UTF_8>::AdjustBufferEndForIncompleteSequences() {
    376376        if (*(cur()-1) >= 0xC0) buffer_rel_pos--;
     
    379379}
    380380
    381 template <> 
     381template <>
    382382void ParsingEngine<U16_Buffer, UTF_8>::AdjustBufferEndForIncompleteSequences() {
    383383        unsigned short last_u16_unit = *(GetCodeUnitPtr(AbsPos()-1));
     
    385385}
    386386
    387 template <> 
     387template <>
    388388void ParsingEngine<UTF8_Buffer, UTF_16>::AdjustBufferEndForIncompleteSequences() {
    389389        if (*(cur()-1) >= 0xC0) buffer_rel_pos--;
     
    392392}
    393393
    394 template <> 
     394template <>
    395395void ParsingEngine<U16_Buffer, UTF_16>::AdjustBufferEndForIncompleteSequences() {
    396396        unsigned short last_u16_unit = *(GetCodeUnitPtr(AbsPos()-1));
     
    402402#ifdef OPTIMIZE_SHORT_SCAN
    403403//
    404 //  Inline ScanTo with unrolled first test that should almost always 
     404//  Inline ScanTo with unrolled first test that should almost always
    405405//  succeed for short scans.
    406406#define ScanTo(item) \
     
    437437//      buffer_rel_pos += cfzl(segment);\
    438438// } while(0)
    439 // 
     439//
    440440// #define ScanTextTo(item) \
    441441// do {\
     
    527527//      Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    528528}
    529        
     529
    530530
    531531template <class B, WorkingCharacterSet W>
     
    536536//      Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    537537}
    538        
     538
    539539template <class B, WorkingCharacterSet W>
    540540void ParsingEngine<B, W>::Syntax_Error (XML_NonTerminal errNT) {
     
    544544//      Error_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    545545}
    546        
     546
    547547
    548548/* Parse a comment beginning "<!--" */
     
    556556                        Syntax_Error(NT_CDSect);
    557557                Advance(2); /* Skip hyphen-nonhyphen pair */
    558                 ScanTo(Hyphen); 
     558                ScanTo(Hyphen);
    559559        }
    560560        if (at_Comment_End<B::Base>(cur())) {
     
    594594                Syntax_Error(NT_CDStart);
    595595        }
    596         else { 
     596        else {
    597597                Advance(1);
    598598                CDATA_start_action(GetCodeUnitPtr(text_or_markup_start));
     
    621621                Advance(1);
    622622                Reference_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    623                
     623
    624624                //      The following code will replace Reference_Action.
    625625                GEntity_info * this_info;
    626626                Parser_Interface<W> * entity_parser;
    627                 int entityID = Parser_Interface<W>::model_info->GlobalGEntityTable[nameID]; 
     627                int entityID = Parser_Interface<W>::model_info->GlobalGEntityTable[nameID];
    628628                if (entityID == 0)
    629629                        WF_Error(wfErr_wf_entdeclared);
     
    631631                        this_info = Parser_Interface<W>::model_info->GEntityData[entityID-1];
    632632                        if (this_info->is_external){
    633                                
     633
    634634                        if (Parser_Interface<W>::entity_Info->standalone != Standalone_no)
    635635                                WF_Error(wfErr_NoExternalRefs);
     
    655655                        }
    656656                }
    657                
     657
    658658        }
    659659}
     
    669669                Advance(1);
    670670                Reference_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    671                
     671
    672672                //      The following code will replace Reference_Action.
    673673                GEntity_info * this_info;
    674674                Parser_Interface<W> * entity_parser;
    675                 int entityID = Parser_Interface<W>::model_info->GlobalGEntityTable[nameID]; 
     675                int entityID = Parser_Interface<W>::model_info->GlobalGEntityTable[nameID];
    676676                if (entityID == 0)
    677677                        WF_Error(wfErr_wf_entdeclared);
     
    679679                        this_info = Parser_Interface<W>::model_info->GEntityData[entityID-1];
    680680                        if (this_info->is_external){
    681                                
     681
    682682                        if (Parser_Interface<W>::entity_Info->standalone != Standalone_no)
    683683                                WF_Error(wfErr_NoExternalRefs);
     
    703703                        }
    704704                }
    705                
     705
    706706        }
    707707}
     
    717717                Advance(1);
    718718                Reference_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    719                
     719
    720720                //      The following code will replace Reference_Action.
    721721                GEntity_info * this_info;
    722722                Parser_Interface<W> * entity_parser;
    723                 int entityID = Parser_Interface<W>::model_info->GlobalGEntityTable[nameID]; 
     723                int entityID = Parser_Interface<W>::model_info->GlobalGEntityTable[nameID];
    724724                if (entityID == 0)
    725725                        WF_Error(wfErr_wf_entdeclared);
     
    727727                        this_info = Parser_Interface<W>::model_info->GEntityData[entityID-1];
    728728                        if (this_info->is_external){
    729                                
     729
    730730                        if (Parser_Interface<W>::entity_Info->standalone != Standalone_no)
    731731                                WF_Error(wfErr_NoExternalRefs);
     
    751751                        }
    752752                }
    753                
     753
    754754        }
    755755}
     
    765765                Advance(1);
    766766                Reference_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    767                
     767
    768768                //      The following code will replace Reference_Action.
    769769                GEntity_info * this_info;
    770770                Parser_Interface<W> * entity_parser;
    771                 int entityID = Parser_Interface<W>::model_info->GlobalGEntityTable[nameID]; 
     771                int entityID = Parser_Interface<W>::model_info->GlobalGEntityTable[nameID];
    772772                if (entityID == 0)
    773773                        WF_Error(wfErr_wf_entdeclared);
     
    775775                        this_info = Parser_Interface<W>::model_info->GEntityData[entityID-1];
    776776                        if (this_info->is_external){
    777                                
     777
    778778                        if (Parser_Interface<W>::entity_Info->standalone != Standalone_no)
    779779                                WF_Error(wfErr_NoExternalRefs);
     
    799799                        }
    800800                }
    801                
    802         }
    803 }
    804        
     801
     802        }
     803}
     804
    805805template <class B, WorkingCharacterSet W>
    806806void ParsingEngine<B, W>::Parse_CharRef() {
     
    825825        }
    826826        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF))
    827                                 WF_Error(wfErr_wf_Legalchar);   
     827                                WF_Error(wfErr_wf_Legalchar);
    828828                else  if (Parser_Interface<W>::entity_Info->version != XML_1_1)
    829829                        if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA)))
    830                                 WF_Error(wfErr_wf_Legalchar); 
    831                                
     830                                WF_Error(wfErr_wf_Legalchar);
     831
    832832        if (!AtChar<B::Base,';'>(cur())) {
    833833                        Syntax_Error(NT_CharRef);
     
    861861        PI_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    862862}
    863  
     863
    864864/* Parse a start or empty element tag. */
    865865template <class B, WorkingCharacterSet W>
     
    893893                        int att_nameID = Parse_Name();
    894894                        att_name_end = AbsPos();
    895                
     895
    896896                        int attID = Parser_Interface<W>::model_info->getOrInsertGlobalAttName(att_nameID);
    897897                        if (attID >= LastAttOccurrence.size()) LastAttOccurrence.push_back(0);
     
    900900                                        WF_Error(wfErr_uniqattspec); /* Duplicate attribute. */
    901901                                        break;
    902                                 }                       
     902                                }
    903903                        }
    904904                        LastAttOccurrence[attID] = att_name_start;
    905                         /* The following optimized tests handle the frequently occurring 
     905                        /* The following optimized tests handle the frequently occurring
    906906                        case that there are no blanks on either side of the equals sign.
    907907                        In many cases, the very first test handles 100% of actual
    908908                        attribute-value pairs encountered. */
    909                         if (at_EqualsQuote<B::Base>(cur())) Advance(1); 
     909                        if (at_EqualsQuote<B::Base>(cur())) Advance(1);
    910910                        else {
    911911                                ScanTo(NonWS);
    912912                                if (!AtChar<B::Base,'='>(cur())) {
    913                                         Syntax_Error(NT_STag); 
     913                                        Syntax_Error(NT_STag);
    914914                                        break;
    915915                                }
     
    917917                                ScanTo(NonWS);
    918918                                if (!AtQuote<B::Base>(cur())) {
    919                                         Syntax_Error(NT_STag); 
     919                                        Syntax_Error(NT_STag);
    920920                                        break;
    921921                                }
     
    954954                                break;
    955955                        }
    956                         else if (AbsPos() == att_val_end + 1) { 
     956                        else if (AbsPos() == att_val_end + 1) {
    957957                                /* No WS following att value */
    958958                                Syntax_Error(NT_STag);
     
    994994// void ParsingEngine<UTF8_Buffer, UTF_8>::Parse_WF_EndTag(int nameID) {
    995995//      Advance(2); /* Skip "</". */
    996 //     
     996//
    997997//      int name_start = AbsPos();
    998998// //   ScanTo(NameFollow);
    999999// //   int lgth = AbsPos()-name_start;
    1000 // 
     1000//
    10011001// #if (not defined(OMISSION)) or ((OMISSION != END_TAG_MATCHING)  and (OMISSION != NAME_LOOKUP))
    10021002//      char * start_elem_name = Parser_Interface<UTF_8>::model_info->symbol_table->Get_UTF8_name(nameID);
    10031003//      int lgth = Parser_Interface<UTF_8>::model_info->symbol_table->Get_UTF8_lgth(nameID);
    10041004//      char * end_elem_name = &((char *) x8data)[buffer_rel_pos];
    1005 //     
    1006 // #ifdef TEMPLATED_SIMD_LIB   
     1005//
     1006// #ifdef TEMPLATED_SIMD_LIB
    10071007//      BytePack byte_compare =  simd<8>::eq(sisd_load_unaligned((BytePack *) end_elem_name),
    10081008//                                                                 sisd_load_unaligned((BytePack *) start_elem_name));
    10091009// #endif
    1010 // #ifndef TEMPLATED_SIMD_LIB   
     1010// #ifndef TEMPLATED_SIMD_LIB
    10111011//      BytePack byte_compare =  simd_eq_8(sisd_load_unaligned((BytePack *) end_elem_name),
    10121012//                                                                 sisd_load_unaligned((BytePack *) start_elem_name));
     
    10511051//      }
    10521052//      Advance(lgth);
    1053 // 
     1053//
    10541054// #endif
    10551055// #if defined(OMISSION) and ((OMISSION == END_TAG_MATCHING) or (OMISSION == NAME_LOOKUP))
     
    10611061// //   }
    10621062// //   if (start_elem_name[lgth] != '\0') WF_Error(wfErr_GIMatch);
    1063 // 
     1063//
    10641064//      if (AtChar<ASCII,'>'>(cur())) {
    10651065//              Advance(1);
     
    10851085        unsigned char quoteCh;
    10861086        Advance(1);
    1087        
     1087
    10881088        #if (not defined(OMISSION)) or (OMISSION != NAME_LOOKUP)
    1089         int nameID = Parse_Name(); 
     1089        int nameID = Parse_Name();
    10901090        #endif
    10911091        #if (defined(OMISSION)) and (OMISSION == NAME_LOOKUP)
     
    11151115                        att_name_start = AbsPos();
    11161116                        #if (not defined(OMISSION)) or (OMISSION != NAME_LOOKUP)
    1117                         int att_nameID = Parse_Name(); 
     1117                        int att_nameID = Parse_Name();
    11181118                        #endif
    11191119                        #if (defined(OMISSION)) and (OMISSION == NAME_LOOKUP)
     
    11291129                                        WF_Error(wfErr_uniqattspec); /* Duplicate attribute. */
    11301130                                        break;
    1131                                 }                       
     1131                                }
    11321132                        }
    11331133                        LastAttOccurrence[attID] = att_name_start;
    11341134                 #endif
    1135                         /* The following optimized tests handle the frequently occurring 
     1135                        /* The following optimized tests handle the frequently occurring
    11361136                        case that there are no blanks on either side of the equals sign.
    11371137                        In many cases, the very first test handles 100% of actual
    11381138                        attribute-value pairs encountered. */
    1139                         if (at_EqualsQuote<B::Base>(cur())) Advance(1); 
     1139                        if (at_EqualsQuote<B::Base>(cur())) Advance(1);
    11401140                        else {
    11411141                                ScanTo(NonWS);
    11421142                                if (!AtChar<B::Base,'='>(cur())) {
    1143                                         Syntax_Error(NT_STag); 
     1143                                        Syntax_Error(NT_STag);
    11441144                                        break;
    11451145                                }
     
    11471147                                ScanTo(NonWS);
    11481148                                if (!AtQuote<B::Base>(cur())) {
    1149                                         Syntax_Error(NT_STag); 
     1149                                        Syntax_Error(NT_STag);
    11501150                                        break;
    11511151                                }
     
    11701170                        else if (at_EmptyElementDelim<B::Base>(cur())) {
    11711171                                Advance(2);
    1172                                 is_emptyStartTag = true;       
     1172                                is_emptyStartTag = true;
    11731173                                EmptyElement_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    11741174                                break;
     
    11861186                                break;
    11871187                        }
    1188                         else if (AbsPos() == att_val_end + 1) { 
     1188                        else if (AbsPos() == att_val_end + 1) {
    11891189                                /* No WS following att value */
    11901190                                Syntax_Error(NT_STag);
     
    12691269template <class B, WorkingCharacterSet W>
    12701270void ParsingEngine<B, W>::ParseContent() {
    1271         Parser_Interface<W>::DocumentStart_action();   
     1271        Parser_Interface<W>::DocumentStart_action();
    12721272        bool is_emptyStartTag = false;
    12731273        do {
     
    13231323                }
    13241324        } while (1);
    1325         Parser_Interface<W>::DocumentEnd_action();     
     1325        Parser_Interface<W>::DocumentEnd_action();
    13261326}
    13271327#endif
     
    13341334        ScanTo(NonWS);
    13351335        start_pos = AbsPos();
    1336        
     1336
    13371337        if (at_DOCTYPE_start<B::Base>(cur()))
    13381338        Advance(9);
     
    13441344        int nameID = Parse_Name();
    13451345
    1346         old_abspos = AbsPos(); 
     1346        old_abspos = AbsPos();
    13471347    ScanTo(NonWS);
    13481348    if(at_SYSTEM<B::Base>(cur())||at_PUBLIC<B::Base>(cur())){
     
    13571357    }
    13581358    else Parser_Interface<W>::model_info->has_external_DTD = false;
    1359     ScanTo(NonWS);     
     1359    ScanTo(NonWS);
    13601360
    13611361        if (AtChar<B::Base,'['>(cur())){
     
    13681368                ScanTo(NonWS);
    13691369        }
    1370        
     1370
    13711371        if (AtChar<B::Base,'>'>(cur())){
    1372                 Advance(1); 
     1372                Advance(1);
    13731373
    13741374                CRE_Seq * rslt = new CRE_Seq();
    13751375                rslt->subCMs.push_back(new CRE_Name(nameID));
    13761376                CM_RegExp * cre = new CM_RegExp();
    1377                 cre->content_re = rslt;         
    1378                
     1377                cre->content_re = rslt;
     1378
    13791379                int id_count = cre->content_re->Set_IDs(0);
    1380                 cre->content_re->Set_First_Map();               
     1380                cre->content_re->Set_First_Map();
    13811381                symbol_set_t * transition_map = new symbol_set_t[id_count+1];
    13821382                cre->content_re->follow_map[0] = id_count+1;
    1383                
     1383
    13841384                cre->content_re->Set_Follow_Map(transition_map);
    13851385                transition_map[0] = cre->content_re->first_map;
    13861386                if (cre->content_re->matches_empty)
    13871387                        transition_map[0][0]=id_count+1;
    1388                        
     1388
    13891389                cre -> transition_map = transition_map;
    1390                
     1390
    13911391                Parser_Interface<W>::model_info->rootModel = cre;
    1392                
     1392
    13931393                /* Check for notations that were used, but not defined by the end of the DTD. */
    13941394                #if (VALIDATION_MODE == ON)
     
    14011401        }
    14021402        else
    1403                 Syntax_Error(NT_doctypedecl);   
     1403                Syntax_Error(NT_doctypedecl);
    14041404}
    14051405
     
    14141414                quot_start = AbsPos()+1;
    14151415                Parse_SystemLiteral (); /*  SystemLiteral */
    1416                 lgth = AbsPos() - quot_start - 1;                       
     1416                lgth = AbsPos() - quot_start - 1;
    14171417                systemLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
    14181418        }
     
    14231423                quot_start = AbsPos()+1;
    14241424                Parse_PubidLiteral ();/*  PubidLiteral */
    1425                 lgth = AbsPos() - quot_start - 1;                       
     1425                lgth = AbsPos() - quot_start - 1;
    14261426                pubidLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
    14271427                systemLiteral = NULL;
     
    14291429                requireWS();
    14301430                if (AtQuote<B::Base>(cur())) {
    1431                         quot_start = AbsPos()+1;       
     1431                        quot_start = AbsPos()+1;
    14321432                        Parse_SystemLiteral ();/*  SystemLiteral */
    1433                         lgth = AbsPos() - quot_start - 1;                       
     1433                        lgth = AbsPos() - quot_start - 1;
    14341434                        systemLiteral = copy_string(GetCodeUnitPtr(quot_start),lgth);
    14351435                }
    14361436        }
    14371437        else
    1438                 Syntax_Error(NT_ExternalID); 
     1438                Syntax_Error(NT_ExternalID);
    14391439}
    14401440
     
    14451445                quoteCh = cur()[0];
    14461446                Advance(1);
    1447         }       
    1448         ScanTo(Quote);                 
     1447        }
     1448        ScanTo(Quote);
    14491449        while (cur()[0] != quoteCh){
    14501450                if(at_EOF())
     
    14721472template <class B, WorkingCharacterSet W>
    14731473void ParsingEngine<B, W>::Parse_IntSubset (){
    1474        
     1474
    14751475        while(1){
    1476                 ScanTo(NonWS); 
     1476                ScanTo(NonWS);
    14771477                text_or_markup_start = AbsPos();
    14781478                if (AtChar<B::Base,'%'>(cur()))
    1479                         Parse_PEReference();   
     1479                        Parse_PEReference();
    14801480                else if (at_PI_Start<B::Base>(cur())) {
    14811481                        Parse_PI();
     
    14971497                                        Parse_Notationdecl();
    14981498                                else {
    1499                                         Syntax_Error(NT_markupdecl);           
    1500                                 }                                                               
     1499                                        Syntax_Error(NT_markupdecl);
     1500                                }
    15011501                        }
    15021502                        else
    1503                                 Syntax_Error(NT_markupdecl); 
     1503                                Syntax_Error(NT_markupdecl);
    15041504                }
    15051505                else if (AtChar<B::Base,']'>(cur())){
     
    15071507                }
    15081508                else
    1509                         Syntax_Error(NT_intSubset); 
     1509                        Syntax_Error(NT_intSubset);
    15101510        }
    15111511}
     
    15181518        fprintf(stderr,"Parameter Reference has not been completed yet.\n");
    15191519        exit(-1);
    1520         int nameID = Parse_Name(); 
     1520        int nameID = Parse_Name();
    15211521        if (AtChar<B::Base,';'>(cur())) {
    15221522                Advance(1);
     
    15241524                PEntity_info * this_info;
    15251525                Parser_Interface<W> * entity_parser;
    1526                 int entityID = Parser_Interface<W>::model_info->GlobalPEntityTable[nameID]; 
     1526                int entityID = Parser_Interface<W>::model_info->GlobalPEntityTable[nameID];
    15271527                if (entityID == 0)
    15281528                        WF_Error(wfErr_wf_entdeclared);
     
    15301530                        this_info = Parser_Interface<W>::model_info->PEntityData[entityID-1];
    15311531                        if (this_info->is_external){
    1532                                
     1532
    15331533//                      if (Parser_Interface<W>::entity_Info->standalone != Standalone_no)
    15341534//                              WF_Error(wfErr_NoExternalRefs);
     
    15861586
    15871587                        int id_count = cre->content_re->Set_IDs(0);
    1588                         cre->content_re->Set_First_Map();       
     1588                        cre->content_re->Set_First_Map();
    15891589                        symbol_set_t * transition_map = new symbol_set_t[id_count+1];
    15901590                        cre->content_re->follow_map[0] = id_count+1;
    1591                        
     1591
    15921592                        cre->content_re->Set_Follow_Map(transition_map);
    15931593                        transition_map[0] = cre->content_re->first_map;
    1594                        
     1594
    15951595                        if (cre->content_re->matches_empty)
    15961596                                transition_map[0][0]=id_count+1;
    1597                                
     1597
    15981598                        cre -> transition_map = transition_map;
    1599                        
     1599
    16001600                        Parser_Interface<W>::model_info->ContentModelData[nameID] = cre;
    16011601                        cm = cre;
    1602                 }                       
     1602                }
    16031603    }
    1604     ScanTo(NonWS);   
     1604    ScanTo(NonWS);
    16051605
    16061606        if (AtChar<B::Base,'>'>(cur())) {
     
    16141614        CM_Mixed * r = new CM_Mixed();
    16151615        Advance(7);  /* Skip "#PCDATA". */
    1616    
     1616
    16171617    if (AtChar<B::Base,')'>(cur())){
    16181618        if (AtChar<B::Base,'*'>(cur())) {
     
    16871687                rslt->Compile();
    16881688                r = rslt;
    1689         }       
     1689        }
    16901690        else if(AtChar<B::Base,')'>(cur())){
    16911691                Advance(1);
     
    16931693        else
    16941694                Syntax_Error(NT_children);
    1695                
     1695
    16961696        if (AtChar<B::Base,'?'>(cur())) {
    16971697                Advance(1);
     
    17391739template <class B, WorkingCharacterSet W>
    17401740void ParsingEngine<B, W>::Parse_AttlistDecl (){
    1741        
     1741
    17421742        int old_abspos;
    1743        
     1743
    17441744        int name_start;
    17451745        int lgth;
    1746        
     1746
    17471747        int elemID;
    17481748        int attID;
    1749        
     1749
    17501750        Advance(7); /* Skip "ATTLIST. */
    17511751        requireWS();
    1752        
     1752
    17531753        int nameID = Parse_Name();
    17541754        elemID = Parser_Interface<W>::model_info->getOrInsertGlobalElement(nameID);
    1755        
     1755
    17561756        old_abspos = AbsPos();
    17571757        ScanTo(NonWS);
     
    17591759                if(old_abspos == AbsPos())
    17601760                Syntax_Error(NT_AttlistDecl);
    1761                
     1761
    17621762                int att_nameID = Parse_Name();
    1763                
     1763
    17641764                attID = Parser_Interface<W>::model_info->getOrInsertGlobalAttName(att_nameID);
    17651765                if (attID >= LastAttOccurrence.size()) LastAttOccurrence.push_back(0);
     
    18321832                Syntax_Error(NT_NotationType);
    18331833        ScanTo(NonWS);
    1834        
     1834
    18351835    int notn_nameID = Parse_Name();
    18361836
     
    18381838        if(Parser_Interface<W>::model_info->GlobalNotationTable[notn_nameID]==0)
    18391839                Parser_Interface<W>::model_info->GlobalNotationTable[notn_nameID] = -1;
    1840        
     1840
    18411841        ScanTo(NonWS);
    18421842        while(AtChar<B::Base,'|'>(cur())){
    18431843                Advance(1);
    1844                 ScanTo(NonWS); 
     1844                ScanTo(NonWS);
    18451845                notn_nameID = Parse_Name();
    1846                        
     1846
    18471847                if(Parser_Interface<W>::model_info->GlobalNotationTable[notn_nameID]==0)
    18481848//                      Validity_Error(vErr_notatn);
    18491849                        Parser_Interface<W>::model_info->GlobalNotationTable[notn_nameID] = -1;
    1850                        
     1850
    18511851                ScanTo(NonWS);
    18521852        }
    1853         if (AtChar<B::Base,')'>(cur())) 
     1853        if (AtChar<B::Base,')'>(cur()))
    18541854                Advance(1);
    18551855        else
     
    18661866                Syntax_Error(NT_Enumeration);
    18671867        ScanTo(NonWS);
    1868        
     1868
    18691869        int nmtokenID = Parse_Nmtoken();
    1870        
     1870
    18711871        this_info->enumValues[nmtokenID]=++(enumCount);
    1872        
     1872
    18731873        ScanTo(NonWS);
    18741874        while(AtChar<B::Base,'|'>(cur())){
    18751875                Advance(1);
    1876                 ScanTo(NonWS); 
     1876                ScanTo(NonWS);
    18771877                int nmtokenID = Parse_Nmtoken();
    1878        
     1878
    18791879                int enumID = this_info->enumValues[nmtokenID];
    1880                 if(enumID==0){ 
     1880                if(enumID==0){
    18811881                        this_info->enumValues[nmtokenID]=++(enumCount);
    18821882                        enumID = enumCount;
     
    18871887                ScanTo(NonWS);
    18881888        }
    1889         if (AtChar<B::Base,')'>(cur())) 
     1889        if (AtChar<B::Base,')'>(cur()))
    18901890                Advance(1);
    18911891        else
     
    19151915                        /* need to normalize */
    19161916                        this_info->defaultValueLgth = AbsPos() - quot_start - 1;
    1917                        
     1917
    19181918                        this_info->defaultValue = new unsigned char[this_info->defaultValueLgth+1];
    1919                         memcpy(this_info->defaultValue, GetCodeUnitPtr(quot_start),this_info->defaultValueLgth); 
     1919                        memcpy(this_info->defaultValue, GetCodeUnitPtr(quot_start),this_info->defaultValueLgth);
    19201920                        this_info->defaultValue[this_info->defaultValueLgth] = '\0';
    19211921                        }
     
    19271927template <class B, WorkingCharacterSet W>
    19281928void ParsingEngine<B, W>::Parse_Entitydecl (){
    1929        
     1929
    19301930        int name_start;
    19311931        int quot_start;
     
    19331933        int old_abspos;
    19341934        char * s;
    1935        
     1935
    19361936        Advance(6); /* Skip "ENTITY. */
    19371937        requireWS();
    1938        
     1938
    19391939        if (AtChar<B::Base,'%'>(cur())){
    19401940                Advance(1);
    19411941                requireWS();
    1942                
     1942
    19431943                int nameID = Parse_Name();
    19441944                PEntity_info * this_info = new PEntity_info;
    19451945                int entityID = Parser_Interface<W>::model_info->GlobalPEntityTable[nameID];
    1946                 if(entityID==0){       
     1946                if(entityID==0){
    19471947                        Parser_Interface<W>::model_info->GlobalPEntityTable[nameID]=++(Parser_Interface<W>::model_info->globalPEntityCount);
    19481948                        entityID = Parser_Interface<W>::model_info->globalPEntityCount;
     
    19511951                else
    19521952                        printf("Warning: Entity definition already exist!\n");
    1953        
     1953
    19541954                requireWS();
    19551955                if(AtQuote<B::Base>(cur())){
     
    19661966        else{
    19671967                int nameID = Parse_Name();
    1968        
     1968
    19691969                GEntity_info * this_info = new GEntity_info();
    19701970                int entityID = Parser_Interface<W>::model_info->GlobalGEntityTable[nameID];
    1971                 if(entityID==0){       
     1971                if(entityID==0){
    19721972                        Parser_Interface<W>::model_info->GlobalGEntityTable[nameID]=++(Parser_Interface<W>::model_info->globalGEntityCount);
    19731973                        entityID = Parser_Interface<W>::model_info->globalGEntityCount;
     
    19761976                else
    19771977                        printf("Warning: Entity definition already exists!\n");
    1978                        
     1978
    19791979                requireWS();
    1980                
     1980
    19811981                if(AtQuote<B::Base>(cur())){
    1982                 Parse_GEntityValue(this_info);                 
     1982                Parse_GEntityValue(this_info);
    19831983                this_info->is_external = false;
    19841984        }
     
    20172017        Advance(8); /* Skip "NOTATION. */
    20182018        requireWS();
    2019        
     2019
    20202020        int nameID = Parse_Name();
    20212021
    20222022        int notationID = Parser_Interface<W>::model_info->GlobalNotationTable[nameID];
    20232023        /* notationID == -1: used but not yet defined; == 0: new, > 0 prev. defined */
    2024         if(notationID <= 0){   
     2024        if(notationID <= 0){
    20252025                Parser_Interface<W>::model_info->GlobalNotationTable[nameID]=++(Parser_Interface<W>::model_info->globalNotationCount);
    20262026                notationID = Parser_Interface<W>::model_info->globalNotationCount;
     
    20292029                Validity_Error(vErr_NoDuplicateTokens);
    20302030        Notation_info * this_info = new Notation_info;
    2031         ScanTo(NonWS);         
     2031        ScanTo(NonWS);
    20322032    Parse_ExternalID(this_info->systemLiteral, this_info->pubidLiteral);
    20332033        ScanTo(NonWS);
     
    20412041template <class B, WorkingCharacterSet W>
    20422042void ParsingEngine<B, W>::requireWS(){
    2043        
    2044     int old_abspos = AbsPos(); 
     2043
     2044    int old_abspos = AbsPos();
    20452045    ScanTo(NonWS);
    20462046    if(old_abspos == AbsPos())
     
    20502050template <class B, WorkingCharacterSet W>
    20512051void ParsingEngine<B, W>::Parse_AttValue(){
    2052        
     2052
    20532053        int     quoteCh = cur()[0];
    20542054        Advance(1); /* Skip " or ' */
    20552055
    2056         ScanTo(Quote);                 
     2056        ScanTo(Quote);
    20572057        while (cur()[0] != quoteCh){
    20582058                if (at_CharRef_Start<B::Base>(cur())){
     
    20762076template <class B, WorkingCharacterSet W>
    20772077void ParsingEngine<B, W>::Parse_GEntityValue(GEntity_info * this_info){
    2078        
     2078
    20792079        int     quoteCh = cur()[0];
    20802080        Advance(1); /* Skip " or ' */
     
    20822082        int quot_start = AbsPos();
    20832083        char * replText;
    2084         ScanTo(Quote);         
     2084        ScanTo(Quote);
    20852085        replText = copy_string(GetCodeUnitPtr(quot_start),AbsPos()-quot_start);
    20862086        while (cur()[0] != quoteCh){
     
    21022102                        Advance(1);
    21032103                        ScanTo(Quote);
    2104                         this_info->is_simple = false;                   
     2104                        this_info->is_simple = false;
    21052105                }
    21062106                replText = cat_string (replText,(char *)GetCodeUnitPtr(quot_start), strlen(replText), AbsPos()-quot_start);
     
    21132113char * ParsingEngine<B, W>::Replace_EntityRef(bool& is_simple){
    21142114        Advance(1);
    2115         int nameID = Parse_Name(); 
     2115        int nameID = Parse_Name();
    21162116        if (AtChar<B::Base,';'>(cur()))
    21172117                Advance(1);
    21182118        else
    21192119                Syntax_Error(NT_EntityValue);
    2120         int entityID = Parser_Interface<W>::model_info->GlobalGEntityTable[nameID]; 
     2120        int entityID = Parser_Interface<W>::model_info->GlobalGEntityTable[nameID];
    21212121        if (entityID == 0)
    21222122                WF_Error(wfErr_wf_entdeclared);
     
    21262126                return Parser_Interface<W>::model_info->GEntityData[entityID-1]->ReplacementText;
    21272127        }
    2128        
     2128
    21292129}
    21302130
     
    21462146        ScanTo(NonWS);
    21472147        int old_pos = AbsPos();
    2148         while (!at_DOCTYPE_start<B::Base>(cur())) {             
     2148        while (!at_DOCTYPE_start<B::Base>(cur())) {
    21492149                text_or_markup_start = AbsPos();
    2150                 if (at_Comment_Start<B::Base>(cur())) 
     2150                if (at_Comment_Start<B::Base>(cur()))
    21512151                        Parse_Comment();
    21522152                else if (at_PI_Start<B::Base>(cur()))
     
    21602160        Parse_DocType();
    21612161        ScanTo(NonWS);
    2162         while(at_Comment_Start<B::Base>(cur()) || at_PI_Start<B::Base>(cur()) ){               
     2162        while(at_Comment_Start<B::Base>(cur()) || at_PI_Start<B::Base>(cur()) ){
    21632163                text_or_markup_start = AbsPos();
    21642164                if (at_Comment_Start<B::Base>(cur()))
    21652165                        Parse_Comment();
    2166                 else 
     2166                else
    21672167                        Parse_PI();
    21682168                ScanTo(NonWS);
     
    21762176        int start_pos=AbsPos();
    21772177        while(!at_EOF()){
    2178                 if(at_condSect_start<B::Base>(cur())){         
     2178                if(at_condSect_start<B::Base>(cur())){
    21792179                        Advance(3);
    21802180                        ScanTo(NonWS);
     
    21932193                        else if (at_IGNORE<B::Base>(cur())){
    21942194                                Advance(6);
    2195                                 ScanTo(NonWS);         
     2195                                ScanTo(NonWS);
    21962196                                if(AtChar<B::Base,'['>(cur())){
    21972197                                        int section_depth=1;
     
    22092209                                                else
    22102210                                                        Advance(1);
    2211                                                 if(section_depth==0) return;                                   
     2211                                                if(section_depth==0) return;
    22122212                                        }
    2213                                         Syntax_Error(NT_ignoreSectContents);   
     2213                                        Syntax_Error(NT_ignoreSectContents);
    22142214                                }
    22152215                                else Syntax_Error(NT_ignoreSect);
     
    22182218                }
    22192219                else if (AtChar<B::Base,'%'>(cur()))
    2220                         Parse_PEReference();   
     2220                        Parse_PEReference();
    22212221                else if (at_PI_Start<B::Base>(cur())) {
    22222222                        Parse_PI();
     
    22372237                                        Parse_Entitydecl();
    22382238                                else if(at_NOTATION<B::Base>(cur()))
    2239                                         Parse_Notationdecl();                                   
     2239                                        Parse_Notationdecl();
    22402240                                else{
    2241                                         Syntax_Error(NT_markupdecl);   
    2242                                 }                                                               
     2241                                        Syntax_Error(NT_markupdecl);
     2242                                }
    22432243                        }
    22442244                        else
    2245                                 Syntax_Error(NT_markupdecl); 
     2245                                Syntax_Error(NT_markupdecl);
    22462246                }
    22472247                else
    2248                         Syntax_Error(NT_extSubsetDecl); 
     2248                        Syntax_Error(NT_extSubsetDecl);
    22492249                ScanTo(NonWS);
    22502250        }
     
    22612261        Advance(1);
    22622262
    2263         int nameID = Parse_Name(); 
     2263        int nameID = Parse_Name();
    22642264        int elemID = Parser_Interface<W>::model_info->GlobalElementTable[nameID];
    22652265        if(elemID==0)
    22662266                        Validity_Error(vErr_elementvalid);
    2267        
     2267
    22682268        ElementName_action(GetCodeUnitPtr(text_or_markup_start+1), LengthFrom(text_or_markup_start+1));
    22692269        /* The following test optimizes the most common case of a
     
    22882288                        att_name_start = AbsPos();
    22892289                        int att_nameID = Parse_Name();
    2290                         #if (not defined(OMISSION)) or (OMISSION != ATTRIBUTE_UNIQUENESS) 
     2290                        #if (not defined(OMISSION)) or (OMISSION != ATTRIBUTE_UNIQUENESS)
    22912291                        int attID = Parser_Interface<W>::model_info->getOrInsertGlobalAttName(att_nameID);
    22922292                        if (attID >= LastAttOccurrence.size()) LastAttOccurrence.push_back(0);
     
    22952295                                        WF_Error(wfErr_uniqattspec); /* Duplicate attribute. */
    22962296                                        break;
    2297                                 }                       
     2297                                }
    22982298                        }
    22992299                        LastAttOccurrence[attID] = att_name_start;
    23002300                        #endif
    2301                         /* The following optimized tests handle the frequently occurring 
     2301                        /* The following optimized tests handle the frequently occurring
    23022302                        case that there are no blanks on either side of the equals sign.
    23032303                        In many cases, the very first test handles 100% of actual
    23042304                        attribute-value pairs encountered. */
    2305                         if (at_EqualsQuote<B::Base>(cur())) Advance(1); 
     2305                        if (at_EqualsQuote<B::Base>(cur())) Advance(1);
    23062306                        else {
    23072307                                ScanTo(NonWS);
    23082308                                if (!AtChar<B::Base,'='>(cur())) {
    2309                                         Syntax_Error(NT_STag); 
     2309                                        Syntax_Error(NT_STag);
    23102310                                        break;
    23112311                                }
    2312                                 Advance(1); 
     2312                                Advance(1);
    23132313                                ScanTo(NonWS);
    23142314                                if (!AtQuote<B::Base>(cur())) {
    2315                                         Syntax_Error(NT_STag); 
     2315                                        Syntax_Error(NT_STag);
    23162316                                        break;
    23172317                                }
     
    23362336                        else if (at_EmptyElementDelim<B::Base>(cur())) {
    23372337                                Advance(2);
    2338                                 is_emptyStartTag = true;       
     2338                                is_emptyStartTag = true;
    23392339                                EmptyElement_action(GetCodeUnitPtr(text_or_markup_start), LengthFrom(text_or_markup_start));
    23402340                                break;
     
    23522352                                break;
    23532353                        }
    2354                         else if (AbsPos() == att_val_end + 1) { 
     2354                        else if (AbsPos() == att_val_end + 1) {
    23552355                                /* No WS following att value */
    23562356                                Syntax_Error(NT_STag);
     
    23812381                        }
    23822382                        break;
    2383                 case cm_Any:           
     2383                case cm_Any:
    23842384                        if (!is_emptyStartTag) {
    23852385                                Parse_AnyContent();
     
    23872387                        }
    23882388                        break;
    2389                 case cm_Mixed:         
     2389                case cm_Mixed:
    23902390                        if (!is_emptyStartTag) {
    23912391                                Parse_MixedContent(((CM_Mixed *) cm)->elements);
     
    24012401                                printf("Final content_state = %i, nameID = %i\n", content_state, nameID);
    24022402                                #endif
    2403                                 Parse_WF_EndTag(nameID);               
     2403                                Parse_WF_EndTag(nameID);
    24042404                        }
    24052405                        if (cre->transition_map[content_state][0]==0) {
     
    24402440                        printf("EntityRef complete, cur_state = %i\n", cur_state);
    24412441#endif
    2442                        
     2442
    24432443                }
    24442444                else if (at_EOF()) {
     
    26512651template <class B, WorkingCharacterSet W>
    26522652void ParsingEngine<B, W>::Parse_DocumentContent() {
    2653         Parser_Interface<W>::DocumentStart_action();   
     2653        Parser_Interface<W>::DocumentStart_action();
    26542654#if (VALIDATION_MODE == ON)
    26552655        int cur_state = 0;
     
    26652665                if (at_Comment_Start<B::Base>(cur()))
    26662666                        Parse_Comment();
    2667                 else 
     2667                else
    26682668                        Parse_PI();
    26692669                ScanTo(NonWS);
     
    26712671        if (!at_EOF()) {
    26722672                Syntax_Error(NT_document);
    2673         }       
     2673        }
    26742674#endif
    2675         Parser_Interface<W>::DocumentEnd_action();     
     2675        Parser_Interface<W>::DocumentEnd_action();
    26762676}
    26772677
     
    26842684        int charref_code = 0;
    26852685        int general_ref_code = 0;
    2686         DocumentStart_action(); 
     2686        DocumentStart_action();
    26872687        bool is_emptyStartTag = false;
    26882688        do {
     
    27122712        printf("general_ref_code: %i\n", general_ref_code);
    27132713        printf("charref_code: %i\n", charref_code);
    2714         DocumentEnd_action();   
     2714        DocumentEnd_action();
    27152715}
    27162716#endif
     
    27402740        int general_ref_code = 0;
    27412741
    2742         DocumentStart_action(); 
     2742        DocumentStart_action();
    27432743        bool is_emptyStartTag = false;
    27442744                for (int i = 0; i < 4; i++) MarkupCounts[i] = 0;
     
    27842784                                else break;
    27852785                        }
    2786                        
     2786
    27872787                }
    27882788
     
    28052805        printf("general_ref_code: %i\n", general_ref_code);
    28062806        printf("charref_code: %i\n", charref_code);
    2807         DocumentEnd_action();   
     2807        DocumentEnd_action();
    28082808}
    28092809
Note: See TracChangeset for help on using the changeset viewer.