Changeset 164 for trunk/src


Ignore:
Timestamp:
Jun 22, 2008, 4:44:24 PM (11 years ago)
Author:
cameron
Message:

Factoring Read XML/Text declarations; generic version

Location:
trunk/src
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/engine.c

    r160 r164  
    6161        if (e->code_unit_base == ASCII) {
    6262                XML_Decl_Parser<ASCII> decl_parser(b);
    63                 decl_parser.ReadXMLInfo(e);
     63                decl_parser.ReadXMLInfo(*e);
    6464                if (e->code_unit_size == SingleByte) {
    6565                        if (!(e->has_encoding_decl) || at_UTF_8(e->encoding))
     
    7676        else /* if (e->code_unit_base == EBCDIC) */ {
    7777                XML_Decl_Parser<EBCDIC> decl_parser(b);
    78                 decl_parser.ReadXMLInfo(e);
     78                decl_parser.ReadXMLInfo(*e);
    7979                return new ParsingEngine< X8_Buffer<EBCDIC> >(e, m, b, false);
    8080        }       
     
    100100        if (e->code_unit_base == ASCII) {
    101101                XML_Decl_Parser<ASCII> decl_parser(b);
    102                 decl_parser.ReadXMLInfo(e);
     102                decl_parser.ReadXMLInfo(*e);
    103103                if (e->code_unit_size == SingleByte) {
    104104                        return new ParsingEngine< X8_Buffer<ASCII> >(e, m, b, true);
     
    113113        else /* if (e->code_unit_base == EBCDIC) */ {
    114114                XML_Decl_Parser<EBCDIC> decl_parser(b);
    115                 decl_parser.ReadXMLInfo(e);
     115                decl_parser.ReadXMLInfo(*e);
    116116                return new ParsingEngine< X8_Buffer<EBCDIC> >(e, m, b, true);
    117117        }       
  • trunk/src/xmldecl.c

    r163 r164  
    142142
    143143template <CodeUnit_Base C>
    144 int XML_Decl_Parser<C>::EncodingAction(Entity_Info *e, int start_pos, int end_pos) {
    145         e->encoding = (unsigned char *) malloc(end_pos-start_pos+1);
    146         memcpy(e->encoding, &x8data[start_pos-buffer_base_pos], end_pos - start_pos);
    147         e->encoding[end_pos - start_pos] = '\0';
    148 }
    149 //
    150 template <CodeUnit_Base C>
    151 void XML_Decl_Parser<C>::ReadXMLInfo(Entity_Info *e) {
    152         e->version = no_XML_version_value;
    153         e->has_encoding_decl = false;
    154         e->standalone = Standalone_no_value;
    155         buffer_rel_pos = e->BOM_units;
    156         // It is possible that there is no XML declaration.
    157         if (!at_XmlDecl_start<C>(cur())) {
    158                 e->content_start = AbsPos();
    159                 return;
    160         }
    161         // Otherwise, the XML declaration exists and must have
    162         // at least version information.
    163         Advance(6);
    164         Scan_WS();
    165         if (!at_version<C>(cur())) DeclarationError(AbsPos());
     144int XML_Decl_Parser<C>::EncodingAction(Entity_Info & e, int start_pos, int end_pos) {
     145        e.encoding = (unsigned char *) malloc(end_pos-start_pos+1);
     146        memcpy(e.encoding, &x8data[start_pos-buffer_base_pos], end_pos - start_pos);
     147        e.encoding[end_pos - start_pos] = '\0';
     148}
     149
     150
     151template <CodeUnit_Base C>
     152inline void XML_Decl_Parser<C>::ParseVersion(Entity_Info & e) {
     153        /* Skip "version" */
    166154        Advance(7);
    167155        Scan_WS();
     
    169157        Advance(1);
    170158        Scan_WS();
    171         if (at_1_0<C>(cur())) e->version = XML_1_0;
    172         else if (at_1_1<C>(cur())) e->version = XML_1_1;
     159        if (at_1_0<C>(cur())) e.version = XML_1_0;
     160        else if (at_1_1<C>(cur())) e.version = XML_1_1;
    173161        else DeclarationError(AbsPos());
    174162        Advance(5);
    175         if (at_PI_End<C>(cur())) {
    176                 e->content_start = AbsPos()+2;
    177                 return;
    178         }
    179         if (!at_WhiteSpace_10<C>(cur())) DeclarationError(AbsPos());
    180         Scan_WS();
    181         if (at_encoding<C>(cur())) {
    182                 e->has_encoding_decl = true;
    183                 Advance(8);
    184                 Scan_WS();
    185                 if (!AtChar<C,'='>(cur())) DeclarationError(AbsPos());
    186                 Advance(1);
    187                 Scan_WS();
    188                 if (AtQuote<C>(cur())) {
    189                         unsigned char quoteCh = cur()[0];
    190                         Advance(1);
    191                         int encoding_start_pos = AbsPos();
    192                         ScanToQuote();
    193                         if (cur()[0] != quoteCh) DeclarationError(AbsPos());
    194                         EncodingAction(e, encoding_start_pos, AbsPos());
    195                 }
    196                 else DeclarationError(AbsPos());
    197                 Advance(1);
    198                 if (at_PI_End<C>(cur())) {
    199                         e->content_start = AbsPos()+2;
    200                         return;
    201                 }
    202                 if (!at_WhiteSpace_10<C>(cur())) DeclarationError(AbsPos());
    203                 Scan_WS();
    204         }
    205         if (at_standalone<C>(cur())) {
    206                 Advance(10);
    207                 Scan_WS();
    208                 if (!AtChar<C,'='>(cur())) DeclarationError(AbsPos());
    209                 Advance(1);
    210                 Scan_WS();
    211                 if (at_yes<C>(cur())) {Advance(5); e->standalone = Standalone_yes;}
    212                 else if (at_no<C>(cur())) {Advance(4); e->standalone = Standalone_no;}
    213                 else DeclarationError(AbsPos());
    214                 Scan_WS();
    215         }
    216         if (!at_PI_End<C>(cur())) DeclarationError(AbsPos());
    217         e->content_start = AbsPos()+2;
    218 }
    219 
    220 // Similar to reading the XML_declaration of the document entity,
    221 // ReadTextDeclaration reads the text declaration of an external
    222 // parsed entity.  This is not really needed at present, for DTDless
    223 // processing.
    224 template <CodeUnit_Base C>
    225 void XML_Decl_Parser<C>::ReadTextDeclaration(Entity_Info *e) {
    226         e->version = no_XML_version_value;
    227         e->has_encoding_decl = false;
    228         e->standalone = Standalone_no_value;
    229         buffer_rel_pos = e->BOM_units;
    230         // It is possible that there is no XML declaration.
    231         if (!at_XmlDecl_start<C>(cur())) {
    232                 e->content_start = AbsPos();
    233                 return;
    234         }
    235         // Otherwise, the text declaration exists and may have
    236         // version information.
    237         Advance(6);
    238         Scan_WS();
    239         if (at_version<C>(cur())) {
    240                 Advance(7);
    241                 Scan_WS();
    242                 if (!AtChar<C,'='>(cur())) DeclarationError(AbsPos());
    243                 Advance(1);
    244                 Scan_WS();
    245                 if (at_1_0<C>(cur())) e->version = XML_1_0;
    246                 else if (at_1_1<C>(cur())) e->version = XML_1_1;
    247                 else DeclarationError(AbsPos());
    248                 Advance(5);
    249                 // Must have whitespace character before declaration.
    250                 if (!at_WhiteSpace_10<C>(cur())) DeclarationError(AbsPos());
    251                 Scan_WS();
    252         }
    253         if (!at_encoding<C>(cur())) DeclarationError(AbsPos());
    254         e->has_encoding_decl = true;
     163}
     164
     165template <CodeUnit_Base C>
     166inline void XML_Decl_Parser<C>::ParseEncoding(Entity_Info & e) {
     167        /* Skip "encoding" */
    255168        Advance(8);
     169        e.has_encoding_decl = true;
    256170        Scan_WS();
    257171        if (!AtChar<C,'='>(cur())) DeclarationError(AbsPos());
     
    268182        else DeclarationError(AbsPos());
    269183        Advance(1);
    270         Scan_WS();
     184}
     185
     186template <CodeUnit_Base C>
     187inline void XML_Decl_Parser<C>::ParseStandalone(Entity_Info & e) {
     188        /* Skip "standalone" */
     189        Advance(10);
     190        Scan_WS();
     191        if (!AtChar<C,'='>(cur())) DeclarationError(AbsPos());
     192        Advance(1);
     193        Scan_WS();
     194        if (at_yes<C>(cur())) {Advance(5); e.standalone = Standalone_yes;}
     195        else if (at_no<C>(cur())) {Advance(4); e.standalone = Standalone_no;}
     196        else DeclarationError(AbsPos());
     197}
     198
     199
     200
     201
     202//
     203template <CodeUnit_Base C>
     204void XML_Decl_Parser<C>::ReadXMLInfo(Entity_Info & e) {
     205        e.version = no_XML_version_value;
     206        e.has_encoding_decl = false;
     207        e.standalone = Standalone_no_value;
     208        buffer_rel_pos = e.BOM_units;
     209        // It is possible that there is no XML declaration.
     210        if (!at_XmlDecl_start<C>(cur())) {
     211                e.content_start = AbsPos();
     212                return;
     213        }
     214        // Otherwise, the XML declaration exists and must have
     215        // at least version information.
     216        Advance(6);
     217        Scan_WS();
     218        if (!at_version<C>(cur())) DeclarationError(AbsPos());
     219        ParseVersion(e);
     220        if (at_PI_End<C>(cur())) {
     221                e.content_start = AbsPos()+2;
     222                return;
     223        }
     224        if (!at_WhiteSpace_10<C>(cur())) DeclarationError(AbsPos());
     225        Scan_WS();
     226        if (at_encoding<C>(cur())) {
     227                ParseEncoding(e);
     228                if (at_PI_End<C>(cur())) {
     229                        e.content_start = AbsPos()+2;
     230                        return;
     231                }
     232                if (!at_WhiteSpace_10<C>(cur())) DeclarationError(AbsPos());
     233                Scan_WS();
     234        }
     235        if (at_standalone<C>(cur())) {
     236                ParseStandalone(e);
     237                Scan_WS();
     238        }
    271239        if (!at_PI_End<C>(cur())) DeclarationError(AbsPos());
    272         e->content_start = AbsPos()+2;
    273 }
    274 
     240        e.content_start = AbsPos()+2;
     241}
     242
     243// Similar to reading the XML_declaration of the document entity,
     244// ReadTextDeclaration reads the text declaration of an external
     245// parsed entity.  This is not really needed at present, for DTDless
     246// processing.
     247template <CodeUnit_Base C>
     248void XML_Decl_Parser<C>::ReadTextDeclaration(Entity_Info & e) {
     249        e.version = no_XML_version_value;
     250        e.has_encoding_decl = false;
     251        e.standalone = Standalone_no_value;
     252        buffer_rel_pos = e.BOM_units;
     253        // It is possible that there is no XML declaration.
     254        if (!at_XmlDecl_start<C>(cur())) {
     255                e.content_start = AbsPos();
     256                return;
     257        }
     258        // Otherwise, the text declaration exists and may have
     259        // version information.
     260        Advance(6);
     261        Scan_WS();
     262        if (at_version<C>(cur())) {
     263                ParseVersion(e);
     264                // Must have whitespace character before encoding declaration.
     265                if (!at_WhiteSpace_10<C>(cur())) DeclarationError(AbsPos());
     266                Scan_WS();
     267        }
     268        if (!at_encoding<C>(cur())) DeclarationError(AbsPos());
     269        ParseEncoding(e);
     270        Scan_WS();
     271        if (!at_PI_End<C>(cur())) DeclarationError(AbsPos());   ParseVersion(e);
     272        if (at_PI_End<C>(cur())) {
     273                e.content_start = AbsPos()+2;
     274                return;
     275        }
     276
     277        e.content_start = AbsPos()+2;
     278}
     279
     280template <CodeUnit_Base C>
     281void XML_Decl_Parser<C>::ReadXMLorTextDecl(Entity_Info & e) {
     282        e.version = no_XML_version_value;
     283        e.has_encoding_decl = false;
     284        e.standalone = Standalone_no_value;
     285        buffer_rel_pos = e.BOM_units;
     286        // It is possible that there is no XML or text declaration.
     287        if (!at_XmlDecl_start<C>(cur())) {
     288                e.content_start = AbsPos();
     289                return;
     290        }
     291        // Otherwise, the XML or text declaration exists and may have
     292        // version information.
     293        Advance(6);
     294        Scan_WS();
     295        if (at_version<C>(cur())) {
     296                ParseVersion(e);
     297                if (at_PI_End<C>(cur())) {
     298                        e.content_start = AbsPos()+2;
     299                        return;
     300                }
     301                if (!at_WhiteSpace_10<C>(cur())) DeclarationError(AbsPos());
     302                Scan_WS();
     303                if (at_encoding<C>(cur())) {
     304                        ParseEncoding(e);
     305                        if (at_PI_End<C>(cur())) {
     306                                e.content_start = AbsPos()+2;
     307                                return;
     308                        }
     309                        if (!at_WhiteSpace_10<C>(cur())) DeclarationError(AbsPos());
     310                        Scan_WS();
     311                }
     312                if (at_standalone<C>(cur())) {
     313                        ParseStandalone(e);
     314                        Scan_WS();
     315                }
     316        }
     317        else {  // Without version, we can only have a text declaration,
     318                // in which case an encoding spec is required.
     319                if (!at_encoding<C>(cur())) DeclarationError(AbsPos());
     320                ParseEncoding();
     321                Scan_WS();
     322                // No standalone spec is allowed in a text declaration.
     323        }
     324        if (!at_PI_End<C>(cur())) DeclarationError(AbsPos());   
     325        e.content_start = AbsPos()+2;
     326}
  • trunk/src/xmldecl.h

    r163 r164  
    9090        ~XML_Decl_Parser ();
    9191       
    92         void ReadXMLInfo(Entity_Info * e);
    93         void ReadTextDeclaration(Entity_Info * e);
     92        void ReadXMLInfo(Entity_Info & e);
     93        void ReadTextDeclaration(Entity_Info & e);
     94        // Generic version if type of external entity unknown.
     95        void ReadXMLorTextDecl(Entity_Info & e);
    9496       
    9597
     
    106108        unsigned char * cur() const;
    107109       
    108         int EncodingAction(Entity_Info * e, int start_pos, int end_pos);
     110        int EncodingAction(Entity_Info & e, int start_pos, int end_pos);
    109111private:
    110112        /* Bytespace parsing routines for internal use in ReadXMLInfo and
     
    112114        void Scan_WS();
    113115        void ScanToQuote();
     116        void ParseVersion(Entity_Info & e);
     117        void ParseEncoding(Entity_Info & e);
     118        void ParseStandalone(Entity_Info & e);
    114119
    115120};
Note: See TracChangeset for help on using the changeset viewer.