[gunzemulator] r350 committed - Got rid of a lot of useless "WHAT IF THERE'S NO STL HURR DURR" bloat.

0 views
Skip to first unread message

gunzem...@googlecode.com

unread,
Jun 27, 2010, 10:37:55 PM6/27/10
to gogo-dev...@googlegroups.com
Revision: 350
Author: cg.wowus.cg
Date: Sun Jun 27 19:37:38 2010
Log: Got rid of a lot of useless "WHAT IF THERE'S NO STL HURR DURR" bloat.
http://code.google.com/p/gunzemulator/source/detail?r=350

Deleted:
/trunk/include/tinyxml/tinystr.h
/trunk/tinyxml/src/tinystr.cpp
Modified:
/trunk/include/tinyxml/tinyxml.h
/trunk/tinyxml/src/CMakeLists.txt
/trunk/tinyxml/src/tinyxml.cpp
/trunk/tinyxml/src/tinyxmlparser.cpp
/trunk/tinyxml/test/CMakeLists.txt
/trunk/tinyxml/test/xmltest.cpp

=======================================
--- /trunk/include/tinyxml/tinystr.h Sun Jun 27 19:25:07 2010
+++ /dev/null
@@ -1,323 +0,0 @@
-/*
-www.sourceforge.net/projects/tinyxml
-Original file by Yves Berquin.
-
-This software is provided 'as-is', without any express or implied
-warranty. In no event will the authors be held liable for any
-damages arising from the use of this software.
-
-Permission is granted to anyone to use this software for any
-purpose, including commercial applications, and to alter it and
-redistribute it freely, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must
-not claim that you wrote the original software. If you use this
-software in a product, an acknowledgment in the product documentation
-would be appreciated but is not required.
-
-2. Altered source versions must be plainly marked as such, and
-must not be misrepresented as being the original software.
-
-3. This notice may not be removed or altered from any source
-distribution.
-*/
-
-/*
- * THIS FILE WAS ALTERED BY Tyge Lovset, 7. April 2005.
- *
- * - completely rewritten. compact, clean, and fast implementation.
- * - sizeof(TiXmlString) = pointer size (4 bytes on 32-bit systems)
- * - fixed reserve() to work as per specification.
- * - fixed buggy compares operator==(), operator<(), and operator>()
- * - fixed operator+=() to take a const ref argument, following spec.
- * - added "copy" constructor with length, and most compare operators.
- * - added swap(), clear(), size(), capacity(), operator+().
- */
-
-#ifndef TIXML_USE_STL
- #define TIXML_USE_STL
-#endif
-
-#ifndef TIXML_USE_STL
-
-#ifndef TIXML_STRING_INCLUDED
-#define TIXML_STRING_INCLUDED
-
-#include <assert.h>
-#include <string.h>
-
-/* The support for explicit isn't that universal, and it isn't really
- required - it is used to check that the TiXmlString class isn't
incorrectly
- used. Be nice to old compilers and macro it here:
-*/
-#if defined(_MSC_VER) && (_MSC_VER >= 1200 )
- // Microsoft visual studio, version 6 and higher.
- #define TIXML_EXPLICIT explicit
-#elif defined(__GNUC__) && (__GNUC__ >= 3 )
- // GCC version 3 and higher.s
- #define TIXML_EXPLICIT explicit
-#else
- #define TIXML_EXPLICIT
-#endif
-
-
-/*
- TiXmlString is an emulation of a subset of the std::string template.
- Its purpose is to allow compiling TinyXML on compilers with no or poor
STL support.
- Only the member functions relevant to the TinyXML project have been
implemented.
- The buffer allocation is made by a simplistic power of 2 like
mechanism : if we increase
- a string and there's no more room, we allocate a buffer twice as big as
we need.
-*/
-class TiXmlString
-{
- public :
- // The size type used
- typedef size_t size_type;
-
- // Error value for find primitive
- static const size_type npos; // = -1;
-
-
- // TiXmlString empty constructor
- TiXmlString () : rep_(&nullrep_)
- {
- }
-
- // TiXmlString copy constructor
- TiXmlString ( const TiXmlString & copy) : rep_(0)
- {
- init(copy.length());
- memcpy(start(), copy.data(), length());
- }
-
- // TiXmlString constructor, based on a string
- TIXML_EXPLICIT TiXmlString ( const char * copy) : rep_(0)
- {
- init( static_cast<size_type>( strlen(copy) ));
- memcpy(start(), copy, length());
- }
-
- // TiXmlString constructor, based on a string
- TIXML_EXPLICIT TiXmlString ( const char * str, size_type len) : rep_(0)
- {
- init(len);
- memcpy(start(), str, len);
- }
-
- // TiXmlString destructor
- ~TiXmlString ()
- {
- quit();
- }
-
- // = operator
- TiXmlString& operator = (const char * copy)
- {
- return assign( copy, (size_type)strlen(copy));
- }
-
- // = operator
- TiXmlString& operator = (const TiXmlString & copy)
- {
- return assign(copy.start(), copy.length());
- }
-
-
- // += operator. Maps to append
- TiXmlString& operator += (const char * suffix)
- {
- return append(suffix, static_cast<size_type>( strlen(suffix) ));
- }
-
- // += operator. Maps to append
- TiXmlString& operator += (char single)
- {
- return append(&single, 1);
- }
-
- // += operator. Maps to append
- TiXmlString& operator += (const TiXmlString & suffix)
- {
- return append(suffix.data(), suffix.length());
- }
-
-
- // Convert a TiXmlString into a null-terminated char *
- const char * c_str () const { return rep_->str; }
-
- // Convert a TiXmlString into a char * (need not be null terminated).
- const char * data () const { return rep_->str; }
-
- // Return the length of a TiXmlString
- size_type length () const { return rep_->size; }
-
- // Alias for length()
- size_type size () const { return rep_->size; }
-
- // Checks if a TiXmlString is empty
- bool empty () const { return rep_->size == 0; }
-
- // Return capacity of string
- size_type capacity () const { return rep_->capacity; }
-
-
- // single char extraction
- const char& at (size_type index) const
- {
- assert( index < length() );
- return rep_->str[ index ];
- }
-
- // [] operator
- char& operator [] (size_type index) const
- {
- assert( index < length() );
- return rep_->str[ index ];
- }
-
- // find a char in a string. Return TiXmlString::npos if not found
- size_type find (char lookup) const
- {
- return find(lookup, 0);
- }
-
- // find a char in a string from an offset. Return TiXmlString::npos if
not found
- size_type find (char tofind, size_type offset) const
- {
- if (offset >= length()) return npos;
-
- for (const char* p = c_str() + offset; *p != '\0'; ++p)
- {
- if (*p == tofind) return static_cast< size_type >( p - c_str() );
- }
- return npos;
- }
-
- void clear ()
- {
- //Lee:
- //The original was just too strange, though correct:
- // TiXmlString().swap(*this);
- //Instead use the quit & re-init:
- quit();
- init(0,0);
- }
-
- /* Function to reserve a big amount of data when we know we'll need it.
Be aware that this
- function DOES NOT clear the content of the TiXmlString if any exists.
- */
- void reserve (size_type cap);
-
- TiXmlString& assign (const char* str, size_type len);
-
- TiXmlString& append (const char* str, size_type len);
-
- void swap (TiXmlString& other)
- {
- Rep* r = rep_;
- rep_ = other.rep_;
- other.rep_ = r;
- }
-
- private:
-
- void init(size_type sz) { init(sz, sz); }
- void set_size(size_type sz) { rep_->str[ rep_->size = sz ] = '\0'; }
- char* start() const { return rep_->str; }
- char* finish() const { return rep_->str + rep_->size; }
-
- struct Rep
- {
- size_type size, capacity;
- char str[1];
- };
-
- void init(size_type sz, size_type cap)
- {
- if (cap)
- {
- // Lee: the original form:
- // rep_ = static_cast<Rep*>(operator new(sizeof(Rep) + cap));
- // doesn't work in some cases of new being overloaded. Switching
- // to the normal allocation, although use an 'int' for systems
- // that are overly picky about structure alignment.
- const size_type bytesNeeded = sizeof(Rep) + cap;
- const size_type intsNeeded = ( bytesNeeded + sizeof(int) - 1 ) /
sizeof( int );
- rep_ = reinterpret_cast<Rep*>( new int[ intsNeeded ] );
-
- rep_->str[ rep_->size = sz ] = '\0';
- rep_->capacity = cap;
- }
- else
- {
- rep_ = &nullrep_;
- }
- }
-
- void quit()
- {
- if (rep_ != &nullrep_)
- {
- // The rep_ is really an array of ints. (see the allocator, above).
- // Cast it back before delete, so the compiler won't incorrectly call
destructors.
- delete [] ( reinterpret_cast<int*>( rep_ ) );
- }
- }
-
- Rep * rep_;
- static Rep nullrep_;
-
-} ;
-
-
-inline bool operator == (const TiXmlString & a, const TiXmlString & b)
-{
- return ( a.length() == b.length() ) // optimization on some
platforms
- && ( strcmp(a.c_str(), b.c_str()) == 0 ); // actual compare
-}
-inline bool operator < (const TiXmlString & a, const TiXmlString & b)
-{
- return strcmp(a.c_str(), b.c_str()) < 0;
-}
-
-inline bool operator != (const TiXmlString & a, const TiXmlString & b) {
return !(a == b); }
-inline bool operator > (const TiXmlString & a, const TiXmlString & b) {
return b < a; }
-inline bool operator <= (const TiXmlString & a, const TiXmlString & b) {
return !(b < a); }
-inline bool operator >= (const TiXmlString & a, const TiXmlString & b) {
return !(a < b); }
-
-inline bool operator == (const TiXmlString & a, const char* b) { return
strcmp(a.c_str(), b) == 0; }
-inline bool operator == (const char* a, const TiXmlString & b) { return b
== a; }
-inline bool operator != (const TiXmlString & a, const char* b) {
return !(a == b); }
-inline bool operator != (const char* a, const TiXmlString & b) {
return !(b == a); }
-
-TiXmlString operator + (const TiXmlString & a, const TiXmlString & b);
-TiXmlString operator + (const TiXmlString & a, const char* b);
-TiXmlString operator + (const char* a, const TiXmlString & b);
-
-
-/*
- TiXmlOutStream is an emulation of std::ostream. It is based on
TiXmlString.
- Only the operators that we need for TinyXML have been developped.
-*/
-class TiXmlOutStream : public TiXmlString
-{
-public :
-
- // TiXmlOutStream << operator.
- TiXmlOutStream & operator << (const TiXmlString & in)
- {
- *this += in;
- return *this;
- }
-
- // TiXmlOutStream << operator.
- TiXmlOutStream & operator << (const char * in)
- {
- *this += in;
- return *this;
- }
-
-} ;
-
-#endif // TIXML_STRING_INCLUDED
-#endif // TIXML_USE_STL
=======================================
--- /trunk/tinyxml/src/tinystr.cpp Sun Jun 27 19:25:07 2010
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
-www.sourceforge.net/projects/tinyxml
-Original file by Yves Berquin.
-
-This software is provided 'as-is', without any express or implied
-warranty. In no event will the authors be held liable for any
-damages arising from the use of this software.
-
-Permission is granted to anyone to use this software for any
-purpose, including commercial applications, and to alter it and
-redistribute it freely, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must
-not claim that you wrote the original software. If you use this
-software in a product, an acknowledgment in the product documentation
-would be appreciated but is not required.
-
-2. Altered source versions must be plainly marked as such, and
-must not be misrepresented as being the original software.
-
-3. This notice may not be removed or altered from any source
-distribution.
-*/
-
-/*
- * THIS FILE WAS ALTERED BY Tyge Løvset, 7. April 2005.
- */
-
-#include <tinyxml/tinystr.h>
-
-#ifndef TIXML_USE_STL
-
-// Error value for find primitive
-const TiXmlString::size_type TiXmlString::npos = static_cast<
TiXmlString::size_type >(-1);
-
-
-// Null rep.
-TiXmlString::Rep TiXmlString::nullrep_ = { 0, 0, { '\0' } };
-
-
-void TiXmlString::reserve (size_type cap)
-{
- if (cap > capacity())
- {
- TiXmlString tmp;
- tmp.init(length(), cap);
- memcpy(tmp.start(), data(), length());
- swap(tmp);
- }
-}
-
-
-TiXmlString& TiXmlString::assign(const char* str, size_type len)
-{
- size_type cap = capacity();
- if (len > cap || cap > 3*(len + 8))
- {
- TiXmlString tmp;
- tmp.init(len);
- memcpy(tmp.start(), str, len);
- swap(tmp);
- }
- else
- {
- memmove(start(), str, len);
- set_size(len);
- }
- return *this;
-}
-
-
-TiXmlString& TiXmlString::append(const char* str, size_type len)
-{
- size_type newsize = length() + len;
- if (newsize > capacity())
- {
- reserve (newsize + capacity());
- }
- memmove(finish(), str, len);
- set_size(newsize);
- return *this;
-}
-
-
-TiXmlString operator + (const TiXmlString & a, const TiXmlString & b)
-{
- TiXmlString tmp;
- tmp.reserve(a.length() + b.length());
- tmp += a;
- tmp += b;
- return tmp;
-}
-
-TiXmlString operator + (const TiXmlString & a, const char* b)
-{
- TiXmlString tmp;
- TiXmlString::size_type b_len = static_cast<TiXmlString::size_type>(
strlen(b) );
- tmp.reserve(a.length() + b_len);
- tmp += a;
- tmp.append(b, b_len);
- return tmp;
-}
-
-TiXmlString operator + (const char* a, const TiXmlString & b)
-{
- TiXmlString tmp;
- TiXmlString::size_type a_len = static_cast<TiXmlString::size_type>(
strlen(a) );
- tmp.reserve(a_len + b.length());
- tmp.append(a, a_len);
- tmp += b;
- return tmp;
-}
-
-
-#endif // TIXML_USE_STL
=======================================
--- /trunk/include/tinyxml/tinyxml.h Sun Jun 27 19:25:07 2010
+++ /trunk/include/tinyxml/tinyxml.h Sun Jun 27 19:37:38 2010
@@ -22,10 +22,6 @@
distribution.
*/

