Attachment 126927 Details for Bug 33937 – Allow building against system copy of tinyxml

[patch] Allow building against system copy of tinyxml

0002-Allow-building-against-system-copy-of-tinyxml.patch (text/plain), 147.26 KB, created by Gilles Dartiguelongue on 2016-09-30 21:58:36 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Gilles Dartiguelongue

Created: 2016-09-30 21:58:36 UTC

Size: 147.26 KB

patch

obsolete

>From 3cf1ce0db03733efc45790eac930074aac867b68 Mon Sep 17 00:00:00 2001
>From: Pacho Ramos <pachoramos1@gmail.com>
>Date: Tue, 20 Sep 2016 00:21:49 +0200
>Subject: [PATCH 2/9] Allow building against system copy of tinyxml
>
>Tested against 2.6.2.
>
>Bugzilla: https://bugs.freedesktop.org//show_bug.cgi?id=33937
>Bugzilla: https://bugs.gentoo.org/show_bug.cgi?id=252920
>Signed-off-by: Gilles Dartiguelongue <eva@gentoo.org>
>---
> configure.ac                  |   20 +
> librarian/Makefile.am         |   11 +-
> librarian/rarian-omf.cpp      |    6 +-
> util/Makefile.am              |   25 +-
> util/rarian-sk-get-cl.cpp     |    6 +-
> util/rarian-sk-migrate.cpp    |    6 +-
> util/rarian-sk-preinstall.cpp |    6 +-
> util/tinystr.cpp              |  115 ---
> util/tinystr.h                |  319 --------
> util/tinyxml.cpp              | 1799 -----------------------------------------
> util/tinyxml.h                | 1520 ----------------------------------
> util/tinyxmlerror.cpp         |   52 --
> util/tinyxmlparser.cpp        | 1580 ------------------------------------
> 13 files changed, 39 insertions(+), 5426 deletions(-)
> delete mode 100644 util/tinystr.cpp
> delete mode 100644 util/tinystr.h
> delete mode 100644 util/tinyxml.cpp
> delete mode 100644 util/tinyxml.h
> delete mode 100644 util/tinyxmlerror.cpp
> delete mode 100644 util/tinyxmlparser.cpp
>
>diff --git a/configure.ac b/configure.ac
>index ebddf05..11262fc 100644
>--- a/configure.ac
>+++ b/configure.ac
>@@ -183,6 +183,26 @@ dnl
> 
> # Checks for library functions.
> 
>+AC_MSG_CHECKING([whether to use system tinyxml])
>+AC_LANG_PUSH([C++])
>+SAVED_LIBS=$LIBS
>+LIBS="$LIBS -ltinyxml"
>+AC_LINK_IFELSE(
>+	[AC_LANG_PROGRAM(
>+		[#include <tinyxml.h>],
>+		[TiXmlElement root("myroot")])
>+	],
>+	[
>+		RARIAN_LIBS="$RARIAN_LIBS -ltinyxml"
>+		HAVE_TINYXML=1
>+		AC_MSG_RESULT([yes])
>+	],
>+	[AC_MSG_FAILURE([no])]
>+)
>+LIBS=$SAVED_LIBS
>+AC_SUBST(RARIAN_LIBS)
>+AC_LANG_POP([C++])
>+
> AC_CONFIG_FILES([Makefile
> 		 rarian.pc
>                  data/Makefile
>diff --git a/librarian/Makefile.am b/librarian/Makefile.am
>index 7bd69b0..51ecc09 100644
>--- a/librarian/Makefile.am
>+++ b/librarian/Makefile.am
>@@ -20,14 +20,9 @@ librarian_la_SOURCES  =  \
> if ENABLE_OMF_READ
> librarian_la_SOURCES  +=  	\
>     rarian-omf.h		\
>-    rarian-omf.cpp		\
>-    $(top_srcdir)/util/tinyxml.cpp			\
>-    $(top_srcdir)/util/tinyxml.h			\
>-    $(top_srcdir)/util/tinyxmlparser.cpp		\
>-    $(top_srcdir)/util/tinystr.cpp			\
>-    $(top_srcdir)/util/tinystr.h			\
>-    $(top_srcdir)/util/tinyxmlerror.cpp	
>+    rarian-omf.cpp
> endif
> 
> librarian_la_CFLAGS = -DDATADIR=\""$(datadir)"\" -DSYSCONFDIR=\""$(sysconfdir)"\" -DI_KNOW_RARIAN_0_8_IS_UNSTABLE
>-librarian_la_LDFLAGS = -export-symbols-regex "^rrn_.*"
>\ No newline at end of file
>+librarian_la_LDFLAGS = -export-symbols-regex "^rrn_.*"
>+librarian_la_LIBADD = $(RARIAN_LIBS)
>diff --git a/librarian/rarian-omf.cpp b/librarian/rarian-omf.cpp
>index 17c08da..bfa3a36 100644
>--- a/librarian/rarian-omf.cpp
>+++ b/librarian/rarian-omf.cpp
>@@ -26,7 +26,7 @@
> #include <dirent.h>
> #include <unistd.h>
> 
>-#include <../util/tinyxml.h>
>+#include <tinyxml.h>
> 
> #include <stdio.h>
> #include <sys/types.h>
>@@ -116,10 +116,10 @@ process_node (TiXmlNode *pParent, RrnReg *reg)
> 
> 	switch ( t )
> 	{
>-	case TiXmlNode::DOCUMENT:
>+	case TiXmlNode::TINYXML_DOCUMENT:
> 		break;
> 
>-	case TiXmlNode::ELEMENT:
>+	case TiXmlNode::TINYXML_ELEMENT:
> 	   if (!strcmp (pParent->Value(), "omf")) {
> 	       am_parsing = true;
> 	   } else if (!am_parsing) {
>diff --git a/util/Makefile.am b/util/Makefile.am
>index 9967a65..5861965 100644
>--- a/util/Makefile.am
>+++ b/util/Makefile.am
>@@ -1,7 +1,8 @@
> INCLUDES =      \
>     -I$(srcdir)/../librarian
> LDADD =         \
>-    ../librarian/librarian.la
>+    ../librarian/librarian.la \
>+    $(RARIAN_LIBS)
> 
> if ENABLE_SK_COMPAT
> bin_SCRIPTS = \
>@@ -39,32 +40,14 @@ endif
> if ENABLE_SK_COMPAT
> rarian_sk_migrate_SOURCES =  \
>     rarian-sk-migrate.cpp    \
>-    tinystr.cpp             \
>-    tinyxml.cpp             \
>-    tinyxmlerror.cpp        \
>-    tinyxmlparser.cpp       \
>-    tinystr.h               \
>-    tinyxml.h               \
>     ../librarian/rarian-reg-full.h \
>     ../librarian/rarian-reg-full.c
> 
> rarian_sk_preinstall_SOURCES = \
>-    rarian-sk-preinstall.cpp \
>-    tinystr.cpp             \
>-    tinyxml.cpp             \
>-    tinyxmlerror.cpp        \
>-    tinyxmlparser.cpp       \
>-    tinystr.h               \
>-    tinyxml.h
>+    rarian-sk-preinstall.cpp
> 
> rarian_sk_get_cl_SOURCES =  \
>-    rarian-sk-get-cl.cpp    \
>-    tinystr.cpp             \
>-    tinyxml.cpp             \
>-    tinyxmlerror.cpp        \
>-    tinyxmlparser.cpp       \
>-    tinystr.h               \
>-    tinyxml.h
>+    rarian-sk-get-cl.cpp
> 
> rarian_sk_get_cl_CXXFLAGS = -DDATADIR=\""$(datadir)"\" -DLOCALSTATEDIR=\""$(localstatedir)"\"
> 
>diff --git a/util/rarian-sk-get-cl.cpp b/util/rarian-sk-get-cl.cpp
>index 776b64c..0a10b33 100644
>--- a/util/rarian-sk-get-cl.cpp
>+++ b/util/rarian-sk-get-cl.cpp
>@@ -131,10 +131,10 @@ process_node (TiXmlNode *pParent)
> 
> 	switch ( t )
> 	{
>-	case TiXmlNode::DOCUMENT:
>+	case TiXmlNode::TINYXML_DOCUMENT:
> 		break;
> 
>-	case TiXmlNode::ELEMENT:
>+	case TiXmlNode::TINYXML_ELEMENT:
> 	   if (!strcmp (pParent->Value(), "sect")) {
> 	     get_attribute (pParent->ToElement());
>       	     rrn_for_each_in_category ((RrnForeachFunc) get_docs, cat, pParent);
>@@ -223,7 +223,7 @@ int main (int argc, char * argv[])
>     exit (2);
>   }
>   
>-  TiXmlNode *pParent = doc.FirstChildElement();
>+  TiXmlNode *pParent = doc.FirstChild();
>   
>   process_node (pParent);
>   
>diff --git a/util/rarian-sk-migrate.cpp b/util/rarian-sk-migrate.cpp
>index 4294eb3..97e4efc 100644
>--- a/util/rarian-sk-migrate.cpp
>+++ b/util/rarian-sk-migrate.cpp
>@@ -195,10 +195,10 @@ process_node (TiXmlNode *pParent)
> 
> 	switch ( t )
> 	{
>-	case TiXmlNode::DOCUMENT:
>+	case TiXmlNode::TINYXML_DOCUMENT:
> 		break;
> 
>-	case TiXmlNode::ELEMENT:
>+	case TiXmlNode::TINYXML_ELEMENT:
> 	   if (!strcmp (pParent->Value(), "omf")) {
> 	       am_parsing = true;
> 	   } else if (!am_parsing) {
>@@ -262,7 +262,7 @@ process_file (char *path, char *fname)
>         exit (2);
>     }
> 
>-    TiXmlNode *pParent = doc.FirstChildElement();
>+    TiXmlNode *pParent = doc.FirstChild();
> 
>     process_node (pParent);
> 
>diff --git a/util/rarian-sk-preinstall.cpp b/util/rarian-sk-preinstall.cpp
>index 3891140..46490c2 100644
>--- a/util/rarian-sk-preinstall.cpp
>+++ b/util/rarian-sk-preinstall.cpp
>@@ -58,10 +58,10 @@ process_node (TiXmlNode *pParent)
> 
> 	switch ( t )
> 	{
>-	case TiXmlNode::DOCUMENT:
>+	case TiXmlNode::TINYXML_DOCUMENT:
> 		break;
> 
>-	case TiXmlNode::ELEMENT:
>+	case TiXmlNode::TINYXML_ELEMENT:
> 	   if (!strcmp (pParent->Value(), "omf")) {
> 	       am_parsing = true;
> 	   } else if (!am_parsing) {
>@@ -129,7 +129,7 @@ int main (int argc, char * argv[])
>     exit (2);
>   }
>   
>-  TiXmlNode *pParent = doc.FirstChildElement();
>+  TiXmlNode *pParent = doc.FirstChild();
>   
>   process_node (pParent);
>   
>diff --git a/util/tinystr.cpp b/util/tinystr.cpp
>deleted file mode 100644
>index 4125242..0000000
>--- a/util/tinystr.cpp
>+++ /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.
>- */
>-
>-
>-#ifndef TIXML_USE_STL
>-
>-#include "tinystr.h"
>-
>-// Error value for find primitive
>-const TiXmlString::size_type TiXmlString::npos = static_cast< 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
>diff --git a/util/tinystr.h b/util/tinystr.h
>deleted file mode 100644
>index 6e3b999..0000000
>--- a/util/tinystr.h
>+++ /dev/null
>@@ -1,319 +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
>-
>-#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)
>-	{
>-		init(copy.length());
>-		memcpy(start(), copy.data(), length());
>-	}
>-
>-	// TiXmlString constructor, based on a string
>-	TIXML_EXPLICIT TiXmlString ( const char * copy)
>-	{
>-		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)
>-	{
>-		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
>diff --git a/util/tinyxml.cpp b/util/tinyxml.cpp
>deleted file mode 100644
>index 6a83291..0000000
>--- a/util/tinyxml.cpp
>+++ /dev/null
>@@ -1,1799 +0,0 @@
>-/*
>-www.sourceforge.net/projects/tinyxml
>-Original code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com)
>-
>-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.
>-*/
>-
>-#include <ctype.h>
>-#include "tinyxml.h"
>-
>-#ifdef TIXML_USE_STL
>-#include <sstream>
>-#include <iostream>
>-#endif
>-
>-
>-bool TiXmlBase::condenseWhiteSpace = true;
>-
>-void TiXmlBase::PutString( const TIXML_STRING& str, TIXML_OSTREAM* stream )
>-{
>-	TIXML_STRING buffer;
>-	PutString( str, &buffer );
>-	(*stream) << buffer;
>-}
>-
>-void TiXmlBase::PutString( const TIXML_STRING& str, TIXML_STRING* outString )
>-{
>-	int i=0;
>-
>-	while( i<(int)str.length() )
>-	{
>-		unsigned char c = (unsigned char) str[i];
>-
>-		if (    c == '&' 
>-		     && i < ( (int)str.length() - 2 )
>-			 && str[i+1] == '#'
>-			 && str[i+2] == 'x' )
>-		{
>-			// Hexadecimal character reference.
>-			// Pass through unchanged.
>-			// &#xA9;	-- copyright symbol, for example.
>-			//
>-			// The -1 is a bug fix from Rob Laveaux. It keeps
>-			// an overflow from happening if there is no ';'.
>-			// There are actually 2 ways to exit this loop -
>-			// while fails (error case) and break (semicolon found).
>-			// However, there is no mechanism (currently) for
>-			// this function to return an error.
>-			while ( i<(int)str.length()-1 )
>-			{
>-				outString->append( str.c_str() + i, 1 );
>-				++i;
>-				if ( str[i] == ';' )
>-					break;
>-			}
>-		}
>-		else if ( c == '&' )
>-		{
>-			outString->append( entity[0].str, entity[0].strLength );
>-			++i;
>-		}
>-		else if ( c == '<' )
>-		{
>-			outString->append( entity[1].str, entity[1].strLength );
>-			++i;
>-		}
>-		else if ( c == '>' )
>-		{
>-			outString->append( entity[2].str, entity[2].strLength );
>-			++i;
>-		}
>-		else if ( c == '\"' )
>-		{
>-			outString->append( entity[3].str, entity[3].strLength );
>-			++i;
>-		}
>-		else if ( c == '\'' )
>-		{
>-			outString->append( entity[4].str, entity[4].strLength );
>-			++i;
>-		}
>-		else if ( c < 32 )
>-		{
>-			// Easy pass at non-alpha/numeric/symbol
>-			// Below 32 is symbolic.
>-			char buf[ 32 ];
>-			
>-			#if defined(TIXML_SNPRINTF)		
>-				TIXML_SNPRINTF( buf, sizeof(buf), "&#x%02X;", (unsigned) ( c & 0xff ) );
>-			#else
>-				sprintf( buf, "&#x%02X;", (unsigned) ( c & 0xff ) );
>-			#endif		
>-
>-			//*ME:	warning C4267: convert 'size_t' to 'int'
>-			//*ME:	Int-Cast to make compiler happy ...
>-			outString->append( buf, (int)strlen( buf ) );
>-			++i;
>-		}
>-		else
>-		{
>-			//char realc = (char) c;
>-			//outString->append( &realc, 1 );
>-			*outString += (char) c;	// somewhat more efficient function call.
>-			++i;
>-		}
>-	}
>-}
>-
>-
>-// <-- Strange class for a bug fix. Search for STL_STRING_BUG
>-TiXmlBase::StringToBuffer::StringToBuffer( const TIXML_STRING& str )
>-{
>-	buffer = new char[ str.length()+1 ];
>-	if ( buffer )
>-	{
>-		strcpy( buffer, str.c_str() );
>-	}
>-}
>-
>-
>-TiXmlBase::StringToBuffer::~StringToBuffer()
>-{
>-	delete [] buffer;
>-}
>-// End strange bug fix. -->
>-
>-
>-TiXmlNode::TiXmlNode( NodeType _type ) : TiXmlBase()
>-{
>-	parent = 0;
>-	type = _type;
>-	firstChild = 0;
>-	lastChild = 0;
>-	prev = 0;
>-	next = 0;
>-}
>-
>-
>-TiXmlNode::~TiXmlNode()
>-{
>-	TiXmlNode* node = firstChild;
>-	TiXmlNode* temp = 0;
>-
>-	while ( node )
>-	{
>-		temp = node;
>-		node = node->next;
>-		delete temp;
>-	}	
>-}
>-
>-
>-void TiXmlNode::CopyTo( TiXmlNode* target ) const
>-{
>-	target->SetValue (value.c_str() );
>-	target->userData = userData; 
>-}
>-
>-
>-void TiXmlNode::Clear()
>-{
>-	TiXmlNode* node = firstChild;
>-	TiXmlNode* temp = 0;
>-
>-	while ( node )
>-	{
>-		temp = node;
>-		node = node->next;
>-		delete temp;
>-	}	
>-
>-	firstChild = 0;
>-	lastChild = 0;
>-}
>-
>-
>-TiXmlNode* TiXmlNode::LinkEndChild( TiXmlNode* node )
>-{
>-	assert( node->parent == 0 || node->parent == this );
>-	assert( node->GetDocument() == 0 || node->GetDocument() == this->GetDocument() );
>-
>-	node->parent = this;
>-
>-	node->prev = lastChild;
>-	node->next = 0;
>-
>-	if ( lastChild )
>-		lastChild->next = node;
>-	else
>-		firstChild = node;			// it was an empty list.
>-
>-	lastChild = node;
>-	return node;
>-}
>-
>-
>-TiXmlNode* TiXmlNode::InsertEndChild( const TiXmlNode& addThis )
>-{
>-	TiXmlNode* node = addThis.Clone();
>-	if ( !node )
>-		return 0;
>-
>-	return LinkEndChild( node );
>-}
>-
>-
>-TiXmlNode* TiXmlNode::InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis )
>-{	
>-	if ( !beforeThis || beforeThis->parent != this )
>-		return 0;
>-
>-	TiXmlNode* node = addThis.Clone();
>-	if ( !node )
>-		return 0;
>-	node->parent = this;
>-
>-	node->next = beforeThis;
>-	node->prev = beforeThis->prev;
>-	if ( beforeThis->prev )
>-	{
>-		beforeThis->prev->next = node;
>-	}
>-	else
>-	{
>-		assert( firstChild == beforeThis );
>-		firstChild = node;
>-	}
>-	beforeThis->prev = node;
>-	return node;
>-}
>-
>-
>-TiXmlNode* TiXmlNode::InsertAfterChild( TiXmlNode* afterThis, const TiXmlNode& addThis )
>-{
>-	if ( !afterThis || afterThis->parent != this )
>-		return 0;
>-
>-	TiXmlNode* node = addThis.Clone();
>-	if ( !node )
>-		return 0;
>-	node->parent = this;
>-
>-	node->prev = afterThis;
>-	node->next = afterThis->next;
>-	if ( afterThis->next )
>-	{
>-		afterThis->next->prev = node;
>-	}
>-	else
>-	{
>-		assert( lastChild == afterThis );
>-		lastChild = node;
>-	}
>-	afterThis->next = node;
>-	return node;
>-}
>-
>-
>-TiXmlNode* TiXmlNode::ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis )
>-{
>-	if ( replaceThis->parent != this )
>-		return 0;
>-
>-	TiXmlNode* node = withThis.Clone();
>-	if ( !node )
>-		return 0;
>-
>-	node->next = replaceThis->next;
>-	node->prev = replaceThis->prev;
>-
>-	if ( replaceThis->next )
>-		replaceThis->next->prev = node;
>-	else
>-		lastChild = node;
>-
>-	if ( replaceThis->prev )
>-		replaceThis->prev->next = node;
>-	else
>-		firstChild = node;
>-
>-	delete replaceThis;
>-	node->parent = this;
>-	return node;
>-}
>-
>-
>-bool TiXmlNode::RemoveChild( TiXmlNode* removeThis )
>-{
>-	if ( removeThis->parent != this )
>-	{	
>-		assert( 0 );
>-		return false;
>-	}
>-
>-	if ( removeThis->next )
>-		removeThis->next->prev = removeThis->prev;
>-	else
>-		lastChild = removeThis->prev;
>-
>-	if ( removeThis->prev )
>-		removeThis->prev->next = removeThis->next;
>-	else
>-		firstChild = removeThis->next;
>-
>-	delete removeThis;
>-	return true;
>-}
>-
>-const TiXmlNode* TiXmlNode::FirstChild( const char * _value ) const
>-{
>-	const TiXmlNode* node;
>-	for ( node = firstChild; node; node = node->next )
>-	{
>-		if ( strcmp( node->Value(), _value ) == 0 )
>-			return node;
>-	}
>-	return 0;
>-}
>-
>-
>-TiXmlNode* TiXmlNode::FirstChild( const char * _value )
>-{
>-	TiXmlNode* node;
>-	for ( node = firstChild; node; node = node->next )
>-	{
>-		if ( strcmp( node->Value(), _value ) == 0 )
>-			return node;
>-	}
>-	return 0;
>-}
>-
>-
>-const TiXmlNode* TiXmlNode::LastChild( const char * _value ) const
>-{
>-	const TiXmlNode* node;
>-	for ( node = lastChild; node; node = node->prev )
>-	{
>-		if ( strcmp( node->Value(), _value ) == 0 )
>-			return node;
>-	}
>-	return 0;
>-}
>-
>-TiXmlNode* TiXmlNode::LastChild( const char * _value )
>-{
>-	TiXmlNode* node;
>-	for ( node = lastChild; node; node = node->prev )
>-	{
>-		if ( strcmp( node->Value(), _value ) == 0 )
>-			return node;
>-	}
>-	return 0;
>-}
>-
>-const TiXmlNode* TiXmlNode::IterateChildren( const TiXmlNode* previous ) const
>-{
>-	if ( !previous )
>-	{
>-		return FirstChild();
>-	}
>-	else
>-	{
>-		assert( previous->parent == this );
>-		return previous->NextSibling();
>-	}
>-}
>-
>-TiXmlNode* TiXmlNode::IterateChildren( TiXmlNode* previous )
>-{
>-	if ( !previous )
>-	{
>-		return FirstChild();
>-	}
>-	else
>-	{
>-		assert( previous->parent == this );
>-		return previous->NextSibling();
>-	}
>-}
>-
>-const TiXmlNode* TiXmlNode::IterateChildren( const char * val, const TiXmlNode* previous ) const
>-{
>-	if ( !previous )
>-	{
>-		return FirstChild( val );
>-	}
>-	else
>-	{
>-		assert( previous->parent == this );
>-		return previous->NextSibling( val );
>-	}
>-}
>-
>-TiXmlNode* TiXmlNode::IterateChildren( const char * val, TiXmlNode* previous )
>-{
>-	if ( !previous )
>-	{
>-		return FirstChild( val );
>-	}
>-	else
>-	{
>-		assert( previous->parent == this );
>-		return previous->NextSibling( val );
>-	}
>-}
>-
>-const TiXmlNode* TiXmlNode::NextSibling( const char * _value ) const 
>-{
>-	const TiXmlNode* node;
>-	for ( node = next; node; node = node->next )
>-	{
>-		if ( strcmp( node->Value(), _value ) == 0 )
>-			return node;
>-	}
>-	return 0;
>-}
>-
>-TiXmlNode* TiXmlNode::NextSibling( const char * _value )
>-{
>-	TiXmlNode* node;
>-	for ( node = next; node; node = node->next )
>-	{
>-		if ( strcmp( node->Value(), _value ) == 0 )
>-			return node;
>-	}
>-	return 0;
>-}
>-
>-const TiXmlNode* TiXmlNode::PreviousSibling( const char * _value ) const
>-{
>-	const TiXmlNode* node;
>-	for ( node = prev; node; node = node->prev )
>-	{
>-		if ( strcmp( node->Value(), _value ) == 0 )
>-			return node;
>-	}
>-	return 0;
>-}
>-
>-TiXmlNode* TiXmlNode::PreviousSibling( const char * _value )
>-{
>-	TiXmlNode* node;
>-	for ( node = prev; node; node = node->prev )
>-	{
>-		if ( strcmp( node->Value(), _value ) == 0 )
>-			return node;
>-	}
>-	return 0;
>-}
>-
>-void TiXmlElement::RemoveAttribute( const char * name )
>-{
>-	TIXML_STRING str( name );
>-	TiXmlAttribute* node = attributeSet.Find( str );
>-	if ( node )
>-	{
>-		attributeSet.Remove( node );
>-		delete node;
>-	}
>-}
>-
>-const TiXmlElement* TiXmlNode::FirstChildElement() const
>-{
>-	const TiXmlNode* node;
>-
>-	for (	node = FirstChild();
>-			node;
>-			node = node->NextSibling() )
>-	{
>-		if ( node->ToElement() )
>-			return node->ToElement();
>-	}
>-	return 0;
>-}
>-
>-TiXmlElement* TiXmlNode::FirstChildElement()
>-{
>-	TiXmlNode* node;
>-
>-	for (	node = FirstChild();
>-			node;
>-			node = node->NextSibling() )
>-	{
>-		if ( node->ToElement() )
>-			return node->ToElement();
>-	}
>-	return 0;
>-}
>-
>-const TiXmlElement* TiXmlNode::FirstChildElement( const char * _value ) const
>-{
>-	const TiXmlNode* node;
>-
>-	for (	node = FirstChild( _value );
>-			node;
>-			node = node->NextSibling( _value ) )
>-	{
>-		if ( node->ToElement() )
>-			return node->ToElement();
>-	}
>-	return 0;
>-}
>-
>-TiXmlElement* TiXmlNode::FirstChildElement( const char * _value )
>-{
>-	TiXmlNode* node;
>-
>-	for (	node = FirstChild( _value );
>-			node;
>-			node = node->NextSibling( _value ) )
>-	{
>-		if ( node->ToElement() )
>-			return node->ToElement();
>-	}
>-	return 0;
>-}
>-
>-const TiXmlElement* TiXmlNode::NextSiblingElement() const
>-{
>-	const TiXmlNode* node;
>-
>-	for (	node = NextSibling();
>-	node;
>-	node = node->NextSibling() )
>-	{
>-		if ( node->ToElement() )
>-			return node->ToElement();
>-	}
>-	return 0;
>-}
>-
>-TiXmlElement* TiXmlNode::NextSiblingElement()
>-{
>-	TiXmlNode* node;
>-
>-	for (	node = NextSibling();
>-	node;
>-	node = node->NextSibling() )
>-	{
>-		if ( node->ToElement() )
>-			return node->ToElement();
>-	}
>-	return 0;
>-}
>-
>-const TiXmlElement* TiXmlNode::NextSiblingElement( const char * _value ) const
>-{
>-	const TiXmlNode* node;
>-
>-	for (	node = NextSibling( _value );
>-	node;
>-	node = node->NextSibling( _value ) )
>-	{
>-		if ( node->ToElement() )
>-			return node->ToElement();
>-	}
>-	return 0;
>-}
>-
>-TiXmlElement* TiXmlNode::NextSiblingElement( const char * _value )
>-{
>-	TiXmlNode* node;
>-
>-	for (	node = NextSibling( _value );
>-	node;
>-	node = node->NextSibling( _value ) )
>-	{
>-		if ( node->ToElement() )
>-			return node->ToElement();
>-	}
>-	return 0;
>-}
>-
>-
>-const TiXmlDocument* TiXmlNode::GetDocument() const
>-{
>-	const TiXmlNode* node;
>-
>-	for( node = this; node; node = node->parent )
>-	{
>-		if ( node->ToDocument() )
>-			return node->ToDocument();
>-	}
>-	return 0;
>-}
>-
>-TiXmlDocument* TiXmlNode::GetDocument()
>-{
>-	TiXmlNode* node;
>-
>-	for( node = this; node; node = node->parent )
>-	{
>-		if ( node->ToDocument() )
>-			return node->ToDocument();
>-	}
>-	return 0;
>-}
>-
>-TiXmlElement::TiXmlElement (const char * _value)
>-	: TiXmlNode( TiXmlNode::ELEMENT )
>-{
>-	firstChild = lastChild = 0;
>-	value = _value;
>-}
>-
>-
>-#ifdef TIXML_USE_STL
>-TiXmlElement::TiXmlElement( const std::string& _value ) 
>-	: TiXmlNode( TiXmlNode::ELEMENT )
>-{
>-	firstChild = lastChild = 0;
>-	value = _value;
>-}
>-#endif
>-
>-
>-TiXmlElement::TiXmlElement( const TiXmlElement& copy)
>-	: TiXmlNode( TiXmlNode::ELEMENT )
>-{
>-	firstChild = lastChild = 0;
>-	copy.CopyTo( this );	
>-}
>-
>-
>-void TiXmlElement::operator=( const TiXmlElement& base )
>-{
>-	ClearThis();
>-	base.CopyTo( this );
>-}
>-
>-
>-TiXmlElement::~TiXmlElement()
>-{
>-	ClearThis();
>-}
>-
>-
>-void TiXmlElement::ClearThis()
>-{
>-	Clear();
>-	while( attributeSet.First() )
>-	{
>-		TiXmlAttribute* node = attributeSet.First();
>-		attributeSet.Remove( node );
>-		delete node;
>-	}
>-}
>-
>-
>-const char * TiXmlElement::Attribute( const char * name ) const
>-{
>-	TIXML_STRING str( name );
>-	const TiXmlAttribute* node = attributeSet.Find( str );
>-
>-	if ( node )
>-		return node->Value();
>-
>-	return 0;
>-}
>-
>-
>-const char * TiXmlElement::Attribute( const char * name, int* i ) const
>-{
>-	const char * s = Attribute( name );
>-	if ( i )
>-	{
>-		if ( s )
>-			*i = atoi( s );
>-		else
>-			*i = 0;
>-	}
>-	return s;
>-}
>-
>-
>-const char * TiXmlElement::Attribute( const char * name, double* d ) const
>-{
>-	const char * s = Attribute( name );
>-	if ( d )
>-	{
>-		if ( s )
>-			*d = atof( s );
>-		else
>-			*d = 0;
>-	}
>-	return s;
>-}
>-
>-
>-int TiXmlElement::QueryIntAttribute( const char* name, int* ival ) const
>-{
>-	TIXML_STRING str( name );
>-	const TiXmlAttribute* node = attributeSet.Find( str );
>-	if ( !node )
>-		return TIXML_NO_ATTRIBUTE;
>-
>-	return node->QueryIntValue( ival );
>-}
>-
>-
>-int TiXmlElement::QueryDoubleAttribute( const char* name, double* dval ) const
>-{
>-	TIXML_STRING str( name );
>-	const TiXmlAttribute* node = attributeSet.Find( str );
>-	if ( !node )
>-		return TIXML_NO_ATTRIBUTE;
>-
>-	return node->QueryDoubleValue( dval );
>-}
>-
>-
>-void TiXmlElement::SetAttribute( const char * name, int val )
>-{	
>-	char buf[64];
>-	#if defined(TIXML_SNPRINTF)		
>-		TIXML_SNPRINTF( buf, sizeof(buf), "%d", val );
>-	#else
>-		sprintf( buf, "%d", val );
>-	#endif
>-	SetAttribute( name, buf );
>-}
>-
>-
>-#ifdef TIXML_USE_STL
>-void TiXmlElement::SetAttribute( const std::string& name, int val )
>-{	
>-   std::ostringstream oss;
>-   oss << val;
>-   SetAttribute( name, oss.str() );
>-}
>-#endif
>-
>-
>-void TiXmlElement::SetDoubleAttribute( const char * name, double val )
>-{	
>-	char buf[256];
>-	#if defined(TIXML_SNPRINTF)		
>-		TIXML_SNPRINTF( buf, sizeof(buf), "%f", val );
>-	#else
>-		sprintf( buf, "%f", val );
>-	#endif
>-	SetAttribute( name, buf );
>-}
>-
>-
>-void TiXmlElement::SetAttribute( const char * cname, const char * cvalue )
>-{
>-	TIXML_STRING _name( cname );
>-	TIXML_STRING _value( cvalue );
>-
>-	TiXmlAttribute* node = attributeSet.Find( _name );
>-	if ( node )
>-	{
>-		node->SetValue( cvalue );
>-		return;
>-	}
>-
>-	TiXmlAttribute* attrib = new TiXmlAttribute( cname, cvalue );
>-	if ( attrib )
>-	{
>-		attributeSet.Add( attrib );
>-	}
>-	else
>-	{
>-		TiXmlDocument* document = GetDocument();
>-		if ( document ) document->SetError( TIXML_ERROR_OUT_OF_MEMORY, 0, 0, TIXML_ENCODING_UNKNOWN );
>-	}
>-}
>-
>-
>-#ifdef TIXML_USE_STL
>-void TiXmlElement::SetAttribute( const std::string& name, const std::string& _value )
>-{
>-	TiXmlAttribute* node = attributeSet.Find( name );
>-	if ( node )
>-	{
>-		node->SetValue( _value );
>-		return;
>-	}
>-
>-	TiXmlAttribute* attrib = new TiXmlAttribute( name, _value );
>-	if ( attrib )
>-	{
>-		attributeSet.Add( attrib );
>-	}
>-	else
>-	{
>-		TiXmlDocument* document = GetDocument();
>-		if ( document ) document->SetError( TIXML_ERROR_OUT_OF_MEMORY, 0, 0, TIXML_ENCODING_UNKNOWN );
>-	}
>-}
>-#endif
>-
>-
>-void TiXmlElement::Print( FILE* cfile, int depth ) const
>-{
>-	int i;
>-	for ( i=0; i<depth; i++ )
>-	{
>-		fprintf( cfile, "    " );
>-	}
>-
>-	fprintf( cfile, "<%s", value.c_str() );
>-
>-	const TiXmlAttribute* attrib;
>-	for ( attrib = attributeSet.First(); attrib; attrib = attrib->Next() )
>-	{
>-		fprintf( cfile, " " );
>-		attrib->Print( cfile, depth );
>-	}
>-
>-	// There are 3 different formatting approaches:
>-	// 1) An element without children is printed as a <foo /> node
>-	// 2) An element with only a text child is printed as <foo> text </foo>
>-	// 3) An element with children is printed on multiple lines.
>-	TiXmlNode* node;
>-	if ( !firstChild )
>-	{
>-		fprintf( cfile, " />" );
>-	}
>-	else if ( firstChild == lastChild && firstChild->ToText() )
>-	{
>-		fprintf( cfile, ">" );
>-		firstChild->Print( cfile, depth + 1 );
>-		fprintf( cfile, "</%s>", value.c_str() );
>-	}
>-	else
>-	{
>-		fprintf( cfile, ">" );
>-
>-		for ( node = firstChild; node; node=node->NextSibling() )
>-		{
>-			if ( !node->ToText() )
>-			{
>-				fprintf( cfile, "\n" );
>-			}
>-			node->Print( cfile, depth+1 );
>-		}
>-		fprintf( cfile, "\n" );
>-		for( i=0; i<depth; ++i )
>-		fprintf( cfile, "    " );
>-		fprintf( cfile, "</%s>", value.c_str() );
>-	}
>-}
>-
>-void TiXmlElement::StreamOut( TIXML_OSTREAM * stream ) const
>-{
>-	(*stream) << "<" << value;
>-
>-	const TiXmlAttribute* attrib;
>-	for ( attrib = attributeSet.First(); attrib; attrib = attrib->Next() )
>-	{	
>-		(*stream) << " ";
>-		attrib->StreamOut( stream );
>-	}
>-
>-	// If this node has children, give it a closing tag. Else
>-	// make it an empty tag.
>-	TiXmlNode* node;
>-	if ( firstChild )
>-	{ 		
>-		(*stream) << ">";
>-
>-		for ( node = firstChild; node; node=node->NextSibling() )
>-		{
>-			node->StreamOut( stream );
>-		}
>-		(*stream) << "</" << value << ">";
>-	}
>-	else
>-	{
>-		(*stream) << " />";
>-	}
>-}
>-
>-
>-void TiXmlElement::CopyTo( TiXmlElement* target ) const
>-{
>-	// superclass:
>-	TiXmlNode::CopyTo( target );
>-
>-	// Element class: 
>-	// Clone the attributes, then clone the children.
>-	const TiXmlAttribute* attribute = 0;
>-	for(	attribute = attributeSet.First();
>-	attribute;
>-	attribute = attribute->Next() )
>-	{
>-		target->SetAttribute( attribute->Name(), attribute->Value() );
>-	}
>-
>-	TiXmlNode* node = 0;
>-	for ( node = firstChild; node; node = node->NextSibling() )
>-	{
>-		target->LinkEndChild( node->Clone() );
>-	}
>-}
>-
>-
>-TiXmlNode* TiXmlElement::Clone() const
>-{
>-	TiXmlElement* clone = new TiXmlElement( Value() );
>-	if ( !clone )
>-		return 0;
>-
>-	CopyTo( clone );
>-	return clone;
>-}
>-
>-
>-const char* TiXmlElement::GetText() const
>-{
>-	const TiXmlNode* child = this->FirstChild();
>-	if ( child ) {
>-		const TiXmlText* childText = child->ToText();
>-		if ( childText ) {
>-			return childText->Value();
>-		}
>-	}
>-	return 0;
>-}
>-
>-
>-TiXmlDocument::TiXmlDocument() : TiXmlNode( TiXmlNode::DOCUMENT )
>-{
>-	tabsize = 4;
>-	useMicrosoftBOM = false;
>-	ClearError();
>-}
>-
>-TiXmlDocument::TiXmlDocument( const char * documentName ) : TiXmlNode( TiXmlNode::DOCUMENT )
>-{
>-	tabsize = 4;
>-	useMicrosoftBOM = false;
>-	value = documentName;
>-	ClearError();
>-}
>-
>-
>-#ifdef TIXML_USE_STL
>-TiXmlDocument::TiXmlDocument( const std::string& documentName ) : TiXmlNode( TiXmlNode::DOCUMENT )
>-{
>-	tabsize = 4;
>-	useMicrosoftBOM = false;
>-    value = documentName;
>-	ClearError();
>-}
>-#endif
>-
>-
>-TiXmlDocument::TiXmlDocument( const TiXmlDocument& copy ) : TiXmlNode( TiXmlNode::DOCUMENT )
>-{
>-	copy.CopyTo( this );
>-}
>-
>-
>-void TiXmlDocument::operator=( const TiXmlDocument& copy )
>-{
>-	Clear();
>-	copy.CopyTo( this );
>-}
>-
>-
>-bool TiXmlDocument::LoadFile( TiXmlEncoding encoding )
>-{
>-	// See STL_STRING_BUG below.
>-	StringToBuffer buf( value );
>-
>-	if ( buf.buffer && LoadFile( buf.buffer, encoding ) )
>-		return true;
>-
>-	return false;
>-}
>-
>-
>-bool TiXmlDocument::SaveFile() const
>-{
>-	// See STL_STRING_BUG below.
>-	StringToBuffer buf( value );
>-
>-	if ( buf.buffer && SaveFile( buf.buffer ) )
>-		return true;
>-
>-	return false;
>-}
>-
>-bool TiXmlDocument::LoadFile( const char* filename, TiXmlEncoding encoding )
>-{
>-	// There was a really terrifying little bug here. The code:
>-	//		value = filename
>-	// in the STL case, cause the assignment method of the std::string to
>-	// be called. What is strange, is that the std::string had the same
>-	// address as it's c_str() method, and so bad things happen. Looks
>-	// like a bug in the Microsoft STL implementation.
>-	// See STL_STRING_BUG above.
>-	// Fixed with the StringToBuffer class.
>-	value = filename;
>-
>-	// reading in binary mode so that tinyxml can normalize the EOL
>-	FILE* file = fopen( value.c_str (), "rb" );	
>-
>-	if ( file )
>-	{
>-		bool result = LoadFile( file, encoding );
>-		fclose( file );
>-		return result;
>-	}
>-	else
>-	{
>-		SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
>-		return false;
>-	}
>-}
>-
>-bool TiXmlDocument::LoadFile( FILE* file, TiXmlEncoding encoding )
>-{
>-	if ( !file ) 
>-	{
>-		SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
>-		return false;
>-	}
>-
>-	// Delete the existing data:
>-	Clear();
>-	location.Clear();
>-
>-	// Get the file size, so we can pre-allocate the string. HUGE speed impact.
>-	long length = 0;
>-	fseek( file, 0, SEEK_END );
>-	length = ftell( file );
>-	fseek( file, 0, SEEK_SET );
>-
>-	// Strange case, but good to handle up front.
>-	if ( length == 0 )
>-	{
>-		SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN );
>-		return false;
>-	}
>-
>-	// If we have a file, assume it is all one big XML file, and read it in.
>-	// The document parser may decide the document ends sooner than the entire file, however.
>-	TIXML_STRING data;
>-	data.reserve( length );
>-
>-	// Subtle bug here. TinyXml did use fgets. But from the XML spec:
>-	// 2.11 End-of-Line Handling
>-	// <snip>
>-	// <quote>
>-	// ...the XML processor MUST behave as if it normalized all line breaks in external 
>-	// parsed entities (including the document entity) on input, before parsing, by translating 
>-	// both the two-character sequence #xD #xA and any #xD that is not followed by #xA to 
>-	// a single #xA character.
>-	// </quote>
>-	//
>-	// It is not clear fgets does that, and certainly isn't clear it works cross platform. 
>-	// Generally, you expect fgets to translate from the convention of the OS to the c/unix
>-	// convention, and not work generally.
>-
>-	/*
>-	while( fgets( buf, sizeof(buf), file ) )
>-	{
>-		data += buf;
>-	}
>-	*/
>-
>-	char* buf = new char[ length+1 ];
>-	buf[0] = 0;
>-
>-	if ( fread( buf, length, 1, file ) != 1 ) {
>-		SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
>-		return false;
>-	}
>-
>-	const char* lastPos = buf;
>-	const char* p = buf;
>-
>-	buf[length] = 0;
>-	while( *p ) {
>-		assert( p < (buf+length) );
>-		if ( *p == 0xa ) {
>-			// Newline character. No special rules for this. Append all the characters
>-			// since the last string, and include the newline.
>-			data.append( lastPos, (p-lastPos+1) );	// append, include the newline
>-			++p;									// move past the newline
>-			lastPos = p;							// and point to the new buffer (may be 0)
>-			assert( p <= (buf+length) );
>-		}
>-		else if ( *p == 0xd ) {
>-			// Carriage return. Append what we have so far, then
>-			// handle moving forward in the buffer.
>-			if ( (p-lastPos) > 0 ) {
>-				data.append( lastPos, p-lastPos );	// do not add the CR
>-			}
>-			data += (char)0xa;						// a proper newline
>-
>-			if ( *(p+1) == 0xa ) {
>-				// Carriage return - new line sequence
>-				p += 2;
>-				lastPos = p;
>-				assert( p <= (buf+length) );
>-			}
>-			else {
>-				// it was followed by something else...that is presumably characters again.
>-				++p;
>-				lastPos = p;
>-				assert( p <= (buf+length) );
>-			}
>-		}
>-		else {
>-			++p;
>-		}
>-	}
>-	// Handle any left over characters.
>-	if ( p-lastPos ) {
>-		data.append( lastPos, p-lastPos );
>-	}		
>-	delete [] buf;
>-	buf = 0;
>-
>-	Parse( data.c_str(), 0, encoding );
>-
>-	if (  Error() )
>-        return false;
>-    else
>-		return true;
>-}
>-
>-
>-bool TiXmlDocument::SaveFile( const char * filename ) const
>-{
>-	// The old c stuff lives on...
>-	FILE* fp = fopen( filename, "w" );
>-	if ( fp )
>-	{
>-		bool result = SaveFile( fp );
>-		fclose( fp );
>-		return result;
>-	}
>-	return false;
>-}
>-
>-
>-bool TiXmlDocument::SaveFile( FILE* fp ) const
>-{
>-	if ( useMicrosoftBOM ) 
>-	{
>-		const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
>-		const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
>-		const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
>-
>-		fputc( TIXML_UTF_LEAD_0, fp );
>-		fputc( TIXML_UTF_LEAD_1, fp );
>-		fputc( TIXML_UTF_LEAD_2, fp );
>-	}
>-	Print( fp, 0 );
>-	return true;
>-}
>-
>-
>-void TiXmlDocument::CopyTo( TiXmlDocument* target ) const
>-{
>-	TiXmlNode::CopyTo( target );
>-
>-	target->error = error;
>-	target->errorDesc = errorDesc.c_str ();
>-
>-	TiXmlNode* node = 0;
>-	for ( node = firstChild; node; node = node->NextSibling() )
>-	{
>-		target->LinkEndChild( node->Clone() );
>-	}	
>-}
>-
>-
>-TiXmlNode* TiXmlDocument::Clone() const
>-{
>-	TiXmlDocument* clone = new TiXmlDocument();
>-	if ( !clone )
>-		return 0;
>-
>-	CopyTo( clone );
>-	return clone;
>-}
>-
>-
>-void TiXmlDocument::Print( FILE* cfile, int depth ) const
>-{
>-	const TiXmlNode* node;
>-	for ( node=FirstChild(); node; node=node->NextSibling() )
>-	{
>-		node->Print( cfile, depth );
>-		fprintf( cfile, "\n" );
>-	}
>-}
>-
>-void TiXmlDocument::StreamOut( TIXML_OSTREAM * out ) const
>-{
>-	const TiXmlNode* node;
>-	for ( node=FirstChild(); node; node=node->NextSibling() )
>-	{
>-		node->StreamOut( out );
>-
>-		// Special rule for streams: stop after the root element.
>-		// The stream in code will only read one element, so don't
>-		// write more than one.
>-		if ( node->ToElement() )
>-			break;
>-	}
>-}
>-
>-
>-const TiXmlAttribute* TiXmlAttribute::Next() const
>-{
>-	// We are using knowledge of the sentinel. The sentinel
>-	// have a value or name.
>-	if ( next->value.empty() && next->name.empty() )
>-		return 0;
>-	return next;
>-}
>-
>-TiXmlAttribute* TiXmlAttribute::Next()
>-{
>-	// We are using knowledge of the sentinel. The sentinel
>-	// have a value or name.
>-	if ( next->value.empty() && next->name.empty() )
>-		return 0;
>-	return next;
>-}
>-
>-const TiXmlAttribute* TiXmlAttribute::Previous() const
>-{
>-	// We are using knowledge of the sentinel. The sentinel
>-	// have a value or name.
>-	if ( prev->value.empty() && prev->name.empty() )
>-		return 0;
>-	return prev;
>-}
>-
>-TiXmlAttribute* TiXmlAttribute::Previous()
>-{
>-	// We are using knowledge of the sentinel. The sentinel
>-	// have a value or name.
>-	if ( prev->value.empty() && prev->name.empty() )
>-		return 0;
>-	return prev;
>-}
>-
>-void TiXmlAttribute::Print( FILE* cfile, int /*depth*/ ) const
>-{
>-	TIXML_STRING n, v;
>-
>-	PutString( name, &n );
>-	PutString( value, &v );
>-
>-	if (value.find ('\"') == TIXML_STRING::npos)
>-		fprintf (cfile, "%s=\"%s\"", n.c_str(), v.c_str() );
>-	else
>-		fprintf (cfile, "%s='%s'", n.c_str(), v.c_str() );
>-}
>-
>-
>-void TiXmlAttribute::StreamOut( TIXML_OSTREAM * stream ) const
>-{
>-	if (value.find( '\"' ) != TIXML_STRING::npos)
>-	{
>-		PutString( name, stream );
>-		(*stream) << "=" << "'";
>-		PutString( value, stream );
>-		(*stream) << "'";
>-	}
>-	else
>-	{
>-		PutString( name, stream );
>-		(*stream) << "=" << "\"";
>-		PutString( value, stream );
>-		(*stream) << "\"";
>-	}
>-}
>-
>-int TiXmlAttribute::QueryIntValue( int* ival ) const
>-{
>-	if ( sscanf( value.c_str(), "%d", ival ) == 1 )
>-		return TIXML_SUCCESS;
>-	return TIXML_WRONG_TYPE;
>-}
>-
>-int TiXmlAttribute::QueryDoubleValue( double* dval ) const
>-{
>-	if ( sscanf( value.c_str(), "%lf", dval ) == 1 )
>-		return TIXML_SUCCESS;
>-	return TIXML_WRONG_TYPE;
>-}
>-
>-void TiXmlAttribute::SetIntValue( int _value )
>-{
>-	char buf [64];
>-	#if defined(TIXML_SNPRINTF)		
>-		TIXML_SNPRINTF(buf, sizeof(buf), "%d", _value);
>-	#else
>-		sprintf (buf, "%d", _value);
>-	#endif
>-	SetValue (buf);
>-}
>-
>-void TiXmlAttribute::SetDoubleValue( double _value )
>-{
>-	char buf [256];
>-	#if defined(TIXML_SNPRINTF)		
>-		TIXML_SNPRINTF( buf, sizeof(buf), "%lf", _value);
>-	#else
>-		sprintf (buf, "%lf", _value);
>-	#endif
>-	SetValue (buf);
>-}
>-
>-int TiXmlAttribute::IntValue() const
>-{
>-	return atoi (value.c_str ());
>-}
>-
>-double  TiXmlAttribute::DoubleValue() const
>-{
>-	return atof (value.c_str ());
>-}
>-
>-
>-TiXmlComment::TiXmlComment( const TiXmlComment& copy ) : TiXmlNode( TiXmlNode::COMMENT )
>-{
>-	copy.CopyTo( this );
>-}
>-
>-
>-void TiXmlComment::operator=( const TiXmlComment& base )
>-{
>-	Clear();
>-	base.CopyTo( this );
>-}
>-
>-
>-void TiXmlComment::Print( FILE* cfile, int depth ) const
>-{
>-	for ( int i=0; i<depth; i++ )
>-	{
>-		fputs( "    ", cfile );
>-	}
>-	fprintf( cfile, "", value.c_str() );
>-}
>-
>-void TiXmlComment::StreamOut( TIXML_OSTREAM * stream ) const
>-{
>-	(*stream) << "";
>-}
>-
>-
>-void TiXmlComment::CopyTo( TiXmlComment* target ) const
>-{
>-	TiXmlNode::CopyTo( target );
>-}
>-
>-
>-TiXmlNode* TiXmlComment::Clone() const
>-{
>-	TiXmlComment* clone = new TiXmlComment();
>-
>-	if ( !clone )
>-		return 0;
>-
>-	CopyTo( clone );
>-	return clone;
>-}
>-
>-
>-void TiXmlText::Print( FILE* cfile, int depth ) const
>-{
>-	if ( cdata )
>-	{
>-		int i;
>-		fprintf( cfile, "\n" );
>-		for ( i=0; i<depth; i++ ) {
>-			fprintf( cfile, "    " );
>-		}
>-		fprintf( cfile, "<![CDATA[" );
>-		fprintf( cfile, "%s", value.c_str() );	// unformatted output
>-		fprintf( cfile, "]]>\n" );
>-	}
>-	else
>-	{
>-		TIXML_STRING buffer;
>-		PutString( value, &buffer );
>-		fprintf( cfile, "%s", buffer.c_str() );
>-	}
>-}
>-
>-
>-void TiXmlText::StreamOut( TIXML_OSTREAM * stream ) const
>-{
>-	if ( cdata )
>-	{
>-		(*stream) << "<![CDATA[" << value << "]]>";
>-	}
>-	else
>-	{
>-		PutString( value, stream );
>-	}
>-}
>-
>-
>-void TiXmlText::CopyTo( TiXmlText* target ) const
>-{
>-	TiXmlNode::CopyTo( target );
>-	target->cdata = cdata;
>-}
>-
>-
>-TiXmlNode* TiXmlText::Clone() const
>-{	
>-	TiXmlText* clone = 0;
>-	clone = new TiXmlText( "" );
>-
>-	if ( !clone )
>-		return 0;
>-
>-	CopyTo( clone );
>-	return clone;
>-}
>-
>-
>-TiXmlDeclaration::TiXmlDeclaration( const char * _version,
>-									const char * _encoding,
>-									const char * _standalone )
>-	: TiXmlNode( TiXmlNode::DECLARATION )
>-{
>-	version = _version;
>-	encoding = _encoding;
>-	standalone = _standalone;
>-}
>-
>-
>-#ifdef TIXML_USE_STL
>-TiXmlDeclaration::TiXmlDeclaration(	const std::string& _version,
>-									const std::string& _encoding,
>-									const std::string& _standalone )
>-	: TiXmlNode( TiXmlNode::DECLARATION )
>-{
>-	version = _version;
>-	encoding = _encoding;
>-	standalone = _standalone;
>-}
>-#endif
>-
>-
>-TiXmlDeclaration::TiXmlDeclaration( const TiXmlDeclaration& copy )
>-	: TiXmlNode( TiXmlNode::DECLARATION )
>-{
>-	copy.CopyTo( this );	
>-}
>-
>-
>-void TiXmlDeclaration::operator=( const TiXmlDeclaration& copy )
>-{
>-	Clear();
>-	copy.CopyTo( this );
>-}
>-
>-
>-void TiXmlDeclaration::Print( FILE* cfile, int /*depth*/ ) const
>-{
>-	fprintf (cfile, "<?xml ");
>-
>-	if ( !version.empty() )
>-		fprintf (cfile, "version=\"%s\" ", version.c_str ());
>-	if ( !encoding.empty() )
>-		fprintf (cfile, "encoding=\"%s\" ", encoding.c_str ());
>-	if ( !standalone.empty() )
>-		fprintf (cfile, "standalone=\"%s\" ", standalone.c_str ());
>-	fprintf (cfile, "?>");
>-}
>-
>-void TiXmlDeclaration::StreamOut( TIXML_OSTREAM * stream ) const
>-{
>-	(*stream) << "<?xml ";
>-
>-	if ( !version.empty() )
>-	{
>-		(*stream) << "version=\"";
>-		PutString( version, stream );
>-		(*stream) << "\" ";
>-	}
>-	if ( !encoding.empty() )
>-	{
>-		(*stream) << "encoding=\"";
>-		PutString( encoding, stream );
>-		(*stream ) << "\" ";
>-	}
>-	if ( !standalone.empty() )
>-	{
>-		(*stream) << "standalone=\"";
>-		PutString( standalone, stream );
>-		(*stream) << "\" ";
>-	}
>-	(*stream) << "?>";
>-}
>-
>-
>-void TiXmlDeclaration::CopyTo( TiXmlDeclaration* target ) const
>-{
>-	TiXmlNode::CopyTo( target );
>-
>-	target->version = version;
>-	target->encoding = encoding;
>-	target->standalone = standalone;
>-}
>-
>-
>-TiXmlNode* TiXmlDeclaration::Clone() const
>-{	
>-	TiXmlDeclaration* clone = new TiXmlDeclaration();
>-
>-	if ( !clone )
>-		return 0;
>-
>-	CopyTo( clone );
>-	return clone;
>-}
>-
>-
>-void TiXmlUnknown::Print( FILE* cfile, int depth ) const
>-{
>-	for ( int i=0; i<depth; i++ )
>-		fprintf( cfile, "    " );
>-	fprintf( cfile, "<%s>", value.c_str() );
>-}
>-
>-
>-void TiXmlUnknown::StreamOut( TIXML_OSTREAM * stream ) const
>-{
>-	(*stream) << "<" << value << ">";		// Don't use entities here! It is unknown.
>-}
>-
>-
>-void TiXmlUnknown::CopyTo( TiXmlUnknown* target ) const
>-{
>-	TiXmlNode::CopyTo( target );
>-}
>-
>-
>-TiXmlNode* TiXmlUnknown::Clone() const
>-{
>-	TiXmlUnknown* clone = new TiXmlUnknown();
>-
>-	if ( !clone )
>-		return 0;
>-
>-	CopyTo( clone );
>-	return clone;
>-}
>-
>-
>-TiXmlAttributeSet::TiXmlAttributeSet()
>-{
>-	sentinel.next = &sentinel;
>-	sentinel.prev = &sentinel;
>-}
>-
>-
>-TiXmlAttributeSet::~TiXmlAttributeSet()
>-{
>-	assert( sentinel.next == &sentinel );
>-	assert( sentinel.prev == &sentinel );
>-}
>-
>-
>-void TiXmlAttributeSet::Add( TiXmlAttribute* addMe )
>-{
>-	assert( !Find( TIXML_STRING( addMe->Name() ) ) );	// Shouldn't be multiply adding to the set.
>-
>-	addMe->next = &sentinel;
>-	addMe->prev = sentinel.prev;
>-
>-	sentinel.prev->next = addMe;
>-	sentinel.prev      = addMe;
>-}
>-
>-void TiXmlAttributeSet::Remove( TiXmlAttribute* removeMe )
>-{
>-	TiXmlAttribute* node;
>-
>-	for( node = sentinel.next; node != &sentinel; node = node->next )
>-	{
>-		if ( node == removeMe )
>-		{
>-			node->prev->next = node->next;
>-			node->next->prev = node->prev;
>-			node->next = 0;
>-			node->prev = 0;
>-			return;
>-		}
>-	}
>-	assert( 0 );		// we tried to remove a non-linked attribute.
>-}
>-
>-const TiXmlAttribute* TiXmlAttributeSet::Find( const TIXML_STRING& name ) const
>-{
>-	const TiXmlAttribute* node;
>-
>-	for( node = sentinel.next; node != &sentinel; node = node->next )
>-	{
>-		if ( node->name == name )
>-			return node;
>-	}
>-	return 0;
>-}
>-
>-TiXmlAttribute*	TiXmlAttributeSet::Find( const TIXML_STRING& name )
>-{
>-	TiXmlAttribute* node;
>-
>-	for( node = sentinel.next; node != &sentinel; node = node->next )
>-	{
>-		if ( node->name == name )
>-			return node;
>-	}
>-	return 0;
>-}
>-
>-#ifdef TIXML_USE_STL	
>-TIXML_ISTREAM & operator >> (TIXML_ISTREAM & in, TiXmlNode & base)
>-{
>-	TIXML_STRING tag;
>-	tag.reserve( 8 * 1000 );
>-	base.StreamIn( &in, &tag );
>-
>-	base.Parse( tag.c_str(), 0, TIXML_DEFAULT_ENCODING );
>-	return in;
>-}
>-#endif
>-
>-
>-TIXML_OSTREAM & operator<< (TIXML_OSTREAM & out, const TiXmlNode & base)
>-{
>-	base.StreamOut (& out);
>-	return out;
>-}
>-
>-
>-#ifdef TIXML_USE_STL	
>-std::string & operator<< (std::string& out, const TiXmlNode& base )
>-{
>-   std::ostringstream os_stream( std::ostringstream::out );
>-   base.StreamOut( &os_stream );
>-   
>-   out.append( os_stream.str() );
>-   return out;
>-}
>-#endif
>-
>-
>-TiXmlHandle TiXmlHandle::FirstChild() const
>-{
>-	if ( node )
>-	{
>-		TiXmlNode* child = node->FirstChild();
>-		if ( child )
>-			return TiXmlHandle( child );
>-	}
>-	return TiXmlHandle( 0 );
>-}
>-
>-
>-TiXmlHandle TiXmlHandle::FirstChild( const char * value ) const
>-{
>-	if ( node )
>-	{
>-		TiXmlNode* child = node->FirstChild( value );
>-		if ( child )
>-			return TiXmlHandle( child );
>-	}
>-	return TiXmlHandle( 0 );
>-}
>-
>-
>-TiXmlHandle TiXmlHandle::FirstChildElement() const
>-{
>-	if ( node )
>-	{
>-		TiXmlElement* child = node->FirstChildElement();
>-		if ( child )
>-			return TiXmlHandle( child );
>-	}
>-	return TiXmlHandle( 0 );
>-}
>-
>-
>-TiXmlHandle TiXmlHandle::FirstChildElement( const char * value ) const
>-{
>-	if ( node )
>-	{
>-		TiXmlElement* child = node->FirstChildElement( value );
>-		if ( child )
>-			return TiXmlHandle( child );
>-	}
>-	return TiXmlHandle( 0 );
>-}
>-
>-
>-TiXmlHandle TiXmlHandle::Child( int count ) const
>-{
>-	if ( node )
>-	{
>-		int i;
>-		TiXmlNode* child = node->FirstChild();
>-		for (	i=0;
>-				child && i<count;
>-				child = child->NextSibling(), ++i )
>-		{
>-			// nothing
>-		}
>-		if ( child )
>-			return TiXmlHandle( child );
>-	}
>-	return TiXmlHandle( 0 );
>-}
>-
>-
>-TiXmlHandle TiXmlHandle::Child( const char* value, int count ) const
>-{
>-	if ( node )
>-	{
>-		int i;
>-		TiXmlNode* child = node->FirstChild( value );
>-		for (	i=0;
>-				child && i<count;
>-				child = child->NextSibling( value ), ++i )
>-		{
>-			// nothing
>-		}
>-		if ( child )
>-			return TiXmlHandle( child );
>-	}
>-	return TiXmlHandle( 0 );
>-}
>-
>-
>-TiXmlHandle TiXmlHandle::ChildElement( int count ) const
>-{
>-	if ( node )
>-	{
>-		int i;
>-		TiXmlElement* child = node->FirstChildElement();
>-		for (	i=0;
>-				child && i<count;
>-				child = child->NextSiblingElement(), ++i )
>-		{
>-			// nothing
>-		}
>-		if ( child )
>-			return TiXmlHandle( child );
>-	}
>-	return TiXmlHandle( 0 );
>-}
>-
>-
>-TiXmlHandle TiXmlHandle::ChildElement( const char* value, int count ) const
>-{
>-	if ( node )
>-	{
>-		int i;
>-		TiXmlElement* child = node->FirstChildElement( value );
>-		for (	i=0;
>-				child && i<count;
>-				child = child->NextSiblingElement( value ), ++i )
>-		{
>-			// nothing
>-		}
>-		if ( child )
>-			return TiXmlHandle( child );
>-	}
>-	return TiXmlHandle( 0 );
>-}
>diff --git a/util/tinyxml.h b/util/tinyxml.h
>deleted file mode 100644
>index 091575a..0000000
>--- a/util/tinyxml.h
>+++ /dev/null
>@@ -1,1520 +0,0 @@
>-/*
>-www.sourceforge.net/projects/tinyxml
>-Original code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com)
>-
>-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.
>-*/
>-
>-
>-#ifndef TINYXML_INCLUDED
>-#define TINYXML_INCLUDED
>-
>-#ifdef _MSC_VER
>-#pragma warning( push )
>-#pragma warning( disable : 4530 )
>-#pragma warning( disable : 4786 )
>-#endif
>-
>-#include <ctype.h>
>-#include <stdio.h>
>-#include <stdlib.h>
>-#include <string.h>
>-#include <assert.h>
>-
>-// Help out windows:
>-#if defined( _DEBUG ) && !defined( DEBUG )
>-#define DEBUG
>-#endif
>-
>-#ifdef TIXML_USE_STL
>-	#include <string>
>- 	#include <iostream>
>-	#define TIXML_STRING	std::string
>-	#define TIXML_ISTREAM	std::istream
>-	#define TIXML_OSTREAM	std::ostream
>-#else
>-	#include "tinystr.h"
>-	#define TIXML_STRING	TiXmlString
>-	#define TIXML_OSTREAM	TiXmlOutStream
>-#endif
>-
>-// Deprecated library function hell. Compilers want to use the
>-// new safe versions. This probably doesn't fully address the problem,
>-// but it gets closer. There are too many compilers for me to fully
>-// test. If you get compilation troubles, undefine TIXML_SAFE
>-
>-#define TIXML_SAFE		// TinyXml isn't fully buffer overrun protected, safe code. This is work in progress.
>-#ifdef TIXML_SAFE
>-	#if defined(_MSC_VER) && (_MSC_VER >= 1400 )
>-		// Microsoft visual studio, version 2005 and higher.
>-		#define TIXML_SNPRINTF _snprintf_s
>-		#define TIXML_SNSCANF  _snscanf_s
>-	#elif defined(_MSC_VER) && (_MSC_VER >= 1200 )
>-		// Microsoft visual studio, version 6 and higher.
>-		//#pragma message( "Using _sn* functions." )
>-		#define TIXML_SNPRINTF _snprintf
>-		#define TIXML_SNSCANF  _snscanf
>-	#elif defined(__GNUC__) && (__GNUC__ >= 3 )
>-		// GCC version 3 and higher.s
>-		//#warning( "Using sn* functions." )
>-		#define TIXML_SNPRINTF snprintf
>-		#define TIXML_SNSCANF  snscanf
>-	#endif
>-#endif	
>-
>-class TiXmlDocument;
>-class TiXmlElement;
>-class TiXmlComment;
>-class TiXmlUnknown;
>-class TiXmlAttribute;
>-class TiXmlText;
>-class TiXmlDeclaration;
>-class TiXmlParsingData;
>-
>-const int TIXML_MAJOR_VERSION = 2;
>-const int TIXML_MINOR_VERSION = 4;
>-const int TIXML_PATCH_VERSION = 3;
>-
>-/*	Internal structure for tracking location of items 
>-	in the XML file.
>-*/
>-struct TiXmlCursor
>-{
>-	TiXmlCursor()		{ Clear(); }
>-	void Clear()		{ row = col = -1; }
>-
>-	int row;	// 0 based.
>-	int col;	// 0 based.
>-};
>-
>-
>-// Only used by Attribute::Query functions
>-enum 
>-{ 
>-	TIXML_SUCCESS,
>-	TIXML_NO_ATTRIBUTE,
>-	TIXML_WRONG_TYPE
>-};
>-
>-
>-// Used by the parsing routines.
>-enum TiXmlEncoding
>-{
>-	TIXML_ENCODING_UNKNOWN,
>-	TIXML_ENCODING_UTF8,
>-	TIXML_ENCODING_LEGACY
>-};
>-
>-const TiXmlEncoding TIXML_DEFAULT_ENCODING = TIXML_ENCODING_UNKNOWN;
>-
>-/** TiXmlBase is a base class for every class in TinyXml.
>-	It does little except to establish that TinyXml classes
>-	can be printed and provide some utility functions.
>-
>-	In XML, the document and elements can contain
>-	other elements and other types of nodes.
>-
>-	@verbatim
>-	A Document can contain:	Element	(container or leaf)
>-							Comment (leaf)
>-							Unknown (leaf)
>-							Declaration( leaf )
>-
>-	An Element can contain:	Element (container or leaf)
>-							Text	(leaf)
>-							Attributes (not on tree)
>-							Comment (leaf)
>-							Unknown (leaf)
>-
>-	A Decleration contains: Attributes (not on tree)
>-	@endverbatim
>-*/
>-class TiXmlBase
>-{
>-	friend class TiXmlNode;
>-	friend class TiXmlElement;
>-	friend class TiXmlDocument;
>-
>-public:
>-	TiXmlBase()	:	userData(0) {}
>-	virtual ~TiXmlBase()					{}
>-
>-	/**	All TinyXml classes can print themselves to a filestream.
>-		This is a formatted print, and will insert tabs and newlines.
>-		
>-		(For an unformatted stream, use the << operator.)
>-	*/
>-	virtual void Print( FILE* cfile, int depth ) const = 0;
>-
>-	/**	The world does not agree on whether white space should be kept or
>-		not. In order to make everyone happy, these global, static functions
>-		are provided to set whether or not TinyXml will condense all white space
>-		into a single space or not. The default is to condense. Note changing this
>-		values is not thread safe.
>-	*/
>-	static void SetCondenseWhiteSpace( bool condense )		{ condenseWhiteSpace = condense; }
>-
>-	/// Return the current white space setting.
>-	static bool IsWhiteSpaceCondensed()						{ return condenseWhiteSpace; }
>-
>-	/** Return the position, in the original source file, of this node or attribute.
>-		The row and column are 1-based. (That is the first row and first column is
>-		1,1). If the returns values are 0 or less, then the parser does not have
>-		a row and column value.
>-
>-		Generally, the row and column value will be set when the TiXmlDocument::Load(),
>-		TiXmlDocument::LoadFile(), or any TiXmlNode::Parse() is called. It will NOT be set
>-		when the DOM was created from operator>>.
>-
>-		The values reflect the initial load. Once the DOM is modified programmatically
>-		(by adding or changing nodes and attributes) the new values will NOT update to
>-		reflect changes in the document.
>-
>-		There is a minor performance cost to computing the row and column. Computation
>-		can be disabled if TiXmlDocument::SetTabSize() is called with 0 as the value.
>-
>-		@sa TiXmlDocument::SetTabSize()
>-	*/
>-	int Row() const			{ return location.row + 1; }
>-	int Column() const		{ return location.col + 1; }	///< See Row()
>-
>-	void  SetUserData( void* user )			{ userData = user; }
>-	void* GetUserData()						{ return userData; }
>-
>-	// Table that returs, for a given lead byte, the total number of bytes
>-	// in the UTF-8 sequence.
>-	static const int utf8ByteTable[256];
>-
>-	virtual const char* Parse(	const char* p, 
>-								TiXmlParsingData* data, 
>-								TiXmlEncoding encoding /*= TIXML_ENCODING_UNKNOWN */ ) = 0;
>-
>-	enum
>-	{
>-		TIXML_NO_ERROR = 0,
>-		TIXML_ERROR,
>-		TIXML_ERROR_OPENING_FILE,
>-		TIXML_ERROR_OUT_OF_MEMORY,
>-		TIXML_ERROR_PARSING_ELEMENT,
>-		TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME,
>-		TIXML_ERROR_READING_ELEMENT_VALUE,
>-		TIXML_ERROR_READING_ATTRIBUTES,
>-		TIXML_ERROR_PARSING_EMPTY,
>-		TIXML_ERROR_READING_END_TAG,
>-		TIXML_ERROR_PARSING_UNKNOWN,
>-		TIXML_ERROR_PARSING_COMMENT,
>-		TIXML_ERROR_PARSING_DECLARATION,
>-		TIXML_ERROR_DOCUMENT_EMPTY,
>-		TIXML_ERROR_EMBEDDED_NULL,
>-		TIXML_ERROR_PARSING_CDATA,
>-
>-		TIXML_ERROR_STRING_COUNT
>-	};
>-
>-protected:
>-
>-	// See STL_STRING_BUG
>-	// Utility class to overcome a bug.
>-	class StringToBuffer
>-	{
>-	  public:
>-		StringToBuffer( const TIXML_STRING& str );
>-		~StringToBuffer();
>-		char* buffer;
>-	};
>-
>-	static const char*	SkipWhiteSpace( const char*, TiXmlEncoding encoding );
>-	inline static bool	IsWhiteSpace( char c )		
>-	{ 
>-		return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' ); 
>-	}
>-	inline static bool	IsWhiteSpace( int c )
>-	{
>-		if ( c < 256 )
>-			return IsWhiteSpace( (char) c );
>-		return false;	// Again, only truly correct for English/Latin...but usually works.
>-	}
>-
>-	virtual void StreamOut (TIXML_OSTREAM *) const = 0;
>-
>-	#ifdef TIXML_USE_STL
>-	    static bool	StreamWhiteSpace( TIXML_ISTREAM * in, TIXML_STRING * tag );
>-	    static bool StreamTo( TIXML_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,
>-		or 0 if the function has an error.
>-	*/
>-	static const char* ReadName( const char* p, TIXML_STRING* name, TiXmlEncoding encoding );
>-
>-	/*	Reads text. Returns a pointer past the given end tag.
>-		Wickedly complex options, but it keeps the (sensitive) code in one place.
>-	*/
>-	static const char* ReadText(	const char* in,				// where to start
>-									TIXML_STRING* text,			// the string read
>-									bool ignoreWhiteSpace,		// whether to keep the white space
>-									const char* endTag,			// what ends this text
>-									bool ignoreCase,			// whether to ignore case in the end tag
>-									TiXmlEncoding encoding );	// the current encoding
>-
>-	// If an entity has been found, transform it into a character.
>-	static const char* GetEntity( const char* in, char* value, int* length, TiXmlEncoding encoding );
>-
>-	// Get a character, while interpreting entities.
>-	// The length can be from 0 to 4 bytes.
>-	inline static const char* GetChar( const char* p, char* _value, int* length, TiXmlEncoding encoding )
>-	{
>-		assert( p );
>-		if ( encoding == TIXML_ENCODING_UTF8 )
>-		{
>-			*length = utf8ByteTable[ *((unsigned char*)p) ];
>-			assert( *length >= 0 && *length < 5 );
>-		}
>-		else
>-		{
>-			*length = 1;
>-		}
>-
>-		if ( *length == 1 )
>-		{
>-			if ( *p == '&' )
>-				return GetEntity( p, _value, length, encoding );
>-			*_value = *p;
>-			return p+1;
>-		}
>-		else if ( *length )
>-		{
>-			//strncpy( _value, p, *length );	// lots of compilers don't like this function (unsafe),
>-												// and the null terminator isn't needed
>-			for( int i=0; p[i] && i<*length; ++i ) {
>-				_value[i] = p[i];
>-			}
>-			return p + (*length);
>-		}
>-		else
>-		{
>-			// Not valid text.
>-			return 0;
>-		}
>-	}
>-
>-	// Puts a string to a stream, expanding entities as it goes.
>-	// Note this should not contian the '<', '>', etc, or they will be transformed into entities!
>-	static void PutString( const TIXML_STRING& str, TIXML_OSTREAM* out );
>-
>-	static void PutString( const TIXML_STRING& str, TIXML_STRING* out );
>-
>-	// Return true if the next characters in the stream are any of the endTag sequences.
>-	// Ignore case only works for english, and should only be relied on when comparing
>-	// to English words: StringEqual( p, "version", true ) is fine.
>-	static bool StringEqual(	const char* p,
>-								const char* endTag,
>-								bool ignoreCase,
>-								TiXmlEncoding encoding );
>-
>-	static const char* errorString[ TIXML_ERROR_STRING_COUNT ];
>-
>-	TiXmlCursor location;
>-
>-    /// Field containing a generic user pointer
>-	void*			userData;
>-	
>-	// None of these methods are reliable for any language except English.
>-	// Good for approximation, not great for accuracy.
>-	static int IsAlpha( unsigned char anyByte, TiXmlEncoding encoding );
>-	static int IsAlphaNum( unsigned char anyByte, TiXmlEncoding encoding );
>-	inline static int ToLower( int v, TiXmlEncoding encoding )
>-	{
>-		if ( encoding == TIXML_ENCODING_UTF8 )
>-		{
>-			if ( v < 128 ) return tolower( v );
>-			return v;
>-		}
>-		else
>-		{
>-			return tolower( v );
>-		}
>-	}
>-	static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
>-
>-private:
>-	TiXmlBase( const TiXmlBase& );				// not implemented.
>-	void operator=( const TiXmlBase& base );	// not allowed.
>-
>-	struct Entity
>-	{
>-		const char*     str;
>-		unsigned int	strLength;
>-		char		    chr;
>-	};
>-	enum
>-	{
>-		NUM_ENTITY = 5,
>-		MAX_ENTITY_LENGTH = 6
>-
>-	};
>-	static Entity entity[ NUM_ENTITY ];
>-	static bool condenseWhiteSpace;
>-};
>-
>-
>-/** The parent class for everything in the Document Object Model.
>-	(Except for attributes).
>-	Nodes have siblings, a parent, and children. A node can be
>-	in a document, or stand on its own. The type of a TiXmlNode
>-	can be queried, and it can be cast to its more defined type.
>-*/
>-class TiXmlNode : public TiXmlBase
>-{
>-	friend class TiXmlDocument;
>-	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.
>-	    */
>-	    friend std::istream& operator >> (std::istream& in, TiXmlNode& base);
>-
>-	    /** An output stream operator, for every class. Note that this outputs
>-		    without any newlines or formatting, as opposed to Print(), which
>-		    includes tabs and new lines.
>-
>-		    The operator<< and operator>> are not completely symmetric. Writing
>-		    a node to a stream is very well defined. You'll get a nice stream
>-		    of output, without any extra whitespace or newlines.
>-		    
>-		    But reading is not as well defined. (As it always is.) If you create
>-		    a TiXmlElement (for example) and read that from an input stream,
>-		    the text needs to define an element or junk will result. This is
>-		    true of all input streams, but it's worth keeping in mind.
>-
>-		    A TiXmlDocument will read nodes until it reads a root element, and
>-			all the children of that root element.
>-	    */	
>-	    friend std::ostream& operator<< (std::ostream& out, const TiXmlNode& base);
>-
>-		/// Appends the XML node or attribute to a std::string.
>-		friend std::string& operator<< (std::string& out, const TiXmlNode& base );
>-
>-	#else
>-	    // Used internally, not part of the public API.
>-	    friend TIXML_OSTREAM& operator<< (TIXML_OSTREAM& out, const TiXmlNode& base);
>-	#endif
>-
>-	/** The types of XML nodes supported by TinyXml. (All the
>-			unsupported types are picked up by UNKNOWN.)
>-	*/
>-	enum NodeType
>-	{
>-		DOCUMENT,
>-		ELEMENT,
>-		COMMENT,
>-		UNKNOWN,
>-		TEXT,
>-		DECLARATION,
>-		TYPECOUNT
>-	};
>-
>-	virtual ~TiXmlNode();
>-
>-	/** The meaning of 'value' changes for the specific type of
>-		TiXmlNode.
>-		@verbatim
>-		Document:	filename of the xml file
>-		Element:	name of the element
>-		Comment:	the comment text
>-		Unknown:	the tag contents
>-		Text:		the text string
>-		@endverbatim
>-
>-		The subclasses will wrap this function.
>-	*/
>-	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
>-
>-	/** Changes the value of the node. Defined as:
>-		@verbatim
>-		Document:	filename of the xml file
>-		Element:	name of the element
>-		Comment:	the comment text
>-		Unknown:	the tag contents
>-		Text:		the text string
>-		@endverbatim
>-	*/
>-	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();
>-
>-	/// One step up the DOM.
>-	TiXmlNode* Parent()							{ return parent; }
>-	const TiXmlNode* Parent() const				{ return parent; }
>-
>-	const TiXmlNode* FirstChild()	const	{ return firstChild; }		///< The first child of this node. Will be null if there are no children.
>-	TiXmlNode* FirstChild()					{ return firstChild; }
>-	const TiXmlNode* FirstChild( const char * value ) const;			///< The first child of this node with the matching 'value'. Will be null if none found.
>-	TiXmlNode* FirstChild( const char * value );						///< The first child of this node with the matching 'value'. Will be null if none found.
>-
>-	const TiXmlNode* LastChild() const	{ return lastChild; }		/// The last child of this node. Will be null if there are no children.
>-	TiXmlNode* LastChild()	{ return lastChild; }
>-	const TiXmlNode* LastChild( const char * value ) const;			/// The last child of this node matching 'value'. Will be null if there are no children.
>-	TiXmlNode* LastChild( const char * 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:
>-		@verbatim
>-			for( child = parent->FirstChild(); child; child = child->NextSibling() )
>-		@endverbatim
>-
>-		IterateChildren does the same thing with the syntax:
>-		@verbatim
>-			child = 0;
>-			while( child = parent->IterateChildren( child ) )
>-		@endverbatim
>-
>-		IterateChildren takes the previous child as input and finds
>-		the next one. If the previous child is null, it returns the
>-		first. IterateChildren will return null when done.
>-	*/
>-	const TiXmlNode* IterateChildren( const TiXmlNode* previous ) const;
>-	TiXmlNode* IterateChildren( TiXmlNode* previous );
>-
>-	/// This flavor of IterateChildren searches for children with a particular 'value'
>-	const TiXmlNode* IterateChildren( const char * value, const TiXmlNode* previous ) const;
>-	TiXmlNode* IterateChildren( const char * value, TiXmlNode* 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, 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.
>-	*/
>-	TiXmlNode* InsertEndChild( const TiXmlNode& addThis );
>-
>-
>-	/** Add a new node related to this. Adds a child past the LastChild.
>-
>-		NOTE: the node to be added is passed by pointer, and will be
>-		henceforth owned (and deleted) by tinyXml. This method is efficient
>-		and avoids an extra copy, but should be used with care as it
>-		uses a different memory model than the other insert functions.
>-
>-		@sa InsertEndChild
>-	*/
>-	TiXmlNode* LinkEndChild( TiXmlNode* addThis );
>-
>-	/** Add a new node related to this. Adds a child before the specified child.
>-		Returns a pointer to the new object or NULL if an error occured.
>-	*/
>-	TiXmlNode* InsertBeforeChild( TiXmlNode* beforeThis, const TiXmlNode& addThis );
>-
>-	/** Add a new node related to this. Adds a child after the specified child.
>-		Returns a pointer to the new object or NULL if an error occured.
>-	*/
>-	TiXmlNode* InsertAfterChild(  TiXmlNode* afterThis, const TiXmlNode& addThis );
>-
>-	/** Replace a child of this node.
>-		Returns a pointer to the new object or NULL if an error occured.
>-	*/
>-	TiXmlNode* ReplaceChild( TiXmlNode* replaceThis, const TiXmlNode& withThis );
>-
>-	/// Delete a child of this node.
>-	bool RemoveChild( TiXmlNode* removeThis );
>-
>-	/// Navigate to a sibling node.
>-	const TiXmlNode* PreviousSibling() const			{ return prev; }
>-	TiXmlNode* PreviousSibling()						{ return prev; }
>-
>-	/// Navigate to a sibling node.
>-	const TiXmlNode* PreviousSibling( const char * ) const;
>-	TiXmlNode* PreviousSibling( const char * );
>-
>-    #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; }
>-	TiXmlNode* NextSibling()							{ return next; }
>-
>-	/// Navigate to a sibling node with the given 'value'.
>-	const TiXmlNode* NextSibling( const char * ) const;
>-	TiXmlNode* NextSibling( const char * );
>-
>-	/** Convenience function to get through elements.
>-		Calls NextSibling and ToElement. Will skip all non-Element
>-		nodes. Returns 0 if there is not another element.
>-	*/
>-	const TiXmlElement* NextSiblingElement() const;
>-	TiXmlElement* NextSiblingElement();
>-
>-	/** Convenience function to get through elements.
>-		Calls NextSibling and ToElement. Will skip all non-Element
>-		nodes. Returns 0 if there is not another element.
>-	*/
>-	const TiXmlElement* NextSiblingElement( const char * ) const;
>-	TiXmlElement* NextSiblingElement( const char * );
>-
>-    #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;
>-	TiXmlElement* FirstChildElement();
>-
>-	/// Convenience function to get through elements.
>-	const TiXmlElement* FirstChildElement( const char * value ) const;
>-	TiXmlElement* FirstChildElement( const char * 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,
>-								UNKNOWN, TEXT, and DECLARATION.
>-	*/
>-	int Type() const	{ return type; }
>-
>-	/** Return a pointer to the Document this node lives in.
>-		Returns null if not in a document.
>-	*/
>-	const TiXmlDocument* GetDocument() const;
>-	TiXmlDocument* GetDocument();
>-
>-	/// Returns true if this node has no children.
>-	bool NoChildren() const						{ return !firstChild; }
>-
>-	virtual const TiXmlDocument*    ToDocument()    const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
>-	virtual const TiXmlElement*     ToElement()     const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
>-	virtual const TiXmlComment*     ToComment()     const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
>-	virtual const TiXmlUnknown*     ToUnknown()     const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
>-	virtual const TiXmlText*        ToText()        const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
>-	virtual const TiXmlDeclaration* ToDeclaration() const { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
>-
>-	virtual TiXmlDocument*          ToDocument()    { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
>-	virtual TiXmlElement*           ToElement()	    { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
>-	virtual TiXmlComment*           ToComment()     { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
>-	virtual TiXmlUnknown*           ToUnknown()	    { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
>-	virtual TiXmlText*	            ToText()        { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
>-	virtual TiXmlDeclaration*       ToDeclaration() { return 0; } ///< Cast to a more defined type. Will return null if not of the requested type.
>-
>-	/** Create an exact duplicate of this node and return it. The memory must be deleted
>-		by the caller. 
>-	*/
>-	virtual TiXmlNode* Clone() const = 0;
>-
>-protected:
>-	TiXmlNode( NodeType _type );
>-
>-	// Copy to the allocated object. Shared functionality between Clone, Copy constructor,
>-	// and the assignment operator.
>-	void CopyTo( TiXmlNode* target ) const;
>-
>-	#ifdef TIXML_USE_STL
>-	    // The real work of the input operator.
>-	    virtual void StreamIn( TIXML_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 );
>-
>-	TiXmlNode*		parent;
>-	NodeType		type;
>-
>-	TiXmlNode*		firstChild;
>-	TiXmlNode*		lastChild;
>-
>-	TIXML_STRING	value;
>-
>-	TiXmlNode*		prev;
>-	TiXmlNode*		next;
>-
>-private:
>-	TiXmlNode( const TiXmlNode& );				// not implemented.
>-	void operator=( const TiXmlNode& base );	// not allowed.
>-};
>-
>-
>-/** An attribute is a name-value pair. Elements have an arbitrary
>-	number of attributes, each with a unique name.
>-
>-	@note The attributes are not TiXmlNodes, since they are not
>-		  part of the tinyXML document object model. There are other
>-		  suggested ways to look at this problem.
>-*/
>-class TiXmlAttribute : public TiXmlBase
>-{
>-	friend class TiXmlAttributeSet;
>-
>-public:
>-	/// Construct an empty attribute.
>-	TiXmlAttribute() : TiXmlBase()
>-	{
>-		document = 0;
>-		prev = next = 0;
>-	}
>-
>-	#ifdef TIXML_USE_STL
>-	/// std::string constructor.
>-	TiXmlAttribute( const std::string& _name, const std::string& _value )
>-	{
>-		name = _name;
>-		value = _value;
>-		document = 0;
>-		prev = next = 0;
>-	}
>-	#endif
>-
>-	/// Construct an attribute with a name and value.
>-	TiXmlAttribute( const char * _name, const char * _value )
>-	{
>-		name = _name;
>-		value = _value;
>-		document = 0;
>-		prev = next = 0;
>-	}
>-
>-	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.
>-	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.
>-
>-	// Get the tinyxml string representation
>-	const TIXML_STRING& NameTStr() const { return name; }
>-
>-	/** QueryIntValue examines the value string. It is an alternative to the
>-		IntValue() method with richer error checking.
>-		If the value is an integer, it is stored in 'value' and 
>-		the call returns TIXML_SUCCESS. If it is not
>-		an integer, it returns TIXML_WRONG_TYPE.
>-
>-		A specialized but useful call. Note that for success it returns 0,
>-		which is the opposite of almost all other TinyXml calls.
>-	*/
>-	int QueryIntValue( int* _value ) const;
>-	/// QueryDoubleValue examines the value string. See QueryIntValue().
>-	int QueryDoubleValue( double* _value ) const;
>-
>-	void SetName( const char* _name )	{ name = _name; }				///< Set the name of this attribute.
>-	void SetValue( const char* _value )	{ value = _value; }				///< Set the value.
>-
>-	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;
>-	TiXmlAttribute* Next();
>-	/// Get the previous sibling attribute in the DOM. Returns null at beginning.
>-	const TiXmlAttribute* Previous() const;
>-	TiXmlAttribute* Previous();
>-
>-	bool operator==( const TiXmlAttribute& rhs ) const { return rhs.name == name; }
>-	bool operator<( const TiXmlAttribute& rhs )	 const { return name < rhs.name; }
>-	bool operator>( const TiXmlAttribute& rhs )  const { return name > rhs.name; }
>-
>-	/*	Attribute parsing starts: first letter of the name
>-						 returns: the next char after the value end quote
>-	*/
>-	virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
>-
>-	// Prints this Attribute to a FILE stream.
>-	virtual void Print( FILE* cfile, int depth ) const;
>-
>-	virtual void StreamOut( TIXML_OSTREAM * out ) const;
>-	// [internal use]
>-	// Set the document pointer so the attribute can report errors.
>-	void SetDocument( TiXmlDocument* doc )	{ document = doc; }
>-
>-private:
>-	TiXmlAttribute( const TiXmlAttribute& );				// not implemented.
>-	void operator=( const TiXmlAttribute& base );	// not allowed.
>-
>-	TiXmlDocument*	document;	// A pointer back to a document, for error reporting.
>-	TIXML_STRING name;
>-	TIXML_STRING value;
>-	TiXmlAttribute*	prev;
>-	TiXmlAttribute*	next;
>-};
>-
>-
>-/*	A class used to manage a group of attributes.
>-	It is only used internally, both by the ELEMENT and the DECLARATION.
>-	
>-	The set can be changed transparent to the Element and Declaration
>-	classes that use it, but NOT transparent to the Attribute
>-	which has to implement a next() and previous() method. Which makes
>-	it a bit problematic and prevents the use of STL.
>-
>-	This version is implemented with circular lists because:
>-		- I like circular lists
>-		- it demonstrates some independence from the (typical) doubly linked list.
>-*/
>-class TiXmlAttributeSet
>-{
>-public:
>-	TiXmlAttributeSet();
>-	~TiXmlAttributeSet();
>-
>-	void Add( TiXmlAttribute* attribute );
>-	void Remove( TiXmlAttribute* attribute );
>-
>-	const TiXmlAttribute* First()	const	{ return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
>-	TiXmlAttribute* First()					{ return ( sentinel.next == &sentinel ) ? 0 : sentinel.next; }
>-	const TiXmlAttribute* Last() const		{ return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
>-	TiXmlAttribute* Last()					{ return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev; }
>-
>-	const TiXmlAttribute*	Find( const TIXML_STRING& name ) const;
>-	TiXmlAttribute*	Find( const TIXML_STRING& name );
>-
>-private:
>-	//*ME:	Because of hidden/disabled copy-construktor in TiXmlAttribute (sentinel-element),
>-	//*ME:	this class must be also use a hidden/disabled copy-constructor !!!
>-	TiXmlAttributeSet( const TiXmlAttributeSet& );	// not allowed
>-	void operator=( const TiXmlAttributeSet& );	// not allowed (as TiXmlAttribute)
>-
>-	TiXmlAttribute sentinel;
>-};
>-
>-
>-/** The element is a container class. It has a value, the element name,
>-	and can contain other elements, text, comments, and unknowns.
>-	Elements also contain an arbitrary number of attributes.
>-*/
>-class TiXmlElement : public TiXmlNode
>-{
>-public:
>-	/// Construct an element.
>-	TiXmlElement (const char * in_value);
>-
>-	#ifdef TIXML_USE_STL
>-	/// std::string constructor.
>-	TiXmlElement( const std::string& _value );
>-	#endif
>-
>-	TiXmlElement( const TiXmlElement& );
>-
>-	void operator=( const TiXmlElement& base );
>-
>-	virtual ~TiXmlElement();
>-
>-	/** Given an attribute name, Attribute() returns the value
>-		for the attribute of that name, or null if none exists.
>-	*/
>-	const char* Attribute( const char* name ) const;
>-
>-	/** Given an attribute name, Attribute() returns the value
>-		for the attribute of that name, or null if none exists.
>-		If the attribute exists and can be converted to an integer,
>-		the integer value will be put in the return 'i', if 'i'
>-		is non-null.
>-	*/
>-	const char* Attribute( const char* name, int* i ) const;
>-
>-	/** Given an attribute name, Attribute() returns the value
>-		for the attribute of that name, or null if none exists.
>-		If the attribute exists and can be converted to an double,
>-		the double value will be put in the return 'd', if 'd'
>-		is non-null.
>-	*/
>-	const char* Attribute( const char* name, double* d ) const;
>-
>-	/** QueryIntAttribute examines the attribute - it is an alternative to the
>-		Attribute() method with richer error checking.
>-		If the attribute is an integer, it is stored in 'value' and 
>-		the call returns TIXML_SUCCESS. If it is not
>-		an integer, it returns TIXML_WRONG_TYPE. If the attribute
>-		does not exist, then TIXML_NO_ATTRIBUTE is returned.
>-	*/	
>-	int QueryIntAttribute( const char* name, int* _value ) const;
>-	/// QueryDoubleAttribute examines the attribute - see QueryIntAttribute().
>-	int QueryDoubleAttribute( const char* name, double* _value ) const;
>-	/// QueryFloatAttribute examines the attribute - see QueryIntAttribute().
>-	int QueryFloatAttribute( const char* name, float* _value ) const {
>-		double d;
>-		int result = QueryDoubleAttribute( name, &d );
>-		if ( result == TIXML_SUCCESS ) {
>-			*_value = (float)d;
>-		}
>-		return result;
>-	}
>-
>-	/** 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 char* Attribute( const std::string& name ) const				{ return Attribute( name.c_str() ); }
>-	const char* Attribute( const std::string& name, int* i ) const		{ return Attribute( name.c_str(), i ); }
>-	const char* Attribute( const std::string& name, double* d ) const	{ return Attribute( name.c_str(), d ); }
>-	int QueryIntAttribute( const std::string& name, int* _value ) const	{ return QueryIntAttribute( name.c_str(), _value ); }
>-	int QueryDoubleAttribute( const std::string& name, double* _value ) const { return QueryDoubleAttribute( name.c_str(), _value ); }
>-
>-	/// STL std::string form.
>-	void SetAttribute( const std::string& name, const std::string& _value );
>-	///< STL std::string form.
>-	void SetAttribute( const std::string& name, int _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.
>-	*/
>-	void SetAttribute( const char * name, int value );
>-
>-	/** 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 SetDoubleAttribute( const char * name, double value );
>-
>-	/** 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(); }
>-	const TiXmlAttribute* LastAttribute()	const 	{ return attributeSet.Last(); }		///< Access the last attribute in this element.
>-	TiXmlAttribute* LastAttribute()					{ return attributeSet.Last(); }
>-
>-	/** Convenience function for easy access to the text inside an element. Although easy
>-		and concise, GetText() is limited compared to getting the TiXmlText child
>-		and accessing it directly.
>-	
>-		If the first child of 'this' is a TiXmlText, the GetText()
>-		returns the character string of the Text node, else null is returned.
>-
>-		This is a convenient method for getting the text of simple contained text:
>-		@verbatim
>-		<foo>This is text</foo>
>-		const char* str = fooElement->GetText();
>-		@endverbatim
>-
>-		'str' will be a pointer to "This is text". 
>-		
>-		Note that this function can be misleading. If the element foo was created from
>-		this XML:
>-		@verbatim
>-		<foo><b>This is text</b></foo> 
>-		@endverbatim
>-
>-		then the value of str would be null. The first child node isn't a text node, it is
>-		another element. From this XML:
>-		@verbatim
>-		<foo>This is <b>text</b></foo> 
>-		@endverbatim
>-		GetText() will return "This is ".
>-
>-		WARNING: GetText() accesses a child node - don't become confused with the 
>-				 similarly named TiXmlHandle::Text() and TiXmlNode::ToText() which are 
>-				 safe type casts on the referenced node.
>-	*/
>-	const char* GetText() const;
>-
>-	/// Creates a new Element and returns it - the returned element is a copy.
>-	virtual TiXmlNode* Clone() const;
>-	// Print the Element to a FILE stream.
>-	virtual void Print( FILE* cfile, int depth ) const;
>-
>-	/*	Attribtue parsing starts: next char past '<'
>-						 returns: next char past '>'
>-	*/
>-	virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
>-
>-	virtual const TiXmlElement*     ToElement()     const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
>-	virtual TiXmlElement*           ToElement()	          { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
>-	
>-protected:
>-
>-	void CopyTo( TiXmlElement* target ) const;
>-	void ClearThis();	// like clear, but initializes 'this' object as well
>-
>-	// Used to be public [internal use]
>-	#ifdef TIXML_USE_STL
>-	    virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
>-	#endif
>-	virtual void StreamOut( TIXML_OSTREAM * out ) const;
>-
>-	/*	[internal use]
>-		Reads the "value" of the element -- another element, or text.
>-		This should terminate with the current end tag.
>-	*/
>-	const char* ReadValue( const char* in, TiXmlParsingData* prevData, TiXmlEncoding encoding );
>-
>-private:
>-
>-	TiXmlAttributeSet attributeSet;
>-};
>-
>-
>-/**	An XML comment.
>-*/
>-class TiXmlComment : public TiXmlNode
>-{
>-public:
>-	/// Constructs an empty comment.
>-	TiXmlComment() : TiXmlNode( TiXmlNode::COMMENT ) {}
>-	TiXmlComment( const TiXmlComment& );
>-	void operator=( const TiXmlComment& base );
>-
>-	virtual ~TiXmlComment()	{}
>-
>-	/// Returns a copy of this Comment.
>-	virtual TiXmlNode* Clone() const;
>-	/// Write this Comment to a FILE stream.
>-	virtual void Print( FILE* cfile, int depth ) const;
>-
>-	/*	Attribtue parsing starts: at the ! of the !--
>-						 returns: next char past '>'
>-	*/
>-	virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
>-
>-	virtual const TiXmlComment*  ToComment() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
>-	virtual TiXmlComment*  ToComment() { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
>-
>-protected:
>-	void CopyTo( TiXmlComment* target ) const;
>-
>-	// used to be public
>-	#ifdef TIXML_USE_STL
>-	    virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
>-	#endif
>-	virtual void StreamOut( TIXML_OSTREAM * out ) const;
>-
>-private:
>-
>-};
>-
>-
>-/** XML text. A text node can have 2 ways to output the next. "normal" output 
>-	and CDATA. It will default to the mode it was parsed from the XML file and
>-	you generally want to leave it alone, but you can change the output mode with 
>-	SetCDATA() and query it with CDATA().
>-*/
>-class TiXmlText : public TiXmlNode
>-{
>-	friend class TiXmlElement;
>-public:
>-	/** Constructor for text element. By default, it is treated as 
>-		normal, encoded text. If you want it be output as a CDATA text
>-		element, set the parameter _cdata to 'true'
>-	*/
>-	TiXmlText (const char * initValue ) : TiXmlNode (TiXmlNode::TEXT)
>-	{
>-		SetValue( initValue );
>-		cdata = false;
>-	}
>-	virtual ~TiXmlText() {}
>-
>-	#ifdef TIXML_USE_STL
>-	/// Constructor.
>-	TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TEXT)
>-	{
>-		SetValue( initValue );
>-		cdata = false;
>-	}
>-	#endif
>-
>-	TiXmlText( const TiXmlText& copy ) : TiXmlNode( TiXmlNode::TEXT )	{ copy.CopyTo( this ); }
>-	void operator=( const TiXmlText& base )							 	{ base.CopyTo( this ); }
>-
>-	/// Write this text object to a FILE stream.
>-	virtual void Print( FILE* cfile, int depth ) const;
>-
>-	/// Queries whether this represents text using a CDATA section.
>-	bool CDATA()					{ return cdata; }
>-	/// Turns on or off a CDATA representation of text.
>-	void SetCDATA( bool _cdata )	{ cdata = _cdata; }
>-
>-	virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
>-
>-	virtual const TiXmlText* ToText() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
>-	virtual TiXmlText*       ToText()       { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
>-
>-protected :
>-	///  [internal use] Creates a new Element and returns it.
>-	virtual TiXmlNode* Clone() const;
>-	void CopyTo( TiXmlText* target ) const;
>-
>-	virtual void StreamOut ( TIXML_OSTREAM * out ) const;
>-	bool Blank() const;	// returns true if all white space and new lines
>-	// [internal use]
>-	#ifdef TIXML_USE_STL
>-	    virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
>-	#endif
>-
>-private:
>-	bool cdata;			// true if this should be input and output as a CDATA style text element
>-};
>-
>-
>-/** In correct XML the declaration is the first entry in the file.
>-	@verbatim
>-		<?xml version="1.0" standalone="yes"?>
>-	@endverbatim
>-
>-	TinyXml will happily read or write files without a declaration,
>-	however. There are 3 possible attributes to the declaration:
>-	version, encoding, and standalone.
>-
>-	Note: In this version of the code, the attributes are
>-	handled as special cases, not generic attributes, simply
>-	because there can only be at most 3 and they are always the same.
>-*/
>-class TiXmlDeclaration : public TiXmlNode
>-{
>-public:
>-	/// Construct an empty declaration.
>-	TiXmlDeclaration()   : TiXmlNode( TiXmlNode::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,
>-						const char* _standalone );
>-
>-	TiXmlDeclaration( const TiXmlDeclaration& copy );
>-	void operator=( const TiXmlDeclaration& copy );
>-
>-	virtual ~TiXmlDeclaration()	{}
>-
>-	/// Version. Will return an empty string if none was found.
>-	const char *Version() const			{ return version.c_str (); }
>-	/// Encoding. Will return an empty string if none was found.
>-	const char *Encoding() const		{ return encoding.c_str (); }
>-	/// Is this a standalone document?
>-	const char *Standalone() const		{ return standalone.c_str (); }
>-
>-	/// Creates a copy of this Declaration and returns it.
>-	virtual TiXmlNode* Clone() const;
>-	/// Print this declaration to a FILE stream.
>-	virtual void Print( FILE* cfile, int depth ) const;
>-
>-	virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
>-
>-	virtual const TiXmlDeclaration* ToDeclaration() const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
>-	virtual TiXmlDeclaration*       ToDeclaration()       { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
>-
>-protected:
>-	void CopyTo( TiXmlDeclaration* target ) const;
>-	// used to be public
>-	#ifdef TIXML_USE_STL
>-	    virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
>-	#endif
>-	virtual void StreamOut ( TIXML_OSTREAM * out) const;
>-
>-private:
>-
>-	TIXML_STRING version;
>-	TIXML_STRING encoding;
>-	TIXML_STRING standalone;
>-};
>-
>-
>-/** Any tag that tinyXml doesn't recognize is saved as an
>-	unknown. It is a tag of text, but should not be modified.
>-	It will be written back to the XML, unchanged, when the file
>-	is saved.
>-
>-	DTD tags get thrown into TiXmlUnknowns.
>-*/
>-class TiXmlUnknown : public TiXmlNode
>-{
>-public:
>-	TiXmlUnknown() : TiXmlNode( TiXmlNode::UNKNOWN )	{}
>-	virtual ~TiXmlUnknown() {}
>-
>-	TiXmlUnknown( const TiXmlUnknown& copy ) : TiXmlNode( TiXmlNode::UNKNOWN )		{ copy.CopyTo( this ); }
>-	void operator=( const TiXmlUnknown& copy )										{ copy.CopyTo( this ); }
>-
>-	/// Creates a copy of this Unknown and returns it.
>-	virtual TiXmlNode* Clone() const;
>-	/// Print this Unknown to a FILE stream.
>-	virtual void Print( FILE* cfile, int depth ) const;
>-
>-	virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
>-
>-	virtual const TiXmlUnknown*     ToUnknown()     const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
>-	virtual TiXmlUnknown*           ToUnknown()	    { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
>-
>-protected:
>-	void CopyTo( TiXmlUnknown* target ) const;
>-
>-	#ifdef TIXML_USE_STL
>-	    virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
>-	#endif
>-	virtual void StreamOut ( TIXML_OSTREAM * out ) const;
>-
>-private:
>-
>-};
>-
>-
>-/** Always the top level node. A document binds together all the
>-	XML pieces. It can be saved, loaded, and printed to the screen.
>-	The 'value' of a document node is the xml file name.
>-*/
>-class TiXmlDocument : public TiXmlNode
>-{
>-public:
>-	/// Create an empty document, that has no name.
>-	TiXmlDocument();
>-	/// 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 );
>-
>-	virtual ~TiXmlDocument() {}
>-
>-	/** Load a file using the current document value.
>-		Returns true if successful. Will delete any existing
>-		document data before loading.
>-	*/
>-	bool LoadFile( TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
>-	/// Save a file using the current document value. Returns true if successful.
>-	bool SaveFile() const;
>-	/// Load a file using the given filename. Returns true if successful.
>-	bool LoadFile( const char * filename, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
>-	/// Save a file using the given filename. Returns true if successful.
>-	bool SaveFile( const char * filename ) const;
>-	/** Load a file using the given FILE*. Returns true if successful. Note that this method
>-		doesn't stream - the entire object pointed at by the FILE*
>-		will be interpreted as an XML file. TinyXML doesn't stream in XML from the current
>-		file location. Streaming may be added in the future.
>-	*/
>-	bool LoadFile( FILE*, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
>-	/// 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.
>-	{
>-		StringToBuffer f( filename );
>-		return ( f.buffer && LoadFile( f.buffer, encoding ));
>-	}
>-	bool SaveFile( const std::string& filename ) const		///< STL std::string version.
>-	{
>-		StringToBuffer f( filename );
>-		return ( f.buffer && SaveFile( f.buffer ));
>-	}
>-	#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
>-		to use that encoding, regardless of what TinyXml might otherwise try to detect.
>-	*/
>-	virtual const char* Parse( const char* p, TiXmlParsingData* data = 0, TiXmlEncoding encoding = TIXML_DEFAULT_ENCODING );
>-
>-	/** Get the root element -- the only top level element -- of the document.
>-		In well formed XML, there should only be one. TinyXml is tolerant of
>-		multiple elements at the document level.
>-	*/
>-	const TiXmlElement* RootElement() const		{ return FirstChildElement(); }
>-	TiXmlElement* RootElement()					{ return FirstChildElement(); }
>-
>-	/** If an error occurs, Error will be set to true. Also,
>-		- The ErrorId() will contain the integer identifier of the error (not generally useful)
>-		- The ErrorDesc() method will return the name of the error. (very useful)
>-		- The ErrorRow() and ErrorCol() will return the location of the error (if known)
>-	*/	
>-	bool Error() const						{ return error; }
>-
>-	/// Contains a textual (english) description of the error if one occurs.
>-	const char * ErrorDesc() const	{ return errorDesc.c_str (); }
>-
>-	/** Generally, you probably want the error string ( ErrorDesc() ). But if you
>-		prefer the ErrorId, this function will fetch it.
>-	*/
>-	int ErrorId()	const				{ return errorId; }
>-
>-	/** Returns the location (if known) of the error. The first column is column 1, 
>-		and the first row is row 1. A value of 0 means the row and column wasn't applicable
>-		(memory errors, for example, have no row/column) or the parser lost the error. (An
>-		error in the error reporting, in that case.)
>-
>-		@sa SetTabSize, Row, Column
>-	*/
>-	int ErrorRow()	{ return errorLocation.row+1; }
>-	int ErrorCol()	{ return errorLocation.col+1; }	///< The column where the error occured. See ErrorRow()
>-
>-	/** SetTabSize() allows the error reporting functions (ErrorRow() and ErrorCol())
>-		to report the correct values for row and column. It does not change the output
>-		or input in any way.
>-		
>-		By calling this method, with a tab size
>-		greater than 0, the row and column of each node and attribute is stored
>-		when the file is loaded. Very useful for tracking the DOM back in to
>-		the source file.
>-
>-		The tab size is required for calculating the location of nodes. If not
>-		set, the default of 4 is used. The tabsize is set per document. Setting
>-		the tabsize to 0 disables row/column tracking.
>-
>-		Note that row and column tracking is not supported when using operator>>.
>-
>-		The tab size needs to be enabled before the parse or load. Correct usage:
>-		@verbatim
>-		TiXmlDocument doc;
>-		doc.SetTabSize( 8 );
>-		doc.Load( "myfile.xml" );
>-		@endverbatim
>-
>-		@sa Row, Column
>-	*/
>-	void SetTabSize( int _tabsize )		{ tabsize = _tabsize; }
>-
>-	int TabSize() const	{ return tabsize; }
>-
>-	/** If you have handled the error, it can be reset with this call. The error
>-		state is automatically cleared if you Parse a new XML block.
>-	*/
>-	void ClearError()						{	error = false; 
>-												errorId = 0; 
>-												errorDesc = ""; 
>-												errorLocation.row = errorLocation.col = 0; 
>-												//errorLocation.last = 0; 
>-											}
>-
>-	/** Dump the document to standard out. */
>-	void Print() const						{ Print( stdout, 0 ); }
>-
>-	/// Print this Document to a FILE stream.
>-	virtual void Print( FILE* cfile, int depth = 0 ) const;
>-	// [internal use]
>-	void SetError( int err, const char* errorLocation, TiXmlParsingData* prevData, TiXmlEncoding encoding );
>-
>-	virtual const TiXmlDocument*    ToDocument()    const { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
>-	virtual TiXmlDocument*          ToDocument()          { return this; } ///< Cast to a more defined type. Will return null not of the requested type.
>-
>-protected :
>-	virtual void StreamOut ( TIXML_OSTREAM * out) const;
>-	// [internal use]
>-	virtual TiXmlNode* Clone() const;
>-	#ifdef TIXML_USE_STL
>-	    virtual void StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag );
>-	#endif
>-
>-private:
>-	void CopyTo( TiXmlDocument* target ) const;
>-
>-	bool error;
>-	int  errorId;
>-	TIXML_STRING errorDesc;
>-	int tabsize;
>-	TiXmlCursor errorLocation;
>-	bool useMicrosoftBOM;		// the UTF-8 BOM were found when read. Note this, and try to write.
>-};
>-
>-
>-/**
>-	A TiXmlHandle is a class that wraps a node pointer with null checks; this is
>-	an incredibly useful thing. Note that TiXmlHandle is not part of the TinyXml
>-	DOM structure. It is a separate utility class.
>-
>-	Take an example:
>-	@verbatim
>-	<Document>
>-		<Element attributeA = "valueA">
>-			<Child attributeB = "value1" />
>-			<Child attributeB = "value2" />
>-		</Element>
>-	<Document>
>-	@endverbatim
>-
>-	Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very 
>-	easy to write a *lot* of code that looks like:
>-
>-	@verbatim
>-	TiXmlElement* root = document.FirstChildElement( "Document" );
>-	if ( root )
>-	{
>-		TiXmlElement* element = root->FirstChildElement( "Element" );
>-		if ( element )
>-		{
>-			TiXmlElement* child = element->FirstChildElement( "Child" );
>-			if ( child )
>-			{
>-				TiXmlElement* child2 = child->NextSiblingElement( "Child" );
>-				if ( child2 )
>-				{
>-					// Finally do something useful.
>-	@endverbatim
>-
>-	And that doesn't even cover "else" cases. TiXmlHandle addresses the verbosity
>-	of such code. A TiXmlHandle checks for null	pointers so it is perfectly safe 
>-	and correct to use:
>-
>-	@verbatim
>-	TiXmlHandle docHandle( &document );
>-	TiXmlElement* child2 = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).Child( "Child", 1 ).Element();
>-	if ( child2 )
>-	{
>-		// do something useful
>-	@endverbatim
>-
>-	Which is MUCH more concise and useful.
>-
>-	It is also safe to copy handles - internally they are nothing more than node pointers.
>-	@verbatim
>-	TiXmlHandle handleCopy = handle;
>-	@endverbatim
>-
>-	What they should not be used for is iteration:
>-
>-	@verbatim
>-	int i=0; 
>-	while ( true )
>-	{
>-		TiXmlElement* child = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).Child( "Child", i ).Element();
>-		if ( !child )
>-			break;
>-		// do something
>-		++i;
>-	}
>-	@endverbatim
>-
>-	It seems reasonable, but it is in fact two embedded while loops. The Child method is 
>-	a linear walk to find the element, so this code would iterate much more than it needs 
>-	to. Instead, prefer:
>-
>-	@verbatim
>-	TiXmlElement* child = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).FirstChild( "Child" ).Element();
>-
>-	for( child; child; child=child->NextSiblingElement() )
>-	{
>-		// do something
>-	}
>-	@endverbatim
>-*/
>-class TiXmlHandle
>-{
>-public:
>-	/// Create a handle from any node (at any depth of the tree.) This can be a null pointer.
>-	TiXmlHandle( TiXmlNode* _node )					{ this->node = _node; }
>-	/// Copy constructor
>-	TiXmlHandle( const TiXmlHandle& ref )			{ this->node = ref.node; }
>-	TiXmlHandle operator=( const TiXmlHandle& ref ) { this->node = ref.node; return *this; }
>-
>-	/// Return a handle to the first child node.
>-	TiXmlHandle FirstChild() const;
>-	/// Return a handle to the first child node with the given name.
>-	TiXmlHandle FirstChild( const char * value ) const;
>-	/// Return a handle to the first child element.
>-	TiXmlHandle FirstChildElement() const;
>-	/// Return a handle to the first child element with the given name.
>-	TiXmlHandle FirstChildElement( const char * value ) const;
>-
>-	/** Return a handle to the "index" child with the given name. 
>-		The first child is 0, the second 1, etc.
>-	*/
>-	TiXmlHandle Child( const char* value, int index ) const;
>-	/** Return a handle to the "index" child. 
>-		The first child is 0, the second 1, etc.
>-	*/
>-	TiXmlHandle Child( int index ) const;
>-	/** Return a handle to the "index" child element with the given name. 
>-		The first child element is 0, the second 1, etc. Note that only TiXmlElements
>-		are indexed: other types are not counted.
>-	*/
>-	TiXmlHandle ChildElement( const char* value, int index ) const;
>-	/** Return a handle to the "index" child element. 
>-		The first child element is 0, the second 1, etc. Note that only TiXmlElements
>-		are indexed: other types are not counted.
>-	*/
>-	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.
>-	TiXmlNode* Node() const			{ return node; } 
>-	/// Return the handle as a TiXmlElement. This may return null.
>-	TiXmlElement* Element() const	{ return ( ( node && node->ToElement() ) ? node->ToElement() : 0 ); }
>-	/// Return the handle as a TiXmlText. This may return null.
>-	TiXmlText* Text() const			{ return ( ( node && node->ToText() ) ? node->ToText() : 0 ); }
>-	/// Return the handle as a TiXmlUnknown. This may return null;
>-	TiXmlUnknown* Unknown() const			{ return ( ( node && node->ToUnknown() ) ? node->ToUnknown() : 0 ); }
>-
>-private:
>-	TiXmlNode* node;
>-};
>-
>-#ifdef _MSC_VER
>-#pragma warning( pop )
>-#endif
>-
>-#endif
>-
>diff --git a/util/tinyxmlerror.cpp b/util/tinyxmlerror.cpp
>deleted file mode 100644
>index 5788438..0000000
>--- a/util/tinyxmlerror.cpp
>+++ /dev/null
>@@ -1,52 +0,0 @@
>-/*
>-www.sourceforge.net/projects/tinyxml
>-Original code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com)
>-
>-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.
>-*/
>-
>-#include "tinyxml.h"
>-
>-// The goal of the seperate error file is to make the first
>-// step towards localization. tinyxml (currently) only supports
>-// english error messages, but the could now be translated.
>-//
>-// It also cleans up the code a bit.
>-//
>-
>-const char* TiXmlBase::errorString[ TIXML_ERROR_STRING_COUNT ] =
>-{
>-	"No error",
>-	"Error",
>-	"Failed to open file",
>-	"Memory allocation failed.",
>-	"Error parsing Element.",
>-	"Failed to read Element name",
>-	"Error reading Element value.",
>-	"Error reading Attributes.",
>-	"Error: empty tag.",
>-	"Error reading end tag.",
>-	"Error parsing Unknown.",
>-	"Error parsing Comment.",
>-	"Error parsing Declaration.",
>-	"Error document empty.",
>-	"Error null (0) or unexpected EOF found in input stream.",
>-	"Error parsing CDATA.",
>-};
>diff --git a/util/tinyxmlparser.cpp b/util/tinyxmlparser.cpp
>deleted file mode 100644
>index 9a77ebc..0000000
>--- a/util/tinyxmlparser.cpp
>+++ /dev/null
>@@ -1,1580 +0,0 @@
>-/*
>-www.sourceforge.net/projects/tinyxml
>-Original code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com)
>-
>-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.
>-*/
>-
>-#include "tinyxml.h"
>-#include <ctype.h>
>-#include <stddef.h>
>-
>-//#define DEBUG_PARSER
>-#if defined( DEBUG_PARSER )
>-#	if defined( DEBUG ) && defined( _MSC_VER )
>-#		include <windows.h>
>-#		define TIXML_LOG OutputDebugString
>-#	else
>-#		define TIXML_LOG printf
>-#	endif
>-#endif
>-
>-// Note tha "PutString" hardcodes the same list. This
>-// is less flexible than it appears. Changing the entries
>-// or order will break putstring.	
>-TiXmlBase::Entity TiXmlBase::entity[ NUM_ENTITY ] = 
>-{
>-	{ "&amp;",  5, '&' },
>-	{ "&lt;",   4, '<' },
>-	{ "&gt;",   4, '>' },
>-	{ "&quot;", 6, '\"' },
>-	{ "&apos;", 6, '\'' }
>-};
>-
>-// Bunch of unicode info at:
>-//		http://www.unicode.org/faq/utf_bom.html
>-// Including the basic of this table, which determines the #bytes in the
>-// sequence from the lead byte. 1 placed for invalid sequences --
>-// although the result will be junk, pass it through as much as possible.
>-// Beware of the non-characters in UTF-8:	
>-//				ef bb bf (Microsoft "lead bytes")
>-//				ef bf be
>-//				ef bf bf 
>-
>-const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
>-const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
>-const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
>-
>-const int TiXmlBase::utf8ByteTable[256] = 
>-{
>-	//	0	1	2	3	4	5	6	7	8	9	a	b	c	d	e	f
>-		1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	// 0x00
>-		1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	// 0x10
>-		1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	// 0x20
>-		1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	// 0x30
>-		1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	// 0x40
>-		1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	// 0x50
>-		1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	// 0x60
>-		1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	// 0x70	End of ASCII range
>-		1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	// 0x80 0x80 to 0xc1 invalid
>-		1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	// 0x90 
>-		1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	// 0xa0 
>-		1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	// 0xb0 
>-		1,	1,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	// 0xc0 0xc2 to 0xdf 2 byte
>-		2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	2,	// 0xd0
>-		3,	3,	3,	3,	3,	3,	3,	3,	3,	3,	3,	3,	3,	3,	3,	3,	// 0xe0 0xe0 to 0xef 3 byte
>-		4,	4,	4,	4,	4,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1,	1	// 0xf0 0xf0 to 0xf4 4 byte, 0xf5 and higher invalid
>-};
>-
>-
>-void TiXmlBase::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length )
>-{
>-	const unsigned long BYTE_MASK = 0xBF;
>-	const unsigned long BYTE_MARK = 0x80;
>-	const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
>-
>-	if (input < 0x80) 
>-		*length = 1;
>-	else if ( input < 0x800 )
>-		*length = 2;
>-	else if ( input < 0x10000 )
>-		*length = 3;
>-	else if ( input < 0x200000 )
>-		*length = 4;
>-	else
>-		{ *length = 0; return; }	// This code won't covert this correctly anyway.
>-
>-	output += *length;
>-
>-	// Scary scary fall throughs.
>-	switch (*length) 
>-	{
>-		case 4:
>-			--output; 
>-			*output = (char)((input | BYTE_MARK) & BYTE_MASK); 
>-			input >>= 6;
>-		case 3:
>-			--output; 
>-			*output = (char)((input | BYTE_MARK) & BYTE_MASK); 
>-			input >>= 6;
>-		case 2:
>-			--output; 
>-			*output = (char)((input | BYTE_MARK) & BYTE_MASK); 
>-			input >>= 6;
>-		case 1:
>-			--output; 
>-			*output = (char)(input | FIRST_BYTE_MARK[*length]);
>-	}
>-}
>-
>-
>-/*static*/ int TiXmlBase::IsAlpha( unsigned char anyByte, TiXmlEncoding /*encoding*/ )
>-{
>-	// This will only work for low-ascii, everything else is assumed to be a valid
>-	// letter. I'm not sure this is the best approach, but it is quite tricky trying
>-	// to figure out alhabetical vs. not across encoding. So take a very 
>-	// conservative approach.
>-
>-//	if ( encoding == TIXML_ENCODING_UTF8 )
>-//	{
>-		if ( anyByte < 127 )
>-			return isalpha( anyByte );
>-		else
>-			return 1;	// What else to do? The unicode set is huge...get the english ones right.
>-//	}
>-//	else
>-//	{
>-//		return isalpha( anyByte );
>-//	}
>-}
>-
>-
>-/*static*/ int TiXmlBase::IsAlphaNum( unsigned char anyByte, TiXmlEncoding /*encoding*/ )
>-{
>-	// This will only work for low-ascii, everything else is assumed to be a valid
>-	// letter. I'm not sure this is the best approach, but it is quite tricky trying
>-	// to figure out alhabetical vs. not across encoding. So take a very 
>-	// conservative approach.
>-
>-//	if ( encoding == TIXML_ENCODING_UTF8 )
>-//	{
>-		if ( anyByte < 127 )
>-			return isalnum( anyByte );
>-		else
>-			return 1;	// What else to do? The unicode set is huge...get the english ones right.
>-//	}
>-//	else
>-//	{
>-//		return isalnum( anyByte );
>-//	}
>-}
>-
>-
>-class TiXmlParsingData
>-{
>-	friend class TiXmlDocument;
>-  public:
>-	void Stamp( const char* now, TiXmlEncoding encoding );
>-
>-	const TiXmlCursor& Cursor()	{ return cursor; }
>-
>-  private:
>-	// Only used by the document!
>-	TiXmlParsingData( const char* start, int _tabsize, int row, int col )
>-	{
>-		assert( start );
>-		stamp = start;
>-		tabsize = _tabsize;
>-		cursor.row = row;
>-		cursor.col = col;
>-	}
>-
>-	TiXmlCursor		cursor;
>-	const char*		stamp;
>-	int				tabsize;
>-};
>-
>-
>-void TiXmlParsingData::Stamp( const char* now, TiXmlEncoding encoding )
>-{
>-	assert( now );
>-
>-	// Do nothing if the tabsize is 0.
>-	if ( tabsize < 1 )
>-	{
>-		return;
>-	}
>-
>-	// Get the current row, column.
>-	int row = cursor.row;
>-	int col = cursor.col;
>-	const char* p = stamp;
>-	assert( p );
>-
>-	while ( p < now )
>-	{
>-		// Treat p as unsigned, so we have a happy compiler.
>-		const unsigned char* pU = (const unsigned char*)p;
>-
>-		// Code contributed by Fletcher Dunn: (modified by lee)
>-		switch (*pU) {
>-			case 0:
>-				// We *should* never get here, but in case we do, don't
>-				// advance past the terminating null character, ever
>-				return;
>-
>-			case '\r':
>-				// bump down to the next line
>-				++row;
>-				col = 0;				
>-				// Eat the character
>-				++p;
>-
>-				// Check for \r\n sequence, and treat this as a single character
>-				if (*p == '\n') {
>-					++p;
>-				}
>-				break;
>-
>-			case '\n':
>-				// bump down to the next line
>-				++row;
>-				col = 0;
>-
>-				// Eat the character
>-				++p;
>-
>-				// Check for \n\r sequence, and treat this as a single
>-				// character.  (Yes, this bizarre thing does occur still
>-				// on some arcane platforms...)
>-				if (*p == '\r') {
>-					++p;
>-				}
>-				break;
>-
>-			case '\t':
>-				// Eat the character
>-				++p;
>-
>-				// Skip to next tab stop
>-				col = (col / tabsize + 1) * tabsize;
>-				break;
>-
>-			case TIXML_UTF_LEAD_0:
>-				if ( encoding == TIXML_ENCODING_UTF8 )
>-				{
>-					if ( *(p+1) && *(p+2) )
>-					{
>-						// In these cases, don't advance the column. These are
>-						// 0-width spaces.
>-						if ( *(pU+1)==TIXML_UTF_LEAD_1 && *(pU+2)==TIXML_UTF_LEAD_2 )
>-							p += 3;	
>-						else if ( *(pU+1)==0xbfU && *(pU+2)==0xbeU )
>-							p += 3;	
>-						else if ( *(pU+1)==0xbfU && *(pU+2)==0xbfU )
>-							p += 3;	
>-						else
>-							{ p +=3; ++col; }	// A normal character.
>-					}
>-				}
>-				else
>-				{
>-					++p;
>-					++col;
>-				}
>-				break;
>-
>-			default:
>-				if ( encoding == TIXML_ENCODING_UTF8 )
>-				{
>-					// Eat the 1 to 4 byte utf8 character.
>-					int step = TiXmlBase::utf8ByteTable[*((unsigned char*)p)];
>-					if ( step == 0 )
>-						step = 1;		// Error case from bad encoding, but handle gracefully.
>-					p += step;
>-
>-					// Just advance one column, of course.
>-					++col;
>-				}
>-				else
>-				{
>-					++p;
>-					++col;
>-				}
>-				break;
>-		}
>-	}
>-	cursor.row = row;
>-	cursor.col = col;
>-	assert( cursor.row >= -1 );
>-	assert( cursor.col >= -1 );
>-	stamp = p;
>-	assert( stamp );
>-}
>-
>-
>-const char* TiXmlBase::SkipWhiteSpace( const char* p, TiXmlEncoding encoding )
>-{
>-	if ( !p || !*p )
>-	{
>-		return 0;
>-	}
>-	if ( encoding == TIXML_ENCODING_UTF8 )
>-	{
>-		while ( *p )
>-		{
>-			const unsigned char* pU = (const unsigned char*)p;
>-			
>-			// Skip the stupid Microsoft UTF-8 Byte order marks
>-			if (	*(pU+0)==TIXML_UTF_LEAD_0
>-				 && *(pU+1)==TIXML_UTF_LEAD_1 
>-				 && *(pU+2)==TIXML_UTF_LEAD_2 )
>-			{
>-				p += 3;
>-				continue;
>-			}
>-			else if(*(pU+0)==TIXML_UTF_LEAD_0
>-				 && *(pU+1)==0xbfU
>-				 && *(pU+2)==0xbeU )
>-			{
>-				p += 3;
>-				continue;
>-			}
>-			else if(*(pU+0)==TIXML_UTF_LEAD_0
>-				 && *(pU+1)==0xbfU
>-				 && *(pU+2)==0xbfU )
>-			{
>-				p += 3;
>-				continue;
>-			}
>-
>-			if ( IsWhiteSpace( *p ) || *p == '\n' || *p =='\r' )		// Still using old rules for white space.
>-				++p;
>-			else
>-				break;
>-		}
>-	}
>-	else
>-	{
>-		while ( *p && IsWhiteSpace( *p ) || *p == '\n' || *p =='\r' )
>-			++p;
>-	}
>-
>-	return p;
>-}
>-
>-#ifdef TIXML_USE_STL
>-/*static*/ bool TiXmlBase::StreamWhiteSpace( TIXML_ISTREAM * in, TIXML_STRING * tag )
>-{
>-	for( ;; )
>-	{
>-		if ( !in->good() ) return false;
>-
>-		int c = in->peek();
>-		// At this scope, we can't get to a document. So fail silently.
>-		if ( !IsWhiteSpace( c ) || c <= 0 )
>-			return true;
>-
>-		*tag += (char) in->get();
>-	}
>-}
>-
>-/*static*/ bool TiXmlBase::StreamTo( TIXML_ISTREAM * in, int character, TIXML_STRING * tag )
>-{
>-	//assert( character > 0 && character < 128 );	// else it won't work in utf-8
>-	while ( in->good() )
>-	{
>-		int c = in->peek();
>-		if ( c == character )
>-			return true;
>-		if ( c <= 0 )		// Silent failure: can't get document at this scope
>-			return false;
>-
>-		in->get();
>-		*tag += (char) c;
>-	}
>-	return false;
>-}
>-#endif
>-
>-const char* TiXmlBase::ReadName( const char* p, TIXML_STRING * name, TiXmlEncoding encoding )
>-{
>-	*name = "";
>-	assert( p );
>-
>-	// Names start with letters or underscores.
>-	// Of course, in unicode, tinyxml has no idea what a letter *is*. The
>-	// algorithm is generous.
>-	//
>-	// After that, they can be letters, underscores, numbers,
>-	// hyphens, or colons. (Colons are valid ony for namespaces,
>-	// but tinyxml can't tell namespaces from names.)
>-	if (    p && *p 
>-		 && ( IsAlpha( (unsigned char) *p, encoding ) || *p == '_' ) )
>-	{
>-		while(		p && *p
>-				&&	(		IsAlphaNum( (unsigned char ) *p, encoding ) 
>-						 || *p == '_'
>-						 || *p == '-'
>-						 || *p == '.'
>-						 || *p == ':' ) )
>-		{
>-			(*name) += *p;
>-			++p;
>-		}
>-		return p;
>-	}
>-	return 0;
>-}
>-
>-const char* TiXmlBase::GetEntity( const char* p, char* value, int* length, TiXmlEncoding encoding )
>-{
>-	// Presume an entity, and pull it out.
>-    TIXML_STRING ent;
>-	int i;
>-	*length = 0;
>-
>-	if ( *(p+1) && *(p+1) == '#' && *(p+2) )
>-	{
>-		unsigned long ucs = 0;
>-		ptrdiff_t delta = 0;
>-		unsigned mult = 1;
>-
>-		if ( *(p+2) == 'x' )
>-		{
>-			// Hexadecimal.
>-			if ( !*(p+3) ) return 0;
>-
>-			const char* q = p+3;
>-			q = strchr( q, ';' );
>-
>-			if ( !q || !*q ) return 0;
>-
>-			delta = q-p;
>-			--q;
>-
>-			while ( *q != 'x' )
>-			{
>-				if ( *q >= '0' && *q <= '9' )
>-					ucs += mult * (*q - '0');
>-				else if ( *q >= 'a' && *q <= 'f' )
>-					ucs += mult * (*q - 'a' + 10);
>-				else if ( *q >= 'A' && *q <= 'F' )
>-					ucs += mult * (*q - 'A' + 10 );
>-				else 
>-					return 0;
>-				mult *= 16;
>-				--q;
>-			}
>-		}
>-		else
>-		{
>-			// Decimal.
>-			if ( !*(p+2) ) return 0;
>-
>-			const char* q = p+2;
>-			q = strchr( q, ';' );
>-
>-			if ( !q || !*q ) return 0;
>-
>-			delta = q-p;
>-			--q;
>-
>-			while ( *q != '#' )
>-			{
>-				if ( *q >= '0' && *q <= '9' )
>-					ucs += mult * (*q - '0');
>-				else 
>-					return 0;
>-				mult *= 10;
>-				--q;
>-			}
>-		}
>-		if ( encoding == TIXML_ENCODING_UTF8 )
>-		{
>-			// convert the UCS to UTF-8
>-			ConvertUTF32ToUTF8( ucs, value, length );
>-		}
>-		else
>-		{
>-			*value = (char)ucs;
>-			*length = 1;
>-		}
>-		return p + delta + 1;
>-	}
>-
>-	// Now try to match it.
>-	for( i=0; i<NUM_ENTITY; ++i )
>-	{
>-		if ( strncmp( entity[i].str, p, entity[i].strLength ) == 0 )
>-		{
>-			assert( strlen( entity[i].str ) == entity[i].strLength );
>-			*value = entity[i].chr;
>-			*length = 1;
>-			return ( p + entity[i].strLength );
>-		}
>-	}
>-
>-	// So it wasn't an entity, its unrecognized, or something like that.
>-	*value = *p;	// Don't put back the last one, since we return it!
>-	return p+1;
>-}
>-
>-
>-bool TiXmlBase::StringEqual( const char* p,
>-							 const char* tag,
>-							 bool ignoreCase,
>-							 TiXmlEncoding encoding )
>-{
>-	assert( p );
>-	assert( tag );
>-	if ( !p || !*p )
>-	{
>-		assert( 0 );
>-		return false;
>-	}
>-
>-	const char* q = p;
>-
>-	if ( ignoreCase )
>-	{
>-		while ( *q && *tag && ToLower( *q, encoding ) == ToLower( *tag, encoding ) )
>-		{
>-			++q;
>-			++tag;
>-		}
>-
>-		if ( *tag == 0 )
>-			return true;
>-	}
>-	else
>-	{
>-		while ( *q && *tag && *q == *tag )
>-		{
>-			++q;
>-			++tag;
>-		}
>-
>-		if ( *tag == 0 )		// Have we found the end of the tag, and everything equal?
>-			return true;
>-	}
>-	return false;
>-}
>-
>-const char* TiXmlBase::ReadText(	const char* p, 
>-									TIXML_STRING * text, 
>-									bool trimWhiteSpace, 
>-									const char* endTag, 
>-									bool caseInsensitive,
>-									TiXmlEncoding encoding )
>-{
>-    *text = "";
>-	if (    !trimWhiteSpace			// certain tags always keep whitespace
>-		 || !condenseWhiteSpace )	// if true, whitespace is always kept
>-	{
>-		// Keep all the white space.
>-		while (	   p && *p
>-				&& !StringEqual( p, endTag, caseInsensitive, encoding )
>-			  )
>-		{
>-			int len;
>-			char cArr[4] = { 0, 0, 0, 0 };
>-			p = GetChar( p, cArr, &len, encoding );
>-			text->append( cArr, len );
>-		}
>-	}
>-	else
>-	{
>-		bool whitespace = false;
>-
>-		// Remove leading white space:
>-		p = SkipWhiteSpace( p, encoding );
>-		while (	   p && *p
>-				&& !StringEqual( p, endTag, caseInsensitive, encoding ) )
>-		{
>-			if ( *p == '\r' || *p == '\n' )
>-			{
>-				whitespace = true;
>-				++p;
>-			}
>-			else if ( IsWhiteSpace( *p ) )
>-			{
>-				whitespace = true;
>-				++p;
>-			}
>-			else
>-			{
>-				// If we've found whitespace, add it before the
>-				// new character. Any whitespace just becomes a space.
>-				if ( whitespace )
>-				{
>-					(*text) += ' ';
>-					whitespace = false;
>-				}
>-				int len;
>-				char cArr[4] = { 0, 0, 0, 0 };
>-				p = GetChar( p, cArr, &len, encoding );
>-				if ( len == 1 )
>-					(*text) += cArr[0];	// more efficient
>-				else
>-					text->append( cArr, len );
>-			}
>-		}
>-	}
>-	return p + strlen( endTag );
>-}
>-
>-#ifdef TIXML_USE_STL
>-
>-void TiXmlDocument::StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag )
>-{
>-	// The basic issue with a document is that we don't know what we're
>-	// streaming. Read something presumed to be a tag (and hope), then
>-	// identify it, and call the appropriate stream method on the tag.
>-	//
>-	// This "pre-streaming" will never read the closing ">" so the
>-	// sub-tag can orient itself.
>-
>-	if ( !StreamTo( in, '<', tag ) ) 
>-	{
>-		SetError( TIXML_ERROR_PARSING_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN );
>-		return;
>-	}
>-
>-	while ( in->good() )
>-	{
>-		int tagIndex = (int) tag->length();
>-		while ( in->good() && in->peek() != '>' )
>-		{
>-			int c = in->get();
>-			if ( c <= 0 )
>-			{
>-				SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );
>-				break;
>-			}
>-			(*tag) += (char) c;
>-		}
>-
>-		if ( in->good() )
>-		{
>-			// We now have something we presume to be a node of 
>-			// some sort. Identify it, and call the node to
>-			// continue streaming.
>-			TiXmlNode* node = Identify( tag->c_str() + tagIndex, TIXML_DEFAULT_ENCODING );
>-
>-			if ( node )
>-			{
>-				node->StreamIn( in, tag );
>-				bool isElement = node->ToElement() != 0;
>-				delete node;
>-				node = 0;
>-
>-				// If this is the root element, we're done. Parsing will be
>-				// done by the >> operator.
>-				if ( isElement )
>-				{
>-					return;
>-				}
>-			}
>-			else
>-			{
>-				SetError( TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN );
>-				return;
>-			}
>-		}
>-	}
>-	// 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 )
>-{
>-	ClearError();
>-
>-	// Parse away, at the document level. Since a document
>-	// contains nothing but other tags, most of what happens
>-	// here is skipping white space.
>-	if ( !p || !*p )
>-	{
>-		SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN );
>-		return 0;
>-	}
>-
>-	// Note that, for a document, this needs to come
>-	// before the while space skip, so that parsing
>-	// starts from the pointer we are given.
>-	location.Clear();
>-	if ( prevData )
>-	{
>-		location.row = prevData->cursor.row;
>-		location.col = prevData->cursor.col;
>-	}
>-	else
>-	{
>-		location.row = 0;
>-		location.col = 0;
>-	}
>-	TiXmlParsingData data( p, TabSize(), location.row, location.col );
>-	location = data.Cursor();
>-
>-	if ( encoding == TIXML_ENCODING_UNKNOWN )
>-	{
>-		// Check for the Microsoft UTF-8 lead bytes.
>-		const unsigned char* pU = (const unsigned char*)p;
>-		if (	*(pU+0) && *(pU+0) == TIXML_UTF_LEAD_0
>-			 && *(pU+1) && *(pU+1) == TIXML_UTF_LEAD_1
>-			 && *(pU+2) && *(pU+2) == TIXML_UTF_LEAD_2 )
>-		{
>-			encoding = TIXML_ENCODING_UTF8;
>-			useMicrosoftBOM = true;
>-		}
>-	}
>-
>-    p = SkipWhiteSpace( p, encoding );
>-	if ( !p )
>-	{
>-		SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN );
>-		return 0;
>-	}
>-
>-	while ( p && *p )
>-	{
>-		TiXmlNode* node = Identify( p, encoding );
>-		if ( node )
>-		{
>-			p = node->Parse( p, &data, encoding );
>-			LinkEndChild( node );
>-		}
>-		else
>-		{
>-			break;
>-		}
>-
>-		// Did we get encoding info?
>-		if (    encoding == TIXML_ENCODING_UNKNOWN
>-			 && node->ToDeclaration() )
>-		{
>-			TiXmlDeclaration* dec = node->ToDeclaration();
>-			const char* enc = dec->Encoding();
>-			assert( enc );
>-
>-			if ( *enc == 0 )
>-				encoding = TIXML_ENCODING_UTF8;
>-			else if ( StringEqual( enc, "UTF-8", true, TIXML_ENCODING_UNKNOWN ) )
>-				encoding = TIXML_ENCODING_UTF8;
>-			else if ( StringEqual( enc, "UTF8", true, TIXML_ENCODING_UNKNOWN ) )
>-				encoding = TIXML_ENCODING_UTF8;	// incorrect, but be nice
>-			else 
>-				encoding = TIXML_ENCODING_LEGACY;
>-		}
>-
>-		p = SkipWhiteSpace( p, encoding );
>-	}
>-
>-	// Was this empty?
>-	if ( !firstChild ) {
>-		SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, encoding );
>-		return 0;
>-	}
>-
>-	// All is well.
>-	return p;
>-}
>-
>-void TiXmlDocument::SetError( int err, const char* pError, TiXmlParsingData* data, TiXmlEncoding encoding )
>-{	
>-	// The first error in a chain is more accurate - don't set again!
>-	if ( error )
>-		return;
>-
>-	assert( err > 0 && err < TIXML_ERROR_STRING_COUNT );
>-	error   = true;
>-	errorId = err;
>-	errorDesc = errorString[ errorId ];
>-
>-	errorLocation.Clear();
>-	if ( pError && data )
>-	{
>-		data->Stamp( pError, encoding );
>-		errorLocation = data->Cursor();
>-	}
>-}
>-
>-
>-TiXmlNode* TiXmlNode::Identify( const char* p, TiXmlEncoding encoding )
>-{
>-	TiXmlNode* returnNode = 0;
>-
>-	p = SkipWhiteSpace( p, encoding );
>-	if( !p || !*p || *p != '<' )
>-	{
>-		return 0;
>-	}
>-
>-	TiXmlDocument* doc = GetDocument();
>-	p = SkipWhiteSpace( p, encoding );
>-
>-	if ( !p || !*p )
>-	{
>-		return 0;
>-	}
>-
>-	// What is this thing? 
>-	// - Elements start with a letter or underscore, but xml is reserved.
>-	// - Comments: ";
>-
>-	if ( !StringEqual( p, startTag, false, encoding ) )
>-	{
>-		document->SetError( TIXML_ERROR_PARSING_COMMENT, p, data, encoding );
>-		return 0;
>-	}
>-	p += strlen( startTag );
>-	p = ReadText( p, &value, false, endTag, false, encoding );
>-	return p;
>-}
>-
>-
>-const char* TiXmlAttribute::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )
>-{
>-	p = SkipWhiteSpace( p, encoding );
>-	if ( !p || !*p ) return 0;
>-
>-	int tabsize = 4;
>-	if ( document )
>-		tabsize = document->TabSize();
>-
>-	if ( data )
>-	{
>-		data->Stamp( p, encoding );
>-		location = data->Cursor();
>-	}
>-	// Read the name, the '=' and the value.
>-	const char* pErr = p;
>-	p = ReadName( p, &name, encoding );
>-	if ( !p || !*p )
>-	{
>-		if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, pErr, data, encoding );
>-		return 0;
>-	}
>-	p = SkipWhiteSpace( p, encoding );
>-	if ( !p || !*p || *p != '=' )
>-	{
>-		if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding );
>-		return 0;
>-	}
>-
>-	++p;	// skip '='
>-	p = SkipWhiteSpace( p, encoding );
>-	if ( !p || !*p )
>-	{
>-		if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding );
>-		return 0;
>-	}
>-	
>-	const char* end;
>-
>-	if ( *p == '\'' )
>-	{
>-		++p;
>-		end = "\'";
>-		p = ReadText( p, &value, false, end, false, encoding );
>-	}
>-	else if ( *p == '"' )
>-	{
>-		++p;
>-		end = "\"";
>-		p = ReadText( p, &value, false, end, false, encoding );
>-	}
>-	else
>-	{
>-		// All attribute values should be in single or double quotes.
>-		// But this is such a common error that the parser will try
>-		// its best, even without them.
>-		value = "";
>-		while (    p && *p										// existence
>-				&& !IsWhiteSpace( *p ) && *p != '\n' && *p != '\r'	// whitespace
>-				&& *p != '/' && *p != '>' )						// tag end
>-		{
>-			value += *p;
>-			++p;
>-		}
>-	}
>-	return p;
>-}
>-
>-#ifdef TIXML_USE_STL
>-void TiXmlText::StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag )
>-{
>-	if ( cdata )
>-	{
>-		int c = in->get();	
>-		if ( c <= 0 )
>-		{
>-			TiXmlDocument* document = GetDocument();
>-			if ( document )
>-				document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );
>-			return;
>-		}
>-
>-		(*tag) += (char) c;
>-
>-		if ( c == '>' 
>-			 && tag->at( tag->length() - 2 ) == ']'
>-			 && tag->at( tag->length() - 3 ) == ']' )
>-		{
>-			// All is well.
>-			return;		
>-		}
>-	}
>-	else
>-	{
>-		while ( in->good() )
>-		{
>-			int c = in->peek();	
>-			if ( c == '<' )
>-				return;
>-			if ( c <= 0 )
>-			{
>-				TiXmlDocument* document = GetDocument();
>-				if ( document )
>-					document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );
>-				return;
>-			}
>-
>-			(*tag) += (char) c;
>-			in->get();
>-		}
>-	}
>-}
>-#endif
>-
>-const char* TiXmlText::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )
>-{
>-	value = "";
>-	TiXmlDocument* document = GetDocument();
>-
>-	if ( data )
>-	{
>-		data->Stamp( p, encoding );
>-		location = data->Cursor();
>-	}
>-
>-	const char* const startTag = "<![CDATA[";
>-	const char* const endTag   = "]]>";
>-
>-	if ( cdata || StringEqual( p, startTag, false, encoding ) )
>-	{
>-		cdata = true;
>-
>-		if ( !StringEqual( p, startTag, false, encoding ) )
>-		{
>-			document->SetError( TIXML_ERROR_PARSING_CDATA, p, data, encoding );
>-			return 0;
>-		}
>-		p += strlen( startTag );
>-
>-		// Keep all the white space, ignore the encoding, etc.
>-		while (	   p && *p
>-				&& !StringEqual( p, endTag, false, encoding )
>-			  )
>-		{
>-			value += *p;
>-			++p;
>-		}
>-
>-		TIXML_STRING dummy; 
>-		p = ReadText( p, &dummy, false, endTag, false, encoding );
>-		return p;
>-	}
>-	else
>-	{
>-		bool ignoreWhite = true;
>-
>-		const char* end = "<";
>-		p = ReadText( p, &value, ignoreWhite, end, false, encoding );
>-		if ( p )
>-			return p-1;	// don't truncate the '<'
>-		return 0;
>-	}
>-}
>-
>-#ifdef TIXML_USE_STL
>-void TiXmlDeclaration::StreamIn( TIXML_ISTREAM * in, TIXML_STRING * tag )
>-{
>-	while ( in->good() )
>-	{
>-		int c = in->get();
>-		if ( c <= 0 )
>-		{
>-			TiXmlDocument* document = GetDocument();
>-			if ( document )
>-				document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );
>-			return;
>-		}
>-		(*tag) += (char) c;
>-
>-		if ( c == '>' )
>-		{
>-			// All is well.
>-			return;
>-		}
>-	}
>-}
>-#endif
>-
>-const char* TiXmlDeclaration::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding _encoding )
>-{
>-	p = SkipWhiteSpace( p, _encoding );
>-	// Find the beginning, find the end, and look for
>-	// the stuff in-between.
>-	TiXmlDocument* document = GetDocument();
>-	if ( !p || !*p || !StringEqual( p, "<?xml", true, _encoding ) )
>-	{
>-		if ( document ) document->SetError( TIXML_ERROR_PARSING_DECLARATION, 0, 0, _encoding );
>-		return 0;
>-	}
>-	if ( data )
>-	{
>-		data->Stamp( p, _encoding );
>-		location = data->Cursor();
>-	}
>-	p += 5;
>-
>-	version = "";
>-	encoding = "";
>-	standalone = "";
>-
>-	while ( p && *p )
>-	{
>-		if ( *p == '>' )
>-		{
>-			++p;
>-			return p;
>-		}
>-
>-		p = SkipWhiteSpace( p, _encoding );
>-		if ( StringEqual( p, "version", true, _encoding ) )
>-		{
>-			TiXmlAttribute attrib;
>-			p = attrib.Parse( p, data, _encoding );		
>-			version = attrib.Value();
>-		}
>-		else if ( StringEqual( p, "encoding", true, _encoding ) )
>-		{
>-			TiXmlAttribute attrib;
>-			p = attrib.Parse( p, data, _encoding );		
>-			encoding = attrib.Value();
>-		}
>-		else if ( StringEqual( p, "standalone", true, _encoding ) )
>-		{
>-			TiXmlAttribute attrib;
>-			p = attrib.Parse( p, data, _encoding );		
>-			standalone = attrib.Value();
>-		}
>-		else
>-		{
>-			// Read over whatever it is.
>-			while( p && *p && *p != '>' && !IsWhiteSpace( *p ) )
>-				++p;
>-		}
>-	}
>-	return 0;
>-}
>-
>-bool TiXmlText::Blank() const
>-{
>-	for ( unsigned i=0; i<value.length(); i++ )
>-		if ( !IsWhiteSpace( value[i] ) )
>-			return false;
>-	return true;
>-}
>-
>-- 
>2.10.0
>

Actions: View | Splinter Review

Attachments on bug 33937: 42964 | 126927

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.