add packagespackages

1 files changed, 0 insertions, 1630 deletions

diff --git a/yhttpd/src/contrib/xml/tinyxml.h b/yhttpd/src/contrib/xml/tinyxml.h
deleted file mode 100644
index a9ece4b..0000000
--- a/yhttpd/src/contrib/xml/tinyxml.h
+++ /dev/null
@@ -1,1630 +0,0 @@
-#include "../../incl.h"
-
-
-/*
-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( 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
-
-#if defined( DEBUG ) && defined( _MSC_VER )
-#include <windows.h>
-#define TIXML_LOG OutputDebugString
-#else
-#define TIXML_LOG printf
-#endif
-
-#include <string>
-#include <iostream>
-#define TIXML_STRING	std::string
-#define TIXML_ISTREAM	std::istream
-#define TIXML_OSTREAM	std::ostream
-
-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 = 3;
-const int TIXML_PATCH_VERSION = 2;
-
-/*	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;
-
-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' );
-  }
-
-  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 );
-      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 Engilish words: StringEqual( p, "version", true ) is fine.
-  static bool StringEqual(	const char* p,
-                           const char* endTag,
-                           bool ignoreCase,
-                           TiXmlEncoding encoding );
-
-
-  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_STRING_COUNT
-  };
-  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 ();
-  }
-
-  /** 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 )
-  {
-    StringToBuffer buf( _value );
-    SetValue( buf.buffer ? buf.buffer : "" );
-  }
-#endif
-
-  /// Delete all the children of this node. Does not affect 'this'.
-  void Clear();
-
-  /// One step up the DOM.
-  TiXmlNode* Parent() const
-  {
-    return parent;
-  }
-
-  TiXmlNode* FirstChild()	const
-  {
-    return firstChild;
-  }		///< The first child of this node. Will be null if there are no children.
-  TiXmlNode* FirstChild( const char * value ) const;			///< The first child of this node with the matching 'value'. Will be null if none found.
-
-  TiXmlNode* LastChild() const
-  {
-    return lastChild;
-  }		/// The last child of this node. Will be null if there are no children.
-  TiXmlNode* LastChild( const char * value ) const;			/// The last child of this node matching 'value'. Will be null if there are no children.
-
-#ifdef TIXML_USE_STL
-
-  TiXmlNode* FirstChild( const std::string& _value ) const
-  {
-    return FirstChild (_value.c_str ());
-  }	///< STL std::string form.
-  TiXmlNode* LastChild( const std::string& _value ) const
-  {
-    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.
-  */
-  TiXmlNode* IterateChildren( TiXmlNode* previous ) const;
-
-  /// This flavor of IterateChildren searches for children with a particular 'value'
-  TiXmlNode* IterateChildren( const char * value, TiXmlNode* previous ) const;
-
-#ifdef TIXML_USE_STL
-
-  TiXmlNode* IterateChildren( const std::string& _value, TiXmlNode* previous ) const
-  {
-    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.
-  TiXmlNode* PreviousSibling() const
-  {
-    return prev;
-  }
-
-  /// Navigate to a sibling node.
-  TiXmlNode* PreviousSibling( const char * ) const;
-
-#ifdef TIXML_USE_STL
-
-  TiXmlNode* PreviousSibling( const std::string& _value ) const
-  {
-    return PreviousSibling (_value.c_str ());
-  }	///< STL std::string form.
-  TiXmlNode* NextSibling( const std::string& _value) const
-  {
-    return NextSibling (_value.c_str ());
-  }	///< STL std::string form.
-#endif
-
-  /// Navigate to a sibling node.
-  TiXmlNode* NextSibling() const
-  {
-    return next;
-  }
-
-  /// Navigate to a sibling node with the given 'value'.
-  TiXmlNode* NextSibling( const char * ) const;
-
-  /** Convenience function to get through elements.
-  	Calls NextSibling and ToElement. Will skip all non-Element
-  	nodes. Returns 0 if there is not another element.
-  */
-  TiXmlElement* NextSiblingElement() const;
-
-  /** Convenience function to get through elements.
-  	Calls NextSibling and ToElement. Will skip all non-Element
-  	nodes. Returns 0 if there is not another element.
-  */
-  TiXmlElement* NextSiblingElement( const char * ) const;
-
-#ifdef TIXML_USE_STL
-
-  TiXmlElement* NextSiblingElement( const std::string& _value) const
-  {
-    return NextSiblingElement (_value.c_str ());
-  }	///< STL std::string form.
-#endif
-
-  /// Convenience function to get through elements.
-  TiXmlElement* FirstChildElement()	const;
-
-  /// Convenience function to get through elements.
-  TiXmlElement* FirstChildElement( const char * value ) const;
-
-#ifdef TIXML_USE_STL
-
-  TiXmlElement* FirstChildElement( const std::string& _value ) const
-  {
-    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.
-  */
-  virtual int Type() const
-  {
-    return type;
-  }
-
-  /** Return a pointer to the Document this node lives in.
-  	Returns null if not in a document.
-  */
-  TiXmlDocument* GetDocument() const;
-
-  /// Returns true if this node has no children.
-  bool NoChildren() const
-  {
-    return !firstChild;
-  }
-
-  TiXmlDocument* ToDocument()	const
-  {
-  return ( this && type == DOCUMENT ) ? (TiXmlDocument*) this : 0;
-  } ///< Cast to a more defined type. Will return null not of the requested type.
-  TiXmlElement*  ToElement() const
-  {
-    return ( this && type == ELEMENT  ) ? (TiXmlElement*)  this : 0;
-  } ///< Cast to a more defined type. Will return null not of the requested type.
-  TiXmlComment*  ToComment() const
-  {
-    return ( this && type == COMMENT  ) ? (TiXmlComment*)  this : 0;
-  } ///< Cast to a more defined type. Will return null not of the requested type.
-  TiXmlUnknown*  ToUnknown() const
-  {
-    return ( this && type == UNKNOWN  ) ? (TiXmlUnknown*)  this : 0;
-  } ///< Cast to a more defined type. Will return null not of the requested type.
-  TiXmlText*	   ToText()    const
-  {
-    return ( this && type == TEXT     ) ? (TiXmlText*)     this : 0;
-  } ///< Cast to a more defined type. Will return null not of the requested type.
-  TiXmlDeclaration* ToDeclaration() const
-  {
-    return ( this && type == DECLARATION ) ? (TiXmlDeclaration*) this : 0;
-  } ///< Cast to a more defined type. Will return null 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 );
-
-  // Internal Value function returning a TIXML_STRING
-  const TIXML_STRING& SValue() const
-  {
-    return value ;
-  }
-
-  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.
-  const int       IntValue() const;									///< Return the value of this attribute, converted to an integer.
-  const double	DoubleValue() const;								///< Return the value of this attribute, converted to a double.
-
-  /** 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 )
-  {
-    StringToBuffer buf( _name );
-    SetName ( buf.buffer ? buf.buffer : "error" );
-  }
-  /// STL std::string form.
-  void SetValue( const std::string& _value )
-  {
-    StringToBuffer buf( _value );
-    SetValue( buf.buffer ? buf.buffer : "error" );
-  }
-#endif
-
-  /// Get the next sibling attribute in the DOM. Returns null at end.
-  TiXmlAttribute* Next() const;
-  /// Get the previous sibling attribute in the DOM. Returns null at beginning.
-  TiXmlAttribute* Previous() const;
-
-  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 );
-
-  TiXmlAttribute* First() const
-  {
-    return ( sentinel.next == &sentinel ) ? 0 : sentinel.next;
-  }
-  TiXmlAttribute* Last()  const
-  {
-    return ( sentinel.prev == &sentinel ) ? 0 : sentinel.prev;
-  }
-  TiXmlAttribute*	Find( const char * name ) const;
-
-private:
-  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;
-
-  /** 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 )
-  {
-    StringToBuffer n( name );
-    StringToBuffer v( _value );
-    if ( n.buffer && v.buffer )
-      SetAttribute (n.buffer, v.buffer );
-  }
-  ///< STL std::string form.
-  void SetAttribute( const std::string& name, int _value )
-  {
-    StringToBuffer n( name );
-    if ( n.buffer )
-      SetAttribute (n.buffer, _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
-
-  TiXmlAttribute* FirstAttribute() const
-  {
-    return attributeSet.First();
-  }		///< Access the first attribute in this element.
-  TiXmlAttribute* LastAttribute()	const
-  {
-    return attributeSet.Last();
-  }		///< Access the last attribute in this element.
-
-  /// 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 );
-
-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 );
-
-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:
-
-};
-
-
-/**