added yhttpd and ycurses trunk versions

1 files changed, 1630 insertions, 0 deletions

diff --git a/yhttpd/src/contrib/xml/tinyxml.h b/yhttpd/src/contrib/xml/tinyxml.h
new file mode 100644
index 0000000..a9ece4b
--- /dev/null
+++ b/yhttpd/src/contrib/xml/tinyxml.h
@@ -0,0 +1,1630 @@
+#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:
+
+};
+
+
+/** XML text. Contained in an element.
+*/
+class TiXmlText : public TiXmlNode