Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Dec 31, 2007, 12:06:33 AM (17 years ago)
Author:
landauf
Message:

updated to the newest tinyXML library and changed one line in the LevelLoader

File:
1 edited

Legend:

Unmodified
Added
Removed

  • code/branches/FICN/src/tinyxml/tinyxmlparser.cc

    r471 r738  
    33Original code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com)
    44
    5 This software is provided 'as-is', without any express or implied 
    6 warranty. In no event will the authors be held liable for any 
     5This software is provided 'as-is', without any express or implied
     6warranty. In no event will the authors be held liable for any
    77damages arising from the use of this software.
    88
    9 Permission is granted to anyone to use this software for any 
    10 purpose, including commercial applications, and to alter it and 
     9Permission is granted to anyone to use this software for any
     10purpose, including commercial applications, and to alter it and
    1111redistribute it freely, subject to the following restrictions:
    1212
    13 1. The origin of this software must not be misrepresented; you must 
     131. The origin of this software must not be misrepresented; you must
    1414not claim that you wrote the original software. If you use this
    1515software in a product, an acknowledgment in the product documentation
    1616would be appreciated but is not required.
    1717
    18 2. Altered source versions must be plainly marked as such, and 
     182. Altered source versions must be plainly marked as such, and
    1919must not be misrepresented as being the original software.
    2020
    21 3. This notice may not be removed or altered from any source 
     213. This notice may not be removed or altered from any source
    2222distribution.
    2323*/
    2424
    25 #include "tinyxml.h"
    2625#include <ctype.h>
    2726#include <stddef.h>
    2827
     28#include "tinyxml.h"
     29
    2930//#define DEBUG_PARSER
     31#if defined( DEBUG_PARSER )
     32#       if defined( DEBUG ) && defined( _MSC_VER )
     33#               include <windows.h>
     34#               define TIXML_LOG OutputDebugString
     35#       else
     36#               define TIXML_LOG printf
     37#       endif
     38#endif
    3039
    3140// Note tha "PutString" hardcodes the same list. This
    3241// is less flexible than it appears. Changing the entries
    33 // or order will break putstring.       
    34 TiXmlBase::Entity TiXmlBase::entity[ NUM_ENTITY ] = 
     42// or order will break putstring.
     43TiXmlBase::Entity TiXmlBase::entity[ NUM_ENTITY ] =
    3544{
    3645        { "&amp;",  5, '&' },
    … …  
    4655// sequence from the lead byte. 1 placed for invalid sequences --
    4756// although the result will be junk, pass it through as much as possible.
    48 // Beware of the non-characters in UTF-8:       
     57// Beware of the non-characters in UTF-8:
    4958//                              ef bb bf (Microsoft "lead bytes")
    5059//                              ef bf be
    51 //                              ef bf bf 
     60//                              ef bf bf
    5261
    5362const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
    … …  
    5564const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
    5665
    57 const int TiXmlBase::utf8ByteTable[256] = 
     66const int TiXmlBase::utf8ByteTable[256] =
    5867{
    5968        //      0       1       2       3       4       5       6       7       8       9       a       b       c       d       e       f
    … …  
    6776                1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      // 0x70 End of ASCII range
    6877                1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      // 0x80 0x80 to 0xc1 invalid
    69                 1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      // 0x90 
    70                 1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      // 0xa0 
    71                 1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      // 0xb0 
     78                1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      // 0x90
     79                1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      // 0xa0
     80                1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      1,      // 0xb0
    7281                1,      1,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      // 0xc0 0xc2 to 0xdf 2 byte
    7382                2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      2,      // 0xd0
    … …  
    8392        const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
    8493
    85         if (input < 0x80) 
     94        if (input < 0x80)
    8695                *length = 1;
    8796        else if ( input < 0x800 )
    … …  
    97106
    98107        // Scary scary fall throughs.
    99         switch (*length) 
     108        switch (*length)
    100109        {
    101110                case 4:
    102                         --output; 
    103                         *output = (char)((input | BYTE_MARK) & BYTE_MASK); 
     111                        --output;
     112                        *output = (char)((input | BYTE_MARK) & BYTE_MASK);
    104113                        input >>= 6;
    105114                case 3:
    106                         --output; 
    107                         *output = (char)((input | BYTE_MARK) & BYTE_MASK); 
     115                        --output;
     116                        *output = (char)((input | BYTE_MARK) & BYTE_MASK);
    108117                        input >>= 6;
    109118                case 2:
    110                         --output; 
    111                         *output = (char)((input | BYTE_MARK) & BYTE_MASK); 
     119                        --output;
     120                        *output = (char)((input | BYTE_MARK) & BYTE_MASK);
    112121                        input >>= 6;
    113122                case 1:
    114                         --output; 
     123                        --output;
    115124                        *output = (char)(input | FIRST_BYTE_MARK[*length]);
    116125        }
    … …  
    122131        // This will only work for low-ascii, everything else is assumed to be a valid
    123132        // letter. I'm not sure this is the best approach, but it is quite tricky trying
    124         // to figure out alhabetical vs. not across encoding. So take a very 
     133        // to figure out alhabetical vs. not across encoding. So take a very
    125134        // conservative approach.
    126135
    … …  
    143152        // This will only work for low-ascii, everything else is assumed to be a valid
    144153        // letter. I'm not sure this is the best approach, but it is quite tricky trying
    145         // to figure out alhabetical vs. not across encoding. So take a very 
     154        // to figure out alhabetical vs. not across encoding. So take a very
    146155        // conservative approach.
    147156
    … …  
    216225                                // bump down to the next line
    217226                                ++row;
    218                                 col = 0;                               
     227                                col = 0;
    219228                                // Eat the character
    220229                                ++p;
    … …  
    258267                                                // 0-width spaces.
    259268                                                if ( *(pU+1)==TIXML_UTF_LEAD_1 && *(pU+2)==TIXML_UTF_LEAD_2 )
    260                                                         p += 3; 
     269                                                        p += 3;
    261270                                                else if ( *(pU+1)==0xbfU && *(pU+2)==0xbeU )
    262                                                         p += 3; 
     271                                                        p += 3;
    263272                                                else if ( *(pU+1)==0xbfU && *(pU+2)==0xbfU )
    264                                                         p += 3; 
     273                                                        p += 3;
    265274                                                else
    266275                                                        { p +=3; ++col; }       // A normal character.
    … …  
    278287                                {
    279288                                        // Eat the 1 to 4 byte utf8 character.
    280                                         int step = TiXmlBase::utf8ByteTable[*((unsigned char*)p)];
     289                                        int step = TiXmlBase::utf8ByteTable[*((const unsigned char*)p)];
    281290                                        if ( step == 0 )
    282291                                                step = 1;               // Error case from bad encoding, but handle gracefully.
    … …  
    314323                {
    315324                        const unsigned char* pU = (const unsigned char*)p;
    316                        
     325
    317326                        // Skip the stupid Microsoft UTF-8 Byte order marks
    318327                        if (    *(pU+0)==TIXML_UTF_LEAD_0
    319                                  && *(pU+1)==TIXML_UTF_LEAD_1 
     328                                 && *(pU+1)==TIXML_UTF_LEAD_1
    320329                                 && *(pU+2)==TIXML_UTF_LEAD_2 )
    321330                        {
    … …  
    354363
    355364#ifdef TIXML_USE_STL
    356 /*static*/ bool TiXmlBase::StreamWhiteSpace( TIXML_ISTREAM * in, TIXML_STRING * tag )
     365/*static*/ bool TiXmlBase::StreamWhiteSpace( std::istream * in, TIXML_STRING * tag )
    357366{
    358367        for( ;; )
    … …  
    369378}
    370379
    371 /*static*/ bool TiXmlBase::StreamTo( TIXML_ISTREAM * in, int character, TIXML_STRING * tag )
     380/*static*/ bool TiXmlBase::StreamTo( std::istream * in, int character, TIXML_STRING * tag )
    372381{
    373382        //assert( character > 0 && character < 128 );   // else it won't work in utf-8
    … …  
    387396#endif
    388397
     398// One of TinyXML's more performance demanding functions. Try to keep the memory overhead down. The
     399// "assign" optimization removes over 10% of the execution time.
     400//
    389401const char* TiXmlBase::ReadName( const char* p, TIXML_STRING * name, TiXmlEncoding encoding )
    390402{
     403        // Oddly, not supported on some comilers,
     404        //name->clear();
     405        // So use this:
    391406        *name = "";
    392407        assert( p );
    … …  
    399414        // hyphens, or colons. (Colons are valid ony for namespaces,
    400415        // but tinyxml can't tell namespaces from names.)
    401         if (    p && *p 
     416        if (    p && *p
    402417                 && ( IsAlpha( (unsigned char) *p, encoding ) || *p == '_' ) )
    403418        {
     419                const char* start = p;
    404420                while(          p && *p
    405                                 &&      (               IsAlphaNum( (unsigned char ) *p, encoding ) 
     421                                &&      (               IsAlphaNum( (unsigned char ) *p, encoding )
    406422                                                 || *p == '_'
    407423                                                 || *p == '-'
    … …  
    409425                                                 || *p == ':' ) )
    410426                {
    411                         (*name) += *p;
     427                        //(*name) += *p; // expensive
    412428                        ++p;
     429                }
     430                if ( p-start > 0 ) {
     431                        name->assign( start, p-start );
    413432                }
    414433                return p;
    … …  
    451470                                else if ( *q >= 'A' && *q <= 'F' )
    452471                                        ucs += mult * (*q - 'A' + 10 );
    453                                 else 
     472                                else
    454473                                        return 0;
    455474                                mult *= 16;
    … …  
    474493                                if ( *q >= '0' && *q <= '9' )
    475494                                        ucs += mult * (*q - '0');
    476                                 else 
     495                                else
    477496                                        return 0;
    478497                                mult *= 10;
    … …  
    507526        // So it wasn't an entity, its unrecognized, or something like that.
    508527        *value = *p;    // Don't put back the last one, since we return it!
     528        //*length = 1;  // Leave unrecognized entities - this doesn't really work.
     529                                        // Just writes strange XML.
    509530        return p+1;
    510531}
    … …  
    551572}
    552573
    553 const char* TiXmlBase::ReadText(        const char* p, 
    554                                                                         TIXML_STRING * text, 
    555                                                                         bool trimWhiteSpace, 
    556                                                                         const char* endTag, 
     574const char* TiXmlBase::ReadText(        const char* p,
     575                                                                        TIXML_STRING * text,
     576                                                                        bool trimWhiteSpace,
     577                                                                        const char* endTag,
    557578                                                                        bool caseInsensitive,
    558579                                                                        TiXmlEncoding encoding )
    … …  
    611632                }
    612633        }
    613         return p + strlen( endTag );
     634        if ( p )
     635                p += strlen( endTag );
     636        return p;
    614637}
    615638
    616639#ifdef TIXML_USE_STL
    617640
    618 void TiXmlDocument::StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag )
     641void TiXmlDocument::StreamIn( std::istream * in, TIXML_STRING * tag )
    619642{
    620643        // The basic issue with a document is that we don't know what we're
    … …  
    625648        // sub-tag can orient itself.
    626649
    627         if ( !StreamTo( in, '<', tag ) ) 
     650        if ( !StreamTo( in, '<', tag ) )
    628651        {
    629652                SetError( TIXML_ERROR_PARSING_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN );
    … …  
    647670                if ( in->good() )
    648671                {
    649                         // We now have something we presume to be a node of 
     672                        // We now have something we presume to be a node of
    650673                        // some sort. Identify it, and call the node to
    651674                        // continue streaming.
    … …  
    756779                        else if ( StringEqual( enc, "UTF8", true, TIXML_ENCODING_UNKNOWN ) )
    757780                                encoding = TIXML_ENCODING_UTF8; // incorrect, but be nice
    758                         else 
     781                        else
    759782                                encoding = TIXML_ENCODING_LEGACY;
    760783                }
    … …  
    774797
    775798void TiXmlDocument::SetError( int err, const char* pError, TiXmlParsingData* data, TiXmlEncoding encoding )
    776 {       
     799{
    777800        // The first error in a chain is more accurate - don't set again!
    778801        if ( error )
    … …  
    811834        }
    812835
    813         // What is this thing? 
     836        // What is this thing?
    814837        // - Elements start with a letter or underscore, but xml is reserved.
    815838        // - Comments: <!--
    … …  
    884907#ifdef TIXML_USE_STL
    885908
    886 void TiXmlElement::StreamIn (TIXML_ISTREAM * in, TIXML_STRING * tag)
     909void TiXmlElement::StreamIn (std::istream * in, TIXML_STRING * tag)
    887910{
    888911        // We're called with some amount of pre-parsing. That is, some of "this"
    … …  
    899922                }
    900923                (*tag) += (char) c ;
    901                
     924
    902925                if ( c == '>' )
    903926                        break;
    … …  
    909932        // If not, identify and stream.
    910933
    911         if (    tag->at( tag->length() - 1 ) == '>' 
     934        if (    tag->at( tag->length() - 1 ) == '>'
    912935                 && tag->at( tag->length() - 2 ) == '/' )
    913936        {
    … …  
    919942                // There is more. Could be:
    920943                //              text
     944                //              cdata text (which looks like another node)
    921945                //              closing tag
    922946                //              another node.
    … …  
    926950
    927951                        // Do we have text?
    928                         if ( in->good() && in->peek() != '<' ) 
     952                        if ( in->good() && in->peek() != '<' )
    929953                        {
    930954                                // Yep, text.
    … …  
    959983                                        return;
    960984                                }
    961                                
     985
    962986                                if ( c == '>' )
    963987                                        break;
    … …  
    965989                                *tag += (char) c;
    966990                                in->get();
     991
     992                                // Early out if we find the CDATA id.
     993                                if ( c == '[' && tag->size() >= 9 )
     994                                {
     995                                        size_t len = tag->size();
     996                                        const char* start = tag->c_str() + len - 9;
     997                                        if ( strcmp( start, "<![CDATA[" ) == 0 ) {
     998                                                assert( !closingTag );
     999                                                break;
     1000                                        }
     1001                                }
    9671002
    9681003                                if ( !firstCharFound && c != '<' && !IsWhiteSpace( c ) )
    … …  
    10681103                        if ( *p  != '>' )
    10691104                        {
    1070                                 if ( document ) document->SetError( TIXML_ERROR_PARSING_EMPTY, p, data, encoding );             
     1105                                if ( document ) document->SetError( TIXML_ERROR_PARSING_EMPTY, p, data, encoding );
    10711106                                return 0;
    10721107                        }
    … …  
    10801115                        ++p;
    10811116                        p = ReadValue( p, data, encoding );             // Note this is an Element method, and will set the error if one happens.
    1082                         if ( !p || !*p )
     1117                        if ( !p || !*p ) {
     1118                                // We were looking for the end tag, but found nothing.
     1119                                // Fix for [ 1663758 ] Failure to report error on bad XML
     1120                                if ( document ) document->SetError( TIXML_ERROR_READING_END_TAG, p, data, encoding );
    10831121                                return 0;
     1122                        }
    10841123
    10851124                        // We should find the end tag now
    … …  
    11061145
    11071146                        attrib->SetDocument( document );
    1108                         const char* pErr = p;
     1147                        pErr = p;
    11091148                        p = attrib->Parse( p, data, encoding );
    11101149
    … …  
    11171156
    11181157                        // Handle the strange case of double attributes:
     1158                        #ifdef TIXML_USE_STL
     1159                        TiXmlAttribute* node = attributeSet.Find( attrib->NameTStr() );
     1160                        #else
    11191161                        TiXmlAttribute* node = attributeSet.Find( attrib->Name() );
     1162                        #endif
    11201163                        if ( node )
    11211164                        {
    … …  
    11681211                        else
    11691212                                delete textNode;
    1170                 } 
    1171                 else 
     1213                }
     1214                else
    11721215                {
    11731216                        // We hit a '<'
    … …  
    11851228                                        p = node->Parse( p, data, encoding );
    11861229                                        LinkEndChild( node );
    1187                                 }                               
     1230                                }
    11881231                                else
    11891232                                {
    … …  
    11991242        {
    12001243                if ( document ) document->SetError( TIXML_ERROR_READING_ELEMENT_VALUE, 0, 0, encoding );
    1201         }       
     1244        }
    12021245        return p;
    12031246}
    … …  
    12051248
    12061249#ifdef TIXML_USE_STL
    1207 void TiXmlUnknown::StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag )
     1250void TiXmlUnknown::StreamIn( std::istream * in, TIXML_STRING * tag )
    12081251{
    12091252        while ( in->good() )
    12101253        {
    1211                 int c = in->get();     
     1254                int c = in->get();
    12121255                if ( c <= 0 )
    12131256                {
    … …  
    12221265                {
    12231266                        // All is well.
    1224                         return;         
     1267                        return;
    12251268                }
    12261269        }
    … …  
    12631306
    12641307#ifdef TIXML_USE_STL
    1265 void TiXmlComment::StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag )
     1308void TiXmlComment::StreamIn( std::istream * in, TIXML_STRING * tag )
    12661309{
    12671310        while ( in->good() )
    12681311        {
    1269                 int c = in->get();     
     1312                int c = in->get();
    12701313                if ( c <= 0 )
    12711314                {
    … …  
    12781321                (*tag) += (char) c;
    12791322
    1280                 if ( c == '>' 
     1323                if ( c == '>'
    12811324                         && tag->at( tag->length() - 2 ) == '-'
    12821325                         && tag->at( tag->length() - 3 ) == '-' )
    12831326                {
    12841327                        // All is well.
    1285                         return;         
     1328                        return;
    12861329                }
    12871330        }
    … …  
    13111354        }
    13121355        p += strlen( startTag );
    1313         p = ReadText( p, &value, false, endTag, false, encoding );
     1356
     1357        // [ 1475201 ] TinyXML parses entities in comments
     1358        // Oops - ReadText doesn't work, because we don't want to parse the entities.
     1359        // p = ReadText( p, &value, false, endTag, false, encoding );
     1360        //
     1361        // from the XML spec:
     1362        /*
     1363         [Definition: Comments may appear anywhere in a document outside other markup; in addition,
     1364                      they may appear within the document type declaration at places allowed by the grammar.
     1365                                  They are not part of the document's character data; an XML processor MAY, but need not,
     1366                                  make it possible for an application to retrieve the text of comments. For compatibility,
     1367                                  the string "--" (double-hyphen) MUST NOT occur within comments.] Parameter entity
     1368                                  references MUST NOT be recognized within comments.
     1369
     1370                                  An example of a comment:
     1371
     1372                                  <!-- declarations for <head> & <body> -->
     1373        */
     1374
     1375    value = "";
     1376        // Keep all the white space.
     1377        while ( p && *p && !StringEqual( p, endTag, false, encoding ) )
     1378        {
     1379                value.append( p, 1 );
     1380                ++p;
     1381        }
     1382        if ( p )
     1383                p += strlen( endTag );
     1384
    13141385        return p;
    13151386}
    … …  
    13211392        if ( !p || !*p ) return 0;
    13221393
    1323         int tabsize = 4;
    1324         if ( document )
    1325                 tabsize = document->TabSize();
     1394//      int tabsize = 4;
     1395//      if ( document )
     1396//              tabsize = document->TabSize();
    13261397
    13271398        if ( data )
    … …  
    13521423                return 0;
    13531424        }
    1354        
     1425
    13551426        const char* end;
    1356 
    1357         if ( *p == '\'' )
     1427        const char SINGLE_QUOTE = '\'';
     1428        const char DOUBLE_QUOTE = '\"';
     1429
     1430        if ( *p == SINGLE_QUOTE )
    13581431        {
    13591432                ++p;
    1360                 end = "\'";
     1433                end = "\'";             // single quote in string
    13611434                p = ReadText( p, &value, false, end, false, encoding );
    13621435        }
    1363         else if ( *p == '"' )
     1436        else if ( *p == DOUBLE_QUOTE )
    13641437        {
    13651438                ++p;
    1366                 end = "\"";
     1439                end = "\"";             // double quote in string
    13671440                p = ReadText( p, &value, false, end, false, encoding );
    13681441        }
    … …  
    13731446                // its best, even without them.
    13741447                value = "";
    1375                 while (    p && *p                                                                              // existence
     1448                while (    p && *p                                                                                      // existence
    13761449                                && !IsWhiteSpace( *p ) && *p != '\n' && *p != '\r'      // whitespace
    1377                                 && *p != '/' && *p != '>' )                                             // tag end
    1378                 {
     1450                                && *p != '/' && *p != '>' )                                                     // tag end
     1451                {
     1452                        if ( *p == SINGLE_QUOTE || *p == DOUBLE_QUOTE ) {
     1453                                // [ 1451649 ] Attribute values with trailing quotes not handled correctly
     1454                                // We did not have an opening quote but seem to have a
     1455                                // closing one. Give up and throw an error.
     1456                                if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding );
     1457                                return 0;
     1458                        }
    13791459                        value += *p;
    13801460                        ++p;
    … …  
    13851465
    13861466#ifdef TIXML_USE_STL
    1387 void TiXmlText::StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag )
    1388 {
    1389         if ( cdata )
    1390         {
    1391                 int c = in->get();     
     1467void TiXmlText::StreamIn( std::istream * in, TIXML_STRING * tag )
     1468{
     1469        while ( in->good() )
     1470        {
     1471                int c = in->peek();
     1472                if ( !cdata && (c == '<' ) )
     1473                {
     1474                        return;
     1475                }
    13921476                if ( c <= 0 )
    13931477                {
    … …  
    13991483
    14001484                (*tag) += (char) c;
    1401 
    1402                 if ( c == '>'
    1403                          && tag->at( tag->length() - 2 ) == ']'
    1404                          && tag->at( tag->length() - 3 ) == ']' )
    1405                 {
    1406                         // All is well.
    1407                         return;         
    1408                 }
    1409         }
    1410         else
    1411         {
    1412                 while ( in->good() )
    1413                 {
    1414                         int c = in->peek();     
    1415                         if ( c == '<' )
     1485                in->get();      // "commits" the peek made above
     1486
     1487                if ( cdata && c == '>' && tag->size() >= 3 ) {
     1488                        size_t len = tag->size();
     1489                        if ( (*tag)[len-2] == ']' && (*tag)[len-3] == ']' ) {
     1490                                // terminator of cdata.
    14161491                                return;
    1417                         if ( c <= 0 )
    1418                         {
    1419                                 TiXmlDocument* document = GetDocument();
    1420                                 if ( document )
    1421                                         document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );
    1422                                 return;
    1423                         }
    1424 
    1425                         (*tag) += (char) c;
    1426                         in->get();
     1492                        }
    14271493                }
    14281494        }
    … …  
    14641530                }
    14651531
    1466                 TIXML_STRING dummy; 
     1532                TIXML_STRING dummy;
    14671533                p = ReadText( p, &dummy, false, endTag, false, encoding );
    14681534                return p;
    … …  
    14811547
    14821548#ifdef TIXML_USE_STL
    1483 void TiXmlDeclaration::StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag )
     1549void TiXmlDeclaration::StreamIn( std::istream * in, TIXML_STRING * tag )
    14841550{
    14851551        while ( in->good() )
    … …  
    15381604                {
    15391605                        TiXmlAttribute attrib;
    1540                         p = attrib.Parse( p, data, _encoding );         
     1606                        p = attrib.Parse( p, data, _encoding );
    15411607                        version = attrib.Value();
    15421608                }
    … …  
    15441610                {
    15451611                        TiXmlAttribute attrib;
    1546                         p = attrib.Parse( p, data, _encoding );         
     1612                        p = attrib.Parse( p, data, _encoding );
    15471613                        encoding = attrib.Value();
    15481614                }
    … …  
    15501616                {
    15511617                        TiXmlAttribute attrib;
    1552                         p = attrib.Parse( p, data, _encoding );         
     1618                        p = attrib.Parse( p, data, _encoding );
    15531619                        standalone = attrib.Value();
    15541620                }
Note: See TracChangeset for help on using the changeset viewer.