-#ifndef TIXML_USE_STL
- #define TIXML_USE_STL
-#endif
-
#ifndef TINYXML_INCLUDED
#define TINYXML_INCLUDED

@@ -46,15 +42,10 @@
#define DEBUG
#endif

-#ifdef TIXML_USE_STL
#include <string>
#include <iostream>
#include <sstream>
#define TIXML_STRING std::string
-#else
- #include "tinystr.h"
- #define TIXML_STRING TiXmlString
-#endif

// Deprecated library function hell. Compilers want to use the
// new safe versions. This probably doesn't fully address the problem,
@@ -301,10 +292,8 @@
return false; // Again, only truly correct for English/Latin...but
usually works.
}

- #ifdef TIXML_USE_STL
static bool StreamWhiteSpace( std::istream * in, TIXML_STRING * tag );
static bool StreamTo( std::istream * in, int character, TIXML_STRING *
tag );
- #endif

/* Reads an XML name into the string provided. Returns
a pointer just past the last character of the name,
@@ -429,8 +418,6 @@
friend class TiXmlElement;

public:
- #ifdef TIXML_USE_STL
-
/** An input stream operator, for every class. Tolerant of newlines
and
formatting, but doesn't expect them.
*/
@@ -457,8 +444,6 @@
/// Appends the XML node or attribute to a std::string.
friend std::string& operator<< (std::string& out, const TiXmlNode& base
);

- #endif
-
/** The types of XML nodes supported by TinyXml. (All the
unsupported types are picked up by UNKNOWN.)
*/
@@ -489,13 +474,11 @@
*/
const char *Value() const { return value.c_str (); }

- #ifdef TIXML_USE_STL
/** Return Value() as a std::string. If you only use STL,
this is more efficient than calling Value().
Only available in STL mode.
*/
const std::string& ValueStr() const { return value; }
- #endif

const TIXML_STRING& ValueTStr() const { return value; }

@@ -510,10 +493,8 @@
*/
void SetValue(const char * _value) { value = _value;}

- #ifdef TIXML_USE_STL
/// STL std::string form.
void SetValue( const std::string& _value ) { value = _value; }
- #endif

/// Delete all the children of this node. Does not affect 'this'.
void Clear();
@@ -539,12 +520,10 @@
return const_cast< TiXmlNode* > ((const_cast< const TiXmlNode*
>(this))->LastChild( _value ));
}

- #ifdef TIXML_USE_STL
const TiXmlNode* FirstChild( const std::string& _value ) const { return
FirstChild (_value.c_str ()); } ///< STL std::string form.
TiXmlNode* FirstChild( const std::string& _value ) { return FirstChild
(_value.c_str ()); } ///< STL std::string form.
const TiXmlNode* LastChild( const std::string& _value ) const { return
LastChild (_value.c_str ()); } ///< STL std::string form.
TiXmlNode* LastChild( const std::string& _value ) { return LastChild
(_value.c_str ()); } ///< STL std::string form.
- #endif

/** An alternate way to walk the children of a node.
One way to iterate over nodes is:
@@ -573,10 +552,8 @@
return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode*
>(this))->IterateChildren( _value, previous ) );
}

- #ifdef TIXML_USE_STL
const TiXmlNode* IterateChildren( const std::string& _value, const
TiXmlNode* previous ) const { return IterateChildren (_value.c_str (),
previous); } ///< STL std::string form.
TiXmlNode* IterateChildren( const std::string& _value, const TiXmlNode*
previous ) { return IterateChildren (_value.c_str (), previous); } ///< STL
std::string form.
- #endif

/** Add a new node related to this. Adds a child past the LastChild.
Returns a pointer to the new object or NULL if an error occured.
@@ -623,12 +600,10 @@
return const_cast< TiXmlNode* >( (const_cast< const TiXmlNode*
>(this))->PreviousSibling( _prev ) );
}

- #ifdef TIXML_USE_STL
const TiXmlNode* PreviousSibling( const std::string& _value ) const {
return PreviousSibling (_value.c_str ()); } ///< STL std::string form.
TiXmlNode* PreviousSibling( const std::string& _value ) { return
PreviousSibling (_value.c_str ()); } ///< STL std::string form.
const TiXmlNode* NextSibling( const std::string& _value) const { return
NextSibling (_value.c_str ()); } ///< STL std::string form.
TiXmlNode* NextSibling( const std::string& _value) { return
NextSibling (_value.c_str ()); } ///< STL std::string form.
- #endif

/// Navigate to a sibling node.
const TiXmlNode* NextSibling() const { return next; }
@@ -658,10 +633,8 @@
return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode*
>(this))->NextSiblingElement( _next ) );
}

- #ifdef TIXML_USE_STL
const TiXmlElement* NextSiblingElement( const std::string& _value) const
{ return NextSiblingElement (_value.c_str ()); } ///< STL std::string form.
TiXmlElement* NextSiblingElement( const std::string& _value) { return
NextSiblingElement (_value.c_str ()); } ///< STL std::string form.
- #endif

/// Convenience function to get through elements.
const TiXmlElement* FirstChildElement() const;
@@ -675,10 +648,8 @@
return const_cast< TiXmlElement* >( (const_cast< const TiXmlNode*
>(this))->FirstChildElement( _value ) );
}

- #ifdef TIXML_USE_STL
const TiXmlElement* FirstChildElement( const std::string& _value ) const
{ return FirstChildElement (_value.c_str ()); } ///< STL std::string form.
TiXmlElement* FirstChildElement( const std::string& _value ) { return
FirstChildElement (_value.c_str ()); } ///< STL std::string form.
- #endif

/** Query the type (as an enumerated value, above) of this node.
The possible types are: DOCUMENT, ELEMENT, COMMENT,
@@ -747,10 +718,8 @@
// and the assignment operator.
void CopyTo( TiXmlNode* target ) const;

- #ifdef TIXML_USE_STL
// The real work of the input operator.
virtual void StreamIn( std::istream* in, TIXML_STRING* tag ) = 0;
- #endif

// Figure out what is at *p, and parse it. Returns null if it is not an
xml node.
TiXmlNode* Identify( const char* start, TiXmlEncoding encoding );
@@ -791,7 +760,6 @@
prev = next = 0;
}

- #ifdef TIXML_USE_STL
/// std::string constructor.
TiXmlAttribute( const std::string& _name, const std::string& _value )
{
@@ -800,7 +768,6 @@
document = 0;
prev = next = 0;
}
- #endif

/// Construct an attribute with a name and value.
TiXmlAttribute( const char * _name, const char * _value )
@@ -813,9 +780,7 @@

const char* Name() const { return name.c_str(); } ///< Return the
name of this attribute.
const char* Value() const { return value.c_str(); } ///< Return the
value of this attribute.
- #ifdef TIXML_USE_STL
const std::string& ValueStr() const { return value; } ///< Return the
value of this attribute.
- #endif
int IntValue() const; ///< Return the value of this attribute,
converted to an integer.
double DoubleValue() const; ///< Return the value of this
attribute, converted to a double.

@@ -841,12 +806,10 @@
void SetIntValue( int _value ); ///< Set the value from an
integer.
void SetDoubleValue( double _value ); ///< Set the value from a
double.

- #ifdef TIXML_USE_STL
/// STL std::string form.
void SetName( const std::string& _name ) { name = _name; }
/// STL std::string form.
void SetValue( const std::string& _value ) { value = _value; }
- #endif

/// Get the next sibling attribute in the DOM. Returns null at end.
const TiXmlAttribute* Next() const;
@@ -920,10 +883,8 @@
TiXmlAttribute* Find( const char* _name ) const;
TiXmlAttribute* FindOrCreate( const char* _name );

-# ifdef TIXML_USE_STL
TiXmlAttribute* Find( const std::string& _name ) const;
TiXmlAttribute* FindOrCreate( const std::string& _name );
-# endif


private:
@@ -946,10 +907,8 @@
/// Construct an element.
TiXmlElement (const char * in_value);

- #ifdef TIXML_USE_STL
/// std::string constructor.
TiXmlElement( const std::string& _value );
- #endif

TiXmlElement( const TiXmlElement& );

@@ -998,7 +957,6 @@
return result;
}

- #ifdef TIXML_USE_STL
/// QueryStringAttribute examines the attribute - see QueryIntAttribute().
int QueryStringAttribute( const char* name, std::string* _value ) const {
const char* cstr = Attribute( name );
@@ -1038,14 +996,12 @@
*outValue = node->ValueStr();
return TIXML_SUCCESS;
}
- #endif

/** Sets an attribute of name to a given value. The attribute
will be created if it does not exist, or changed if it does.
*/
void SetAttribute( const char* name, const char * _value );

- #ifdef TIXML_USE_STL
const std::string* Attribute( const std::string& name ) const;
const std::string* Attribute( const std::string& name, int* i ) const;
const std::string* Attribute( const std::string& name, double* d ) const;
@@ -1058,7 +1014,6 @@
void SetAttribute( const std::string& name, int _value );
///< STL std::string form.
void SetDoubleAttribute( const std::string& name, double value );
- #endif

/** Sets an attribute of name to a given value. The attribute
will be created if it does not exist, or changed if it does.
@@ -1073,9 +1028,7 @@
/** Deletes an attribute with the given name.
*/
void RemoveAttribute( const char * name );
- #ifdef TIXML_USE_STL
void RemoveAttribute( const std::string& name ) { RemoveAttribute
(name.c_str ()); } ///< STL std::string form.
- #endif

const TiXmlAttribute* FirstAttribute() const { return
attributeSet.First(); } ///< Access the first attribute in this element.
TiXmlAttribute* FirstAttribute() { return attributeSet.First(); }
@@ -1139,9 +1092,7 @@
void ClearThis(); // like clear, but initializes 'this' object as well

// Used to be public [internal use]
- #ifdef TIXML_USE_STL
virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
- #endif
/* [internal use]
Reads the "value" of the element -- another element, or text.
This should terminate with the current end tag.
@@ -1190,9 +1141,7 @@
void CopyTo( TiXmlComment* target ) const;

// used to be public
- #ifdef TIXML_USE_STL
virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
- #endif
// virtual void StreamOut( TIXML_OSTREAM * out ) const;

private:
@@ -1220,14 +1169,12 @@
}
virtual ~TiXmlText() {}

- #ifdef TIXML_USE_STL
/// Constructor.
TiXmlText( const std::string& initValue ) : TiXmlNode
(TiXmlNode::TINYXML_TEXT)
{
SetValue( initValue );
cdata = false;
}
- #endif

TiXmlText( const TiXmlText& copy ) : TiXmlNode( TiXmlNode::TINYXML_TEXT )
{ copy.CopyTo( this ); }
void operator=( const TiXmlText& base ) { base.CopyTo( this ); }
@@ -1256,9 +1203,7 @@

bool Blank() const; // returns true if all white space and new lines
// [internal use]
- #ifdef TIXML_USE_STL
virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
- #endif

private:
bool cdata; // true if this should be input and output as a CDATA style
text element
@@ -1284,13 +1229,10 @@
/// Construct an empty declaration.
TiXmlDeclaration() : TiXmlNode( TiXmlNode::TINYXML_DECLARATION ) {}

-#ifdef TIXML_USE_STL
/// Constructor.
TiXmlDeclaration( const std::string& _version,
const std::string& _encoding,
const std::string& _standalone );
-#endif
-
/// Construct.
TiXmlDeclaration( const char* _version,
const char* _encoding,
@@ -1328,9 +1270,7 @@
protected:
void CopyTo( TiXmlDeclaration* target ) const;
// used to be public
- #ifdef TIXML_USE_STL
virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
- #endif

private:

@@ -1372,10 +1312,7 @@

protected:
void CopyTo( TiXmlUnknown* target ) const;
-
- #ifdef TIXML_USE_STL
virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
- #endif

private:

@@ -1394,10 +1331,8 @@
/// Create a document with a name. The name of the document is also the
filename of the xml.
TiXmlDocument( const char * documentName );

- #ifdef TIXML_USE_STL
/// Constructor.
TiXmlDocument( const std::string& documentName );
- #endif

TiXmlDocument( const TiXmlDocument& copy );
void operator=( const TiXmlDocument& copy );
@@ -1424,7 +1359,6 @@
/// Save a file using the given FILE*. Returns true if successful.
bool SaveFile( FILE* ) const;

- #ifdef TIXML_USE_STL
bool LoadFile( const std::string& filename, TiXmlEncoding encoding =
TIXML_DEFAULT_ENCODING ) ///< STL std::string version.
{
return LoadFile( filename.c_str(), encoding );
@@ -1433,7 +1367,6 @@
{
return SaveFile( filename.c_str() );
}
- #endif

/** Parse the given null terminated block of xml data. Passing in an
encoding to this
method (either TIXML_ENCODING_LEGACY or TIXML_ENCODING_UTF8 will force
TinyXml
@@ -1535,9 +1468,7 @@
protected :
// [internal use]
virtual TiXmlNode* Clone() const;
- #ifdef TIXML_USE_STL
virtual void StreamIn( std::istream * in, TIXML_STRING * tag );
- #endif

private:
void CopyTo( TiXmlDocument* target ) const;
@@ -1668,13 +1599,11 @@
*/
TiXmlHandle ChildElement( int index ) const;

- #ifdef TIXML_USE_STL
TiXmlHandle FirstChild( const std::string& _value ) const { return
FirstChild( _value.c_str() ); }
TiXmlHandle FirstChildElement( const std::string& _value ) const {
return FirstChildElement( _value.c_str() ); }

TiXmlHandle Child( const std::string& _value, int index ) const {
return Child( _value.c_str(), index ); }
TiXmlHandle ChildElement( const std::string& _value, int index ) const {
return ChildElement( _value.c_str(), index ); }
- #endif

/** Return the handle as a TiXmlNode. This may return null.
*/
@@ -1772,10 +1701,8 @@
/// Return the length of the result string.
size_t Size() { return buffer.size(); }

- #ifdef TIXML_USE_STL
/// Return the result.
const std::string& Str() { return buffer; }
- #endif

private:
void DoIndent() {
=======================================
--- /trunk/tinyxml/src/CMakeLists.txt Sun Jun 27 19:25:07 2010
+++ /trunk/tinyxml/src/CMakeLists.txt Sun Jun 27 19:37:38 2010
@@ -1,5 +1,4 @@
set(TINYXML_SRC
- tinystr.cpp
tinyxml.cpp
tinyxmlerror.cpp
tinyxmlparser.cpp
=======================================
--- /trunk/tinyxml/src/tinyxml.cpp Sun Jun 27 19:25:07 2010
+++ /trunk/tinyxml/src/tinyxml.cpp Sun Jun 27 19:37:38 2010
@@ -26,10 +26,8 @@

#include <tinyxml/tinyxml.h>

-#ifdef TIXML_USE_STL
#include <sstream>
#include <iostream>
-#endif

FILE* TiXmlFOpen( const char* filename, const char* mode );

@@ -432,12 +430,9 @@

void TiXmlElement::RemoveAttribute( const char * name )
{
- #ifdef TIXML_USE_STL
TIXML_STRING str( name );
TiXmlAttribute* node = attributeSet.Find( str );
- #else
- TiXmlAttribute* node = attributeSet.Find( name );
- #endif
+
if ( node )
{
attributeSet.Remove( node );
@@ -526,14 +521,12 @@
}


-#ifdef TIXML_USE_STL
TiXmlElement::TiXmlElement( const std::string& _value )
: TiXmlNode( TiXmlNode::TINYXML_ELEMENT )
{
firstChild = lastChild = 0;
value = _value;
}
-#endif


TiXmlElement::TiXmlElement( const TiXmlElement& copy)
@@ -578,7 +571,6 @@
}


-#ifdef TIXML_USE_STL
const std::string* TiXmlElement::Attribute( const std::string& name ) const
{
const TiXmlAttribute* attrib = attributeSet.Find( name );
@@ -586,7 +578,6 @@
return &attrib->ValueStr();
return 0;
}
-#endif


const char* TiXmlElement::Attribute( const char* name, int* i ) const
@@ -604,7 +595,6 @@
}


-#ifdef TIXML_USE_STL
const std::string* TiXmlElement::Attribute( const std::string& name, int*
i ) const
{
const TiXmlAttribute* attrib = attributeSet.Find( name );
@@ -618,7 +608,6 @@
}
return result;
}
-#endif


const char* TiXmlElement::Attribute( const char* name, double* d ) const
@@ -636,7 +625,6 @@
}


-#ifdef TIXML_USE_STL
const std::string* TiXmlElement::Attribute( const std::string& name,
double* d ) const
{
const TiXmlAttribute* attrib = attributeSet.Find( name );
@@ -650,7 +638,6 @@
}
return result;
}
-#endif


int TiXmlElement::QueryIntAttribute( const char* name, int* ival ) const
@@ -662,7 +649,6 @@
}


-#ifdef TIXML_USE_STL
int TiXmlElement::QueryIntAttribute( const std::string& name, int* ival )
const
{
const TiXmlAttribute* attrib = attributeSet.Find( name );
@@ -670,7 +656,6 @@
return TIXML_NO_ATTRIBUTE;
return attrib->QueryIntValue( ival );
}
-#endif


int TiXmlElement::QueryDoubleAttribute( const char* name, double* dval )
const
@@ -682,7 +667,6 @@
}


-#ifdef TIXML_USE_STL
int TiXmlElement::QueryDoubleAttribute( const std::string& name, double*
dval ) const
{
const TiXmlAttribute* attrib = attributeSet.Find( name );
@@ -690,7 +674,6 @@
return TIXML_NO_ATTRIBUTE;
return attrib->QueryDoubleValue( dval );
}
-#endif


void TiXmlElement::SetAttribute( const char * name, int val )
@@ -702,7 +685,6 @@
}


-#ifdef TIXML_USE_STL
void TiXmlElement::SetAttribute( const std::string& name, int val )
{
TiXmlAttribute* attrib = attributeSet.FindOrCreate( name );
@@ -710,7 +692,6 @@
attrib->SetIntValue( val );
}
}
-#endif


void TiXmlElement::SetDoubleAttribute( const char * name, double val )
@@ -722,7 +703,6 @@
}


-#ifdef TIXML_USE_STL
void TiXmlElement::SetDoubleAttribute( const std::string& name, double val
)
{
TiXmlAttribute* attrib = attributeSet.FindOrCreate( name );
@@ -730,7 +710,6 @@
attrib->SetDoubleValue( val );
}
}
-#endif


void TiXmlElement::SetAttribute( const char * cname, const char * cvalue )
@@ -742,7 +721,6 @@
}


-#ifdef TIXML_USE_STL
void TiXmlElement::SetAttribute( const std::string& _name, const
std::string& _value )
{
TiXmlAttribute* attrib = attributeSet.FindOrCreate( _name );
@@ -750,7 +728,6 @@
attrib->SetValue( _value );
}
}
-#endif


void TiXmlElement::Print( FILE* cfile, int depth ) const
@@ -882,7 +859,6 @@
}


-#ifdef TIXML_USE_STL
TiXmlDocument::TiXmlDocument( const std::string& documentName ) :
TiXmlNode( TiXmlNode::TINYXML_DOCUMENT )
{
tabsize = 4;
@@ -890,7 +866,6 @@
value = documentName;
ClearError();
}
-#endif


TiXmlDocument::TiXmlDocument( const TiXmlDocument& copy ) : TiXmlNode(
TiXmlNode::TINYXML_DOCUMENT )
@@ -1341,7 +1316,6 @@
}


-#ifdef TIXML_USE_STL
TiXmlDeclaration::TiXmlDeclaration( const std::string& _version,
const std::string& _encoding,
const std::string& _standalone )
@@ -1351,7 +1325,6 @@
encoding = _encoding;
standalone = _standalone;
}
-#endif


TiXmlDeclaration::TiXmlDeclaration( const TiXmlDeclaration& copy )
@@ -1466,11 +1439,7 @@

void TiXmlAttributeSet::Add( TiXmlAttribute* addMe )
{
- #ifdef TIXML_USE_STL
assert( !Find( TIXML_STRING( addMe->Name() ) ) ); // Shouldn't be
multiply adding to the set.
- #else
- assert( !Find( addMe->Name() ) ); // Shouldn't be multiply adding to the
set.
- #endif

addMe->next = &sentinel;
addMe->prev = sentinel.prev;
@@ -1498,7 +1467,6 @@
}


-#ifdef TIXML_USE_STL
TiXmlAttribute* TiXmlAttributeSet::Find( const std::string& name ) const
{
for( TiXmlAttribute* node = sentinel.next; node != &sentinel; node =
node->next )
@@ -1519,8 +1487,6 @@
}
return attrib;
}
-#endif
-

TiXmlAttribute* TiXmlAttributeSet::Find( const char* name ) const
{
@@ -1545,7 +1511,6 @@
}


-#ifdef TIXML_USE_STL
std::istream& operator>> (std::istream & in, TiXmlNode & base)
{
TIXML_STRING tag;
@@ -1555,10 +1520,8 @@
base.Parse( tag.c_str(), 0, TIXML_DEFAULT_ENCODING );
return in;
}
-#endif


-#ifdef TIXML_USE_STL
std::ostream& operator<< (std::ostream & out, const TiXmlNode & base)
{
TiXmlPrinter printer;
@@ -1579,8 +1542,6 @@

return out;
}
-#endif
-

TiXmlHandle TiXmlHandle::FirstChild() const
{
=======================================
--- /trunk/tinyxml/src/tinyxmlparser.cpp Sun Jun 27 19:25:07 2010
+++ /trunk/tinyxml/src/tinyxmlparser.cpp Sun Jun 27 19:37:38 2010
@@ -361,7 +361,6 @@
return p;
}

-#ifdef TIXML_USE_STL
/*static*/ bool TiXmlBase::StreamWhiteSpace( std::istream * in,
TIXML_STRING * tag )
{
for( ;; )
@@ -393,7 +392,6 @@
}
return false;
}
-#endif

// One of TinyXML's more performance demanding functions. Try to keep the
memory overhead down. The
// "assign" optimization removes over 10% of the execution time.
@@ -635,8 +633,6 @@
p += strlen( endTag );
return p;
}
-
-#ifdef TIXML_USE_STL

void TiXmlDocument::StreamIn( std::istream * in, TIXML_STRING * tag )
{
@@ -698,8 +694,6 @@
// We should have returned sooner.
SetError( TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN );
}
-
-#endif

const char* TiXmlDocument::Parse( const char* p, TiXmlParsingData*
prevData, TiXmlEncoding encoding )
{
@@ -897,8 +891,6 @@
}
return returnNode;
}
-
-#ifdef TIXML_USE_STL

void TiXmlElement::StreamIn (std::istream * in, TIXML_STRING * tag)
{
@@ -1038,7 +1030,6 @@
}
}
}
-#endif

const char* TiXmlElement::Parse( const char* p, TiXmlParsingData* data,
TiXmlEncoding encoding )
{
@@ -1157,11 +1148,7 @@
}

// Handle the strange case of double attributes:
- #ifdef TIXML_USE_STL
TiXmlAttribute* node = attributeSet.Find( attrib->NameTStr() );
- #else
- TiXmlAttribute* node = attributeSet.Find( attrib->Name() );
- #endif
if ( node )
{
if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, pErr,
data, encoding );
@@ -1247,7 +1234,6 @@
}


-#ifdef TIXML_USE_STL
void TiXmlUnknown::StreamIn( std::istream * in, TIXML_STRING * tag )
{
while ( in->good() )
@@ -1269,8 +1255,6 @@
}
}
}
-#endif
-

const char* TiXmlUnknown::Parse( const char* p, TiXmlParsingData* data,
TiXmlEncoding encoding )
{
@@ -1305,7 +1289,6 @@
return p;
}

-#ifdef TIXML_USE_STL
void TiXmlComment::StreamIn( std::istream * in, TIXML_STRING * tag )
{
while ( in->good() )
@@ -1330,7 +1313,6 @@
}
}
}
-#endif


const char* TiXmlComment::Parse( const char* p, TiXmlParsingData* data,
TiXmlEncoding encoding )
@@ -1460,7 +1442,6 @@
return p;
}

-#ifdef TIXML_USE_STL
void TiXmlText::StreamIn( std::istream * in, TIXML_STRING * tag )
{
while ( in->good() )
@@ -1490,7 +1471,6 @@
}
}
}
-#endif

const char* TiXmlText::Parse( const char* p, TiXmlParsingData* data,
TiXmlEncoding encoding )
{
@@ -1542,7 +1522,6 @@
}
}

-#ifdef TIXML_USE_STL
void TiXmlDeclaration::StreamIn( std::istream * in, TIXML_STRING * tag )
{
while ( in->good() )
@@ -1564,7 +1543,6 @@
}
}
}
-#endif

const char* TiXmlDeclaration::Parse( const char* p, TiXmlParsingData*
data, TiXmlEncoding _encoding )
{
=======================================
--- /trunk/tinyxml/test/CMakeLists.txt Sun Jun 27 19:25:07 2010
+++ /trunk/tinyxml/test/CMakeLists.txt Sun Jun 27 19:37:38 2010
@@ -1,5 +1,5 @@
set(TINYXML_TESTS
- xmltest.cpp
+ xmltest
# More tests here!
)

=======================================
--- /trunk/tinyxml/test/xmltest.cpp Sun Jun 27 19:25:07 2010
+++ /trunk/tinyxml/test/xmltest.cpp Sun Jun 27 19:37:38 2010
@@ -6,13 +6,10 @@

#include <cstdio>

-#ifdef TIXML_USE_STL
- #include <iostream>
- #include <sstream>
- using namespace std;
-#else
- #include <stdio.h>
-#endif
+#include <iostream>
+#include <sstream>
+
+using namespace std;

#if defined( WIN32 ) && defined( TUNE )
#include <crtdbg.h>
@@ -26,8 +23,6 @@
static int gPass = 0;
static int gFail = 0;

-
-
bool XmlTest (const char* testString, const char* expected, const char*
found, bool noEcho )
{
bool pass = !strcmp( expected, found );
@@ -96,7 +91,6 @@

{

- #ifdef TIXML_USE_STL
// What the todo list should look like after processing.
// In stream (no formatting) representation.
const char* demoEnd =
@@ -118,7 +112,6 @@
"<Item priority=\"2\" distance=\"here\">Do bills"
"</Item>"
"</ToDo>";
- #endif

// The example parses from the character string (above):
#if defined( WIN32 ) && defined( TUNE )
@@ -158,12 +151,10 @@
doc.Accept( &printer );
fprintf( stdout, "%s", printer.CStr() );
}
- #ifdef TIXML_USE_STL
{
printf( "** Printing via operator<< **\n" );
std::cout << doc;
}
- #endif
TiXmlNode* node = 0;
TiXmlElement* todoElement = 0;
TiXmlElement* itemElement = 0;
@@ -249,10 +240,8 @@
doc.Print( stdout );


- #ifdef TIXML_USE_STL
printf( "** Demo doc processed to stream: ** \n\n" );
cout << doc << endl << endl;
- #endif

// --------------------------------------------------------
// Different tests...do we have what we expect?
@@ -263,13 +252,11 @@

//////////////////////////////////////////////////////

- #ifdef TIXML_USE_STL
cout << "** Basic structure. **\n";
ostringstream outputStream( ostringstream::out );
outputStream << doc;
XmlTest( "Output stream correct.", string( demoEnd ).c_str(),
outputStream.str().c_str(), true );
- #endif

node = doc.RootElement();
assert( node );
@@ -350,7 +337,6 @@
}
XmlTest( "'Item' children of the 'ToDo' element, using Last/Previous.",
3, count );

- #ifdef TIXML_USE_STL
{
cout << "\n** Parsing. **\n";
istringstream parse0( "<Element0 attribute0='foo0' attribute1= noquotes
attribute2 = '&gt;' />" );
@@ -362,7 +348,6 @@
XmlTest ( "Reads incorrectly
formatted 'attribute1=noquotes'.", "noquotes",
element0.Attribute( "attribute1" ) );
XmlTest ( "Read attribute with entity value '>'.", ">",
element0.Attribute( "attribute2" ) );
}
- #endif

{
const char* error = "<?xml version=\"1.0\" standalone=\"no\" ?>\n"
@@ -378,7 +363,6 @@

}

- #ifdef TIXML_USE_STL
{
//////////////////////////////////////////////////////
cout << "\n** Streaming. **\n";
@@ -403,7 +387,6 @@
XmlTest( "String printing correct.", string( demoEnd ).c_str(),
str.c_str(), true );
}
- #endif
}

{
@@ -680,19 +663,15 @@
TiXmlDocument docAssign;
docAssign = docCopy;

- #ifdef TIXML_USE_STL
std::string original, copy, assign;
original << doc;
copy << docCopy;
assign << docAssign;
XmlTest( "Copy/Assign: document copy.", original.c_str(), copy.c_str(),
true );
XmlTest( "Copy/Assign: document assign.", original.c_str(),
assign.c_str(), true );
-
- #endif
}

//////////////////////////////////////////////////////
-#ifdef TIXML_USE_STL
printf ("\n** Parsing, no Condense Whitespace **\n");
TiXmlBase::SetCondenseWhiteSpace( false );
{
@@ -705,7 +684,6 @@
true );
}
TiXmlBase::SetCondenseWhiteSpace( true );
-#endif

//////////////////////////////////////////////////////
// GetText();
@@ -752,7 +730,6 @@
"I am > the rules!\n...since I make symbolic puns",
true );

- #ifdef TIXML_USE_STL
//cout << doc << '\n';

doc.Clear();
@@ -764,7 +741,6 @@
XmlTest( "CDATA stream.", doc.FirstChildElement()->FirstChild()->Value(),
"I am > the rules!\n...since I make symbolic puns",
true );
- #endif

TiXmlDocument doc1 = doc;
//doc.Print();
@@ -793,14 +769,12 @@

XmlTest( "CDATA with all bytes #1.", str.c_str(), printer.CStr(), true );

- #ifdef TIXML_USE_STL
doc.Clear();
istringstream iss( printer.Str() );
iss >> doc;
std::string out;
out << doc;
XmlTest( "CDATA with all bytes #2.", out.c_str(), printer.CStr(), true );
- #endif
}
{
// [ 1480107 ] Bug-fix for STL-streaming of CDATA that contains tags
@@ -819,8 +793,6 @@
"<b>I am > the rules!</b>\n...since I make symbolic puns",
true );

- #ifdef TIXML_USE_STL
-
doc.Clear();

istringstream parse0( str );
@@ -829,7 +801,6 @@
XmlTest( "CDATA stream. [ 1480107 ]",
doc.FirstChildElement()->FirstChild()->Value(),
"<b>I am > the rules!</b>\n...since I make symbolic puns",
true );
- #endif

TiXmlDocument doc1 = doc;
//doc.Print();
@@ -896,26 +867,12 @@
// Missing constructor implementation. No test -- just compiles.
TiXmlText text( "Missing" );

- #ifdef TIXML_USE_STL
// Missing implementation:
TiXmlDocument doc;
string name = "missing";
doc.LoadFile( name );

TiXmlText textSTL( name );
- #else
- // verifying some basic string functions:
- TiXmlString a;
- TiXmlString b( "Hello" );
- TiXmlString c( "ooga" );
-
- c = " World!";
- a = b;
- a += c;
- a = a;
-
- XmlTest( "Basic TiXmlString test. ", "Hello World!", a.c_str() );
- #endif
}

// Long filenames crashing STL version
@@ -1016,12 +973,10 @@
TiXmlHandle docH( &doc );
TiXmlUnknown* unknown = docH.Child( 1 ).Unknown();
XmlTest( "Correct value of unknown.", "!DOCTYPE PLAY SYSTEM 'play.dtd'",
unknown->Value() );
- #ifdef TIXML_USE_STL
TiXmlNode* node = docH.Child( 2 ).Node();
std::string str;
str << (*node);
XmlTest( "Correct streaming of unknown.", "<!ELEMENT title (#PCDATA)>",
str.c_str() );
- #endif
}

{
@@ -1036,11 +991,9 @@
TiXmlComment* comment = docH.Child( 0 ).Node()->ToComment();

XmlTest( "Comment formatting.", " Somewhat<evil> ", comment->Value() );
- #ifdef TIXML_USE_STL
std::string str;
str << (*comment);
XmlTest( "Comment streaming.", "<!-- Somewhat<evil> -->", str.c_str() );
- #endif
}

{
@@ -1105,13 +1058,11 @@
doc.Parse( doctype );
XmlTest( "Embedded null throws error.", true, doc.Error() );

- #ifdef TIXML_USE_STL
istringstream strm( doctype );
doc.Clear();
doc.ClearError();
strm >> doc;
XmlTest( "Embedded null throws error.", true, doc.Error() );
- #endif
}

{
@@ -1140,18 +1091,6 @@
doc.Parse( str );
XmlTest( "Empty document error TIXML_ERROR_DOCUMENT_EMPTY",
TiXmlBase::TIXML_ERROR_DOCUMENT_EMPTY, doc.ErrorId() );
}
- #ifndef TIXML_USE_STL
- {
- // String equality. [ 1006409 ] string operator==/!= no worky in all
cases
- TiXmlString temp;
- XmlTest( "Empty tinyxml string compare equal", ( temp == "" ), true );
-
- TiXmlString foo;
- TiXmlString bar( "" );
- XmlTest( "Empty tinyxml string compare equal", ( foo == bar ), true );
- }
-
- #endif
{
// Bug [ 1195696 ] from marlonism
TiXmlBase::SetCondenseWhiteSpace(false);
@@ -1180,7 +1119,6 @@
xml.Parse( "<foo attribute=bar\" />" );
XmlTest( "Throw error with bad end quotes.", xml.Error(), true );
}
- #ifdef TIXML_USE_STL
{
// Bug [ 1449463 ] Consider generic query
TiXmlDocument xml;
@@ -1205,9 +1143,7 @@
XmlTest( "QueryValueAttribute", (f==3.0f), true );
XmlTest( "QueryValueAttribute", (str==std::string( "a string" )), true );
}
- #endif
-
- #ifdef TIXML_USE_STL
+
{
// [ 1505267 ] redundant malloc in TiXmlElement::Attribute
TiXmlDocument xml;
@@ -1226,7 +1162,6 @@
XmlTest( "Attribute", (d==3.0), true );
XmlTest( "Attribute", (i==3), true );
}
- #endif

{
// [ 1356059 ] Allow TiXMLDocument to only be at the top level
@@ -1254,7 +1189,6 @@
//XmlTest( "Tag split by newline", xml.Error(), false );
}

- #ifdef TIXML_USE_STL
{
// [ 1475201 ] TinyXML parses entities in comments
TiXmlDocument xml;
@@ -1270,7 +1204,6 @@
XmlTest( "Comments ignore entities.", " declarations for <head> &
<body> ", c0->Value(), true );
XmlTest( "Comments ignore entities.", " far &amp; away ", c1->Value(),
true );
}
- #endif

{
// [ 1475201 ] TinyXML parses entities in comments
Reply all
Reply to author
Forward
0 new messages