Changeset 267


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.

Location:
trunk/src
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/bitlex.c

    r262 r267  
    7373                        else EncodingError("8-bit", e->encoding, lgth);
    7474                case DoubleByte:
    75                         if (e->BOM_units == 1) 
     75                        if (e->BOM_units == 1)
    7676                                if ((lgth == 6) && at_UTF_16(e->encoding))
    7777                                        return new UTF_16_Lexer(e, l);
     
    9292                                else EncodingError("16LE", e->encoding, lgth);
    9393                case QuadByte:
    94                         if (e->BOM_units == 1) 
     94                        if (e->BOM_units == 1)
    9595                                if ((lgth == 6) && at_UTF_32(e->encoding))
    9696                                        return new UTF_32_Lexer(e, l);
     
    274274        BitBlock Control, WS;
    275275        for (int i = 0; i < buffer_blocks; i++) {
    276                 WS_Control_Blocks<C>(x8basis[i].bit, 
     276                WS_Control_Blocks<C>(x8basis[i].bit,
    277277                                     WS,
    278278                                     Control);
     
    287287static inline void ComputeLexicalItemBlocks(BitBlock bit[], BitBlock LexItem[]);
    288288
    289 /* Given the bit[] array of one BitBlock each for the 8 bits of 
     289/* Given the bit[] array of one BitBlock each for the 8 bits of
    290290   an ASCII-family character representation, compute the parallel
    291291   lexical item streams needed for XML parsing.
     
    382382        negated forms ensures that a potential CD_End is not ruled
    383383        out at the block boundary. */
    384         LexItem[CD_End_check] = simd_andc(RBracket, 
     384        LexItem[CD_End_check] = simd_andc(RBracket,
    385385                                          simd_or(sisd_sbli(simd_not(RBracket), 1),
    386386                                                  sisd_sbli(simd_not(RAngle), 2)));
     
    528528  BitBlock temp126 = simd_and(temp115, temp95);
    529529  BitBlock Hex = simd_or(temp125, temp126);
    530        
     530
    531531  LexItem[NonDigit] = simd_not(Digit);
    532532  LexItem[NonHex] = simd_not(Hex);
    533533
    534 #endif 
    535        
     534#endif
     535
    536536        /* Mark potential occurrences of ']]>'  These are all actual
    537537        occurrences of ]]> as well as occurrences of ]] or ] at
     
    539539        negated forms ensures that a potential CD_End is not ruled
    540540        out at the block boundary. */
    541         LexItem[CD_End_check] = simd_andc(RBracket, 
     541        LexItem[CD_End_check] = simd_andc(RBracket,
    542542                                          simd_or(sisd_sbli(simd_not(RBracket), 1),
    543543                                                  sisd_sbli(simd_not(RAngle), 2)));
     
    569569        }
    570570        for (int i = 0; i < buffer_blocks; i++) {
    571                 parsing_engine_data->item_stream[NameFollow][i] = 
     571                parsing_engine_data->item_stream[NameFollow][i] =
    572572                        simd_or(parsing_engine_data->item_stream[NameFollow][i],
    573573                                simd_not(parsing_engine_data->item_stream[NonWS][i]));
     
    581581        /*  UTF-8 sequences may cross block boundaries.  If a
    582582            prefix is found near the end of a block that requires
    583             one or more suffixes in the next block, then 
     583            one or more suffixes in the next block, then
    584584            prefix_pending is set to mark the positions.
    585585            However, at the beginning of the buffer, no suffixes
     
    587587#ifdef TEMPLATED_SIMD_LIB
    588588        BitBlock prefix_pending = simd<1>::constant<0>();
    589         /*  If a suffix is pending, then it may involve one of 
     589        /*  If a suffix is pending, then it may involve one of
    590590            the special case prefixes E0, ED. F0, F4, or the
    591591            EF prefix or EF_BF combination for FFFF/FFFE detection.*/
     
    598598#ifndef TEMPLATED_SIMD_LIB
    599599        BitBlock prefix_pending = simd_const_1(0);
    600         /*  If a suffix is pending, then it may involve one of 
     600        /*  If a suffix is pending, then it may involve one of
    601601            the special case prefixes E0, ED. F0, F4, or the
    602602            EF prefix or EF_BF combination for FFFF/FFFE detection.*/
     
    609609        /* Temporary variables used within the block. */
    610610        BitBlock suffix_required_scope;
    611         BitBlock prefix_E0ED, E0ED_scope, bit5_scope, E0ED_constraint; 
    612         BitBlock prefix_F5FF, prefix_F0F4, F0F4_scope, F0F4_constraint; 
     611        BitBlock prefix_E0ED, E0ED_scope, bit5_scope, E0ED_constraint;
     612        BitBlock prefix_F5FF, prefix_F0F4, F0F4_scope, F0F4_constraint;
    613613        BitBlock X111x, B111x, prefix_EF, BF, EF_BF, EF_scope, EF_BF_scope;
    614614
     
    633633
    634634                /*  Initiate validation for two-byte sequences. */
    635                 error_mask = simd_andc(u8prefix2, 
     635                error_mask = simd_andc(u8prefix2,
    636636                                        simd_or(simd_or(x8basis[i].bit[3], x8basis[i].bit[4]),
    637637                                                simd_or(x8basis[i].bit[5], x8basis[i].bit[6])));
     
    669669                if (bitblock_has_bit(u8prefix3or4)) {
    670670                        /*  Extend validation for errors in three-byte sequences. */
    671                         suffix_required_scope = simd_or(suffix_required_scope, 
     671                        suffix_required_scope = simd_or(suffix_required_scope,
    672672                                                        sisd_sfli(u8prefix3or4, 2));
    673673                        bit5_scope = simd_or(bit5_scope, sisd_sfli(x8basis[i].bit[5], 1));
    674674                        prefix_E0ED = simd_andc(u8prefix3,
    675                                                 simd_or(simd_or(x8basis[i].bit[6], 
     675                                                simd_or(simd_or(x8basis[i].bit[6],
    676676                                                                simd_xor(x8basis[i].bit[4], x8basis[i].bit[7])),
    677677                                                        simd_xor(x8basis[i].bit[4], x8basis[i].bit[5])));
     
    684684                        prefix_pending = simd_or(prefix_pending,
    685685                                                 sisd_sbli(u8prefix3or4, BLOCKSIZE - 2));
    686                         bit5_pending = sisd_sbli(x8basis[i].bit[5], BLOCKSIZE - 1); 
    687                         E0ED_pending = sisd_sbli(prefix_E0ED, BLOCKSIZE - 1); 
     686                        bit5_pending = sisd_sbli(x8basis[i].bit[5], BLOCKSIZE - 1);
     687                        E0ED_pending = sisd_sbli(prefix_E0ED, BLOCKSIZE - 1);
    688688                        EF_pending = sisd_sbli(prefix_EF, BLOCKSIZE - 1);
    689689                        EF_BF_pending = sisd_sbli(EF_BF, BLOCKSIZE - 2);
    690690                        if (bitblock_has_bit(u8prefix4)) {
    691691                                /*  Extend validation for errors in four-byte sequences. */
    692                                 suffix_required_scope = simd_or(suffix_required_scope, 
     692                                suffix_required_scope = simd_or(suffix_required_scope,
    693693                                                                sisd_sfli(u8prefix4, 3));
    694694                                prefix_pending = simd_or(prefix_pending,
    695695                                                         sisd_sbli(u8prefix4, BLOCKSIZE - 3));
    696                                 prefix_F5FF = simd_and(u8prefix4, 
     696                                prefix_F5FF = simd_and(u8prefix4,
    697697                                                       simd_or(x8basis[i].bit[4],
    698698                                                                simd_and(x8basis[i].bit[5],
    699699                                                                        simd_or(x8basis[i].bit[6], x8basis[i].bit[7]))));
    700700                                error_mask = simd_or(error_mask, prefix_F5FF);
    701                                 prefix_F0F4 = simd_andc(u8prefix4, 
    702                                                         simd_or(x8basis[i].bit[4], 
     701                                prefix_F0F4 = simd_andc(u8prefix4,
     702                                                        simd_or(x8basis[i].bit[4],
    703703                                                                simd_or(x8basis[i].bit[6], x8basis[i].bit[7])));
    704704                                F0F4_scope = simd_or(F0F4_scope, sisd_sfli(prefix_F0F4, 1));
     
    708708                E0ED_constraint = simd_xor(bit5_scope, x8basis[i].bit[2]);
    709709                error_mask = simd_or(error_mask, simd_andc(E0ED_scope, E0ED_constraint));
    710                 F0F4_constraint = simd_xor(bit5_scope, 
     710                F0F4_constraint = simd_xor(bit5_scope,
    711711                                           simd_or(x8basis[i].bit[2], x8basis[i].bit[3]));
    712712                error_mask = simd_or(error_mask, simd_andc(F0F4_scope, F0F4_constraint));
     
    985985//              print_bit_block("validation_stream[err_pos/128]", validation_stream[err_pos/128]);
    986986
    987                 CharSetValidationError((char *) entity_Info->encoding, lexer_base_pos + err_pos);
     987                CharSetValidationError((const char *) entity_Info->encoding, lexer_base_pos + err_pos);
    988988        }
    989989#if defined(PAPI) and defined(CODE_CLOCKING) and (CODE_CLOCKING == CHARSET_VALIDATION)
     
    10171017        if (buffer_units < BUFFER_SIZE) {
    10181018#ifdef TEMPLATED_SIMD_LIB
    1019                 BitBlock final_block_mask = 
     1019                BitBlock final_block_mask =
    10201020                        sisd_sfl(simd<1>::constant<1>(), sisd_from_int(buffer_units % BLOCKSIZE));
    10211021#endif
    10221022#ifndef TEMPLATED_SIMD_LIB
    1023                 BitBlock final_block_mask = 
     1023                BitBlock final_block_mask =
    10241024                        sisd_sfl(simd_const_1(1), sisd_from_int(buffer_units % BLOCKSIZE));
    10251025#endif
  • 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
  • trunk/src/engine.h

    r263 r267  
    99#define ENGINE_H
    1010
    11 /*  Parabix provides strings to the application using the WorkingCharacterSet. 
     11/*  Parabix provides strings to the application using the WorkingCharacterSet.
    1212    This parameter is set by template instantiation; normally only one
    1313    WorkingCharacterSet parameter is chosen.  However, it is possible
     
    3434public:
    3535        virtual ~Parser_Interface();
    36         static Parser_Interface * ParserFactory(char * filename);
    37         static Parser_Interface * ParserFactory(char * filename, Model_Info * m);
     36        static Parser_Interface * ParserFactory(const char * filename);
     37        static Parser_Interface * ParserFactory(const char * filename, Model_Info * m);
    3838        // Constructor for a subsidiary parser for internal entities.
    39         static Parser_Interface * ParserFactory(char * byte_buffer, int byte_count, Entity_Info * e, Model_Info * m);
     39        static Parser_Interface * ParserFactory(const char * byte_buffer, int byte_count, Entity_Info * e, Model_Info * m);
    4040        virtual void ParseContent() = 0;
    4141        virtual void Parse_DocumentContent() = 0;
     
    5757
    5858        /* Action routine for document start. */
    59         void DocumentStart_action();   
    60        
     59        void DocumentStart_action();
     60
    6161        /* Action routine for document end. */
    6262        void DocumentEnd_action();
    63        
     63
    6464        /* Action routine for an XML comment in "<!--"  "-->" brackets. */
    6565        void Comment_action(unsigned char * item, int lgth);
    66        
     66
    6767        /* Action routine called upon recognizing "<![CDATA[" to start a CDATA section. */
    6868        void CDATA_start_action(unsigned char * CDATA_ptr);
     
    7070        /* Action routine called upon recognizing "]]>" to end a CDATA section. */
    7171        void CDATA_end_action(unsigned char * CDATA_end_ptr);
    72        
     72
    7373        /* Action routine for an XML processing instruction enclosed in "<?" and "?>" brackets. */
    7474        void PI_action(unsigned char * item, int lgth);
    75        
     75
    7676        /* Action routine for an empty element enclosed in "<" and "/>" brackets. */
    7777        void EmptyElement_action(unsigned char * item, int lgth);
    78        
     78
    7979        /* Action routine for a start tag enclosed in "<" and ">" brackets. */
    8080        void StartTag_action(unsigned char * item, int lgth);
    81        
     81
    8282        /* Action routine for an end tag enclosed in "</" and ">" brackets. */
    8383        void EndTag_action(unsigned char * item, int lgth);
    84        
     84
    8585        /* Action routine for an error item */
    8686        void Error_action(unsigned char * item, int lgth);
    87        
     87
    8888        /* Action routine for a text item */
    8989        void Text_action(unsigned char * item, int lgth, bool more);
    90        
     90
    9191        /* Action routine for a character or entity reference.*/
    9292        void Reference_action(unsigned char * item, int lgth);
    93        
    94         /* Action routine for an element name occurring immediately after the 
     93
     94        /* Action routine for an element name occurring immediately after the
    9595        opening "<" of a start tag or empty element tag. */
    9696        void ElementName_action(unsigned char * item, int lgth);
    97        
    98         /* Action routine for a processing instruction target name occurring immediately 
     97
     98        /* Action routine for a processing instruction target name occurring immediately
    9999        after the opening "<?" of a processing instruction. */
    100100        void PI_Target_action(unsigned char * item, int lgth);
    101        
     101
    102102        /* Action routine for an individual attribute/value pair occurring in
    103103        a element start tag or an empty element tag. */
    104         void AttributeValue_action(unsigned char * name, int name_lgth, 
     104        void AttributeValue_action(unsigned char * name, int name_lgth,
    105105                                   unsigned char * val, int val_lgth);
    106        
     106
    107107        /* Action routine for an individual namespace binding occurring in
    108108        a element start tag or an empty element tag. */
    109         void Namespace_action(unsigned char * name, int name_end, 
     109        void Namespace_action(unsigned char * name, int name_end,
    110110                              unsigned char * URI, int URI_end);
    111        
     111
    112112        /*Action routine for end of buffer events. */
    113113        void FinalizeBuffer_action();
    114        
     114
    115115        /*Document Type actions.*/
    116116        void Doctype_action(unsigned char * item, int lgth);
    117117        void PEReference_action(unsigned char * item, int lgth);
    118        
     118
    119119        void Prolog_action(unsigned char * item, int lgth);
    120        
     120
    121121        void ExtSubsetDecl_action(unsigned char * item, int lgth);
    122        
     122
    123123};
    124124
     
    134134        vector<int> LastAttOccurrence;
    135135        XML_Decl_Parser<B::Base> * decl_parser;
    136        
     136
    137137        int text_or_markup_start;
    138138        /* Getters for current point/position information. */
     
    157157        void Validity_Error (XML_Constraint errCode);
    158158        void Syntax_Error (XML_NonTerminal errNT);
    159        
     159
    160160        void Parse_Comment ();
    161161        void Parse_StartTag ();
     
    163163        void Parse_CDATA ();
    164164        void Parse_PI ();
    165         void Parse_CharRef (); 
     165        void Parse_CharRef ();
    166166        void Parse_EntityRef ();
    167167        void Parse_EntityRef_inMixed(symbol_set_t elems);
    168168        void Parse_EntityRef_inAnyContent();
    169        
     169
    170170        /* Parsing routine for Document Type*/
    171171        void Parse_DocType ();
     
    193193        void Parse_Prolog();
    194194        void Parse_DocumentContent();
    195        
     195
    196196        void Parse_WF_Element();
    197197        void Parse_WF_Content();
     
    204204        void Parse_AnyContent();
    205205        void Parse_MixedContent(symbol_set_t elems);
    206        
     206
    207207        int Parse_ValidStartTag(bool& is_empty);
    208        
     208
    209209        int Parse_Nmtoken();
    210         int Parse_Name(); 
    211        
     210        int Parse_Name();
     211
    212212        /*Parsing routine for external entities*/
    213213        void Parse_ExtSubsetDecl ();
    214        
     214
    215215protected:
    216216        /* Co-classes */
    217217
    218         Byteplex * byteplex;   
     218        Byteplex * byteplex;
    219219        Bitplex * bitplex;
    220220        Lexer_Interface * lexer;
     
    222222        BytePack * x8data;
    223223        LexicalStreamSet * buf;
    224                
     224
    225225        int buffer_base_pos;
    226226        int buffer_rel_pos;
  • trunk/src/stringpool.h

    r184 r267  
    1111#define STRINGPOOL_H
    1212
    13 template <int BasePoolSize, int ExpansionPercent> 
     13template <int BasePoolSize, int ExpansionPercent>
    1414class StringPool {
    1515public:
    1616        StringPool();
    1717        ~StringPool();
    18         char * Insert(char * full_string, int lgth);
     18        char * Insert(const char * full_string, int lgth);
    1919        /* The following methods provide for incremental construction of strings
    2020           each constructed by a sequence of calls of the form:
     
    2424        char * CloseString();  /* Return the pointer to the constructed string. */
    2525private:
    26         /* The initial buffer is allocated as part of the StringPool object. 
     26        /* The initial buffer is allocated as part of the StringPool object.
    2727           For stack allocated StringPools that do not exceed the initial
    2828           BasePoolSize, this completely eliminates the overhead and memory
     
    4343};
    4444
    45 template <int BasePoolSize, int ExpansionPercent> 
     45template <int BasePoolSize, int ExpansionPercent>
    4646StringPool<BasePoolSize, ExpansionPercent>::StringPool() {
    4747        node1.more_buffers = NULL;
     
    5454}
    5555
    56 template <int BasePoolSize, int ExpansionPercent> 
     56template <int BasePoolSize, int ExpansionPercent>
    5757StringPool<BasePoolSize, ExpansionPercent>::~StringPool() {
    5858        while (current_node != &node1) {
     
    6363}
    6464
    65 template <int BasePoolSize, int ExpansionPercent> 
     65template <int BasePoolSize, int ExpansionPercent>
    6666void StringPool<BasePoolSize, ExpansionPercent>::ExtendPool() {
    6767        size_t new_buffer_size = (size_t) ((total_size * ExpansionPercent)/100);
     
    8989        printf("ExtendPool() called: space_avail = %i\n", space_avail);
    9090#endif
    91 }       
     91}
    9292
    93 template <int BasePoolSize, int ExpansionPercent> 
    94 char * StringPool<BasePoolSize, ExpansionPercent>::Insert(char * s, int lgth) {
     93template <int BasePoolSize, int ExpansionPercent>
     94char * StringPool<BasePoolSize, ExpansionPercent>::Insert(const char * s, int lgth) {
    9595        int total_lgth = lgth + 1;
    9696        while (total_lgth > space_avail) ExtendPool();
     
    106106}
    107107
    108 template <int BasePoolSize, int ExpansionPercent> 
     108template <int BasePoolSize, int ExpansionPercent>
    109109void StringPool<BasePoolSize, ExpansionPercent>::OpenString() {
    110110        opened_string_ptr = insertion_ptr;
    111111}
    112112
    113 template <int BasePoolSize, int ExpansionPercent> 
     113template <int BasePoolSize, int ExpansionPercent>
    114114void StringPool<BasePoolSize, ExpansionPercent>::AppendSegment(char * segment, int segment_lgth) {
    115115        /* Make sure that there is length for this segment plus null byte. */
     
    120120}
    121121
    122 template <int BasePoolSize, int ExpansionPercent> 
     122template <int BasePoolSize, int ExpansionPercent>
    123123char * StringPool<BasePoolSize, ExpansionPercent>::CloseString() {
    124124        insertion_ptr[0] = '\0';
  • trunk/src/symtab.c

    r184 r267  
    5353        else switch (codepoint >> 12) {
    5454                case 0: case 1: return true;
    55                 case 2: if (codepoint >= 0x2070) 
     55                case 2: if (codepoint >= 0x2070)
    5656                                if (codepoint <= 0x218F) return true;
    5757                                else return (codepoint >= 0x2C00) & (codepoint <= 0x2FEF);
     
    7171        else switch (codepoint >> 12) {
    7272                case 0: case 1: return true;
    73                 case 2: if (codepoint >= 0x2070) 
     73                case 2: if (codepoint >= 0x2070)
    7474                                if (codepoint <= 0x218F) return true;
    7575                                else return (codepoint >= 0x2C00) & (codepoint <= 0x2FEF);
     
    134134        }
    135135        else {
    136                 int codepoint = ((bytes[0] & 0x0F) << 18)| ((bytes[1] & 0x3F) << 12) | 
     136                int codepoint = ((bytes[0] & 0x0F) << 18)| ((bytes[1] & 0x3F) << 12) |
    137137                                ((bytes[2] & 0x3F) << 6) | (bytes[3] & 0x3F);
    138138                return is_XML11_NameStrt_codepoint(codepoint) ? 4 : 0;
     
    154154        }
    155155        else {
    156                 int codepoint = ((bytes[0] & 0x0F) << 18)| ((bytes[1] & 0x3F) << 12) | 
     156                int codepoint = ((bytes[0] & 0x0F) << 18)| ((bytes[1] & 0x3F) << 12) |
    157157                                ((bytes[2] & 0x3F) << 6) | (bytes[3] & 0x3F);
    158158                return is_XML11_NameChar_codepoint(codepoint) ? 4 : 0;
     
    166166                valid_bytes = XML_10_UTF8_NameChar_bytes((unsigned char *) &protoname[pos]);
    167167                pos += valid_bytes;
    168                  
     168
    169169        }
    170170        /* Success requires that every byte sequence processed be valid
    171171           and that the total lgth processed be exactly that provided on
    172172           input. */
    173          
     173
    174174        return (valid_bytes > 0) & (pos == lgth);
    175175}
     
    194194                valid_bytes = XML_10_UTF8_NameChar_bytes((unsigned char *) &prototoken[pos]);
    195195                pos += valid_bytes;
    196                  
     196
    197197        }
    198198        /* Success requires that every byte sequence processed be valid
    199199           and that the total lgth processed be exactly that provided on
    200200           input. */
    201          
     201
    202202        return (valid_bytes > 0) & (pos == lgth);
    203203}
     
    216216}
    217217
    218 int Symbol_Table::Insert_Name(char * name, int lgth) {
     218int Symbol_Table::Insert_Name(const char * name, int lgth) {
    219219//      char * s = copy_name(name,lgth);
    220220        char * s = pool.Insert(name,lgth);
     
    240240                /* Clear bytes beyond the length of the name. */
    241241                b = sisd_sfl(b, sisd_from_int(8 * (sizeof(BytePack) - name_lgth)));
    242         } 
     242        }
    243243        else {
    244244                int offset = name_lgth % sizeof(BytePack);
     
    271271
    272272int Symbol_Table::UTF8_Lookup_or_Insert_Name(char * name, int lgth) {
    273                
     273
    274274        char delim = name[lgth];
    275275        name[lgth] = '\0';
    276276        int nameID = UTF8NameMap[name];
    277         name[lgth] = delim;     
    278        
     277        name[lgth] = delim;
     278
    279279        if(nameID == 0){
    280280        #if (not defined(OMISSION)) or (OMISSION != NAME_VALIDATION)
     
    335335
    336336int Symbol_Table::UTF8_Lookup_or_Insert_Nmtoken(char * nmtoken, int lgth) {
    337                
     337
    338338        char delim = nmtoken[lgth];
    339339        nmtoken[lgth] = '\0';
    340340        int nmtokenID = UTF8NmtokenMap[nmtoken];
    341         nmtoken[lgth] = delim; 
    342        
     341        nmtoken[lgth] = delim;
     342
    343343        if(nmtokenID == 0){
    344344        #if (not defined(OMISSION)) or (OMISSION != NAME_VALIDATION)
     
    394394}
    395395
    396 int Symbol_Table::LookupOrInsertReserved(){             
     396int Symbol_Table::LookupOrInsertReserved(){
    397397        int nameID = UTF8NameMap[reserved];
    398398        if(nameID == 0){
     
    417417}
    418418
    419 int Symbol_Table::LookupOrInsertReserved_nmtoken(){             
     419int Symbol_Table::LookupOrInsertReserved_nmtoken(){
    420420        int nmtokenID = UTF8NmtokenMap[reserved];
    421421        if(nmtokenID == 0){
  • trunk/src/symtab.h

    r184 r267  
    2525        int        lgth;
    2626};
    27        
    28 char * predefined[] = {"lt", "gt", "amp", "quot", "apos"};
    2927
     28const char * predefined[] = {"lt", "gt", "amp", "quot", "apos"};
    3029
    3130class Symbol_Table {
     
    3433
    3534
    36         int Insert_Name(char * name, int lgth);
    37         int ASCII_Lookup_or_Insert_Name(char * name, int lgth); 
     35        int Insert_Name(const char * name, int lgth);
     36        int ASCII_Lookup_or_Insert_Name(char * name, int lgth);
    3837        int UTF8_Lookup_or_Insert_Name(char * name, int lgth);
    39         int ASCII_Lookup_or_Insert_Nmtoken(char * name, int lgth);     
     38        int ASCII_Lookup_or_Insert_Nmtoken(char * name, int lgth);
    4039        int UTF8_Lookup_or_Insert_Nmtoken(char * name, int lgth);
    4140
     
    4544        char * Get_UTF8_nmtoken(int nmtokenID);
    4645        int Get_UTF8_nmtoken_lgth(int nmtokenID);
    47        
     46
    4847        char * ReserveSymbolSpace(int u8_lgth);
    4948        int LookupOrInsertReserved();
    5049        int LookupOrInsertReserved_nmtoken();
    51        
     50
    5251        XML_version version;
    5352        vector<Name_Data> UTF8NameTable;
  • trunk/src/xml_error.c

    r156 r267  
    2424
    2525
    26 void NoEncodingError(char * msg) {
     26void NoEncodingError(const char * msg) {
    2727        fprintf(stderr, "Error : %s\n", msg);
    2828        exit(-1);
    2929}
    3030
    31 void EncodingError(char * msg, unsigned char * encoding, int lgth) {
     31void EncodingError(const char * msg, unsigned char * encoding, int lgth) {
    3232        fprintf(stderr, "Error : Illegal/unsupported %s encoding of length %i: \"", msg, lgth);
    3333        for (int i = 0; i < lgth; i++) fprintf(stderr, "%c", encoding[i]);
    34         fprintf(stderr, "\"\n"); 
     34        fprintf(stderr, "\"\n");
    3535        exit(-1);
    3636}
    3737
    38 void CharSetValidationError(char * encoding, int err_pos) {
     38void CharSetValidationError(const char * encoding, int err_pos) {
    3939        fprintf(stderr, "Error: Invalid %s character in input stream at position %i\n", encoding, err_pos);
    4040        exit(-1);
     
    5656}
    5757
    58 void ImplementationLimitError(char * msg) {
     58void ImplementationLimitError(const char * msg) {
    5959        fprintf(stderr, "Fatal implementation limit - %s\n", msg);
    6060        exit(-1);
  • trunk/src/xml_error.h

    r120 r267  
    5353                vErr_UniqueNotationName};
    5454
    55 char * XML_Constraint_Strings[] = {
     55const char * XML_Constraint_Strings[] = {
    5656                "wfc-PEinInternalSubset",
    5757                "ExtSubset",
     
    184184                NT_Extender};
    185185
    186 char * XML_NonTerminal_Names[] = {
     186const char * XML_NonTerminal_Names[] = {
    187187                "document  [1]",
    188188                "Char  [2]",
  • trunk/src/xmlmodel.c

    r173 r267  
    1010#include "xmlmodel.h"
    1111
    12 void Model_Info::SimpleEntity(char * entity_Name, char * replText) {
    13                
     12void Model_Info::SimpleEntity(const char * entity_Name, const char * replText) {
     13
    1414                int entity_NameID = symbol_table->Insert_Name(entity_Name, strlen(entity_Name));
    1515                int entityID = GlobalGEntityTable[entity_NameID];
    16                 if(entityID==0){       
     16                if(entityID==0){
    1717                        GEntity_info * this_info = new GEntity_info;
    1818                        GlobalGEntityTable[entity_NameID]=++(globalGEntityCount);
    1919                        entityID = globalGEntityCount;
    20                
     20
    2121                        this_info->globalGEntity_id = entityID;
    2222                        this_info->is_external = false;
    2323                        this_info->ReplacementText = replText;
    2424                        this_info->systemLiteral = NULL;
    25                         this_info->pubidLiteral = NULL; 
     25                        this_info->pubidLiteral = NULL;
    2626                        this_info->NDataName = NULL;
    2727                        this_info->is_simple = true;
    28                        
     28
    2929                        GEntityData.push_back(this_info);
    3030                }
     
    3535        globalAttributeCount = 0;
    3636        symbol_table = new Symbol_Table();
    37         SimpleEntity("lt", "<"); 
    38         SimpleEntity("gt", ">"); 
    39         SimpleEntity("amp", "&"); 
    40         SimpleEntity("quot", "\""); 
    41         SimpleEntity("apos", "'");     
     37        SimpleEntity("lt", "<");
     38        SimpleEntity("gt", ">");
     39        SimpleEntity("amp", "&");
     40        SimpleEntity("quot", "\"");
     41        SimpleEntity("apos", "'");
    4242}
    4343
     
    4848int Model_Info::getOrInsertGlobalElement(int elem_nameID) {
    4949        int elemID =  GlobalElementTable[elem_nameID];
    50         if(elemID==0){ 
     50        if(elemID==0){
    5151                GlobalElementTable[elem_nameID]=++(globalElementCount);
    5252                elemID = globalElementCount;
    53                
     53
    5454                ElementAttributeData.push_back(vector<ATT_info *>());
    5555        }
     
    5858
    5959int Model_Info::getOrInsertGlobalAttName(int att_nameID){
    60                
     60
    6161        int attID = GlobalAttributeTable[att_nameID];
    62         if(attID==0){   
     62        if(attID==0){
    6363                GlobalAttributeTable[att_nameID]=++(globalAttributeCount);
    6464                attID = globalAttributeCount;
  • trunk/src/xmlmodel.h

    r174 r267  
    4040/* Attribute Modeling */
    4141
    42 enum ATT_type {CDATA_att, ID_att, IDREF_att, IDREFS_att, ENTITY_att, ENTITIES_att, 
     42enum ATT_type {CDATA_att, ID_att, IDREF_att, IDREFS_att, ENTITY_att, ENTITIES_att,
    4343               NMTOKEN_att, NMTOKENS_att, NOTATION_att, enumeration_att};
    4444/* Possible attribute types as specified in ATTLIST declarations. */
     
    6363        int globalGEntity_id;
    6464        bool is_external;
    65         char * ReplacementText;
     65        const char * ReplacementText;
    6666        char * systemLiteral;
    67         char * pubidLiteral;   
     67        char * pubidLiteral;
    6868        char * NDataName;
    6969        bool is_simple;
    70        
     70
    7171};
    7272
     
    7777        char * ReplacementText;
    7878        char * systemLiteral;
    79         char * pubidLiteral;   
     79        char * pubidLiteral;
    8080};
    8181
     
    8888public:
    8989        char * systemLiteral;
    90         char * pubidLiteral;   
     90        char * pubidLiteral;
    9191};
    9292
    9393
    9494class Model_Info {
    95        
    96 public: 
     95
     96public:
    9797        Model_Info();
    9898        ~Model_Info();
    9999        bool has_external_DTD;
    100100        char * external_DTD_systemLiteral;
    101         char * external_DTD_pubidLiteral;       
     101        char * external_DTD_pubidLiteral;
    102102        Symbol_Table * symbol_table;
    103        
    104    
     103
     104
    105105        /* Information computed from ATTLIST, ELEMENT, NOTATION and ENTITY declarations. */
    106106
     
    110110        hash_map<int, int > GlobalGEntityTable;
    111111        hash_map<int, int > GlobalPEntityTable;
    112        
    113        
     112
     113
    114114        int globalElementCount;
    115115        int globalAttributeCount;
     
    126126//      vector<ContentModel *> ContentModelData;
    127127        hash_map<int, ContentModel * > ContentModelData;
    128        
    129        
     128
     129
    130130        vector<GEntity_info *> GEntityData;
    131131        vector<PEntity_info *> PEntityData;
    132132        vector<Notation_info *> NotationData;
    133        
    134         void SimpleEntity(char * entity_Name, char * replText);
     133
     134        void SimpleEntity(const char * entity_Name, const char * replText);
    135135};
    136136
Note: See TracChangeset for help on using the changeset viewer.