10 files changed, 5816 insertions, 0 deletions

diff --git a/0.8/src/contrib/README b/0.8/src/contrib/README
new file mode 100644
index 0000000..873f114
--- /dev/null
+++ b/0.8/src/contrib/README
@@ -0,0 +1,5 @@
+This directory includes source code which has been included directly into yChat but is not
+programmed by the yChat project explicitly which means the source code here is from extern.
+
+Used versions:
+tinyxml 2.3.2
diff --git a/0.8/src/contrib/crypt/how b/0.8/src/contrib/crypt/how
new file mode 100644
index 0000000..d60c94b
--- /dev/null
+++ b/0.8/src/contrib/crypt/how
@@ -0,0 +1 @@
+hash = md5::MD5Crypt(this->password.c_str(), salt);
diff --git a/0.8/src/contrib/crypt/md5.cpp b/0.8/src/contrib/crypt/md5.cpp
new file mode 100644
index 0000000..1f74478
--- /dev/null
+++ b/0.8/src/contrib/crypt/md5.cpp
@@ -0,0 +1,295 @@
+/*:*
+ *: File: ./src/contrib/crypt/md5.cpp
+ *: 
+ *: yChat; Homepage: ychat.buetow.org; Version 0.9.0-CURRENT
+ *: 
+ *: Copyright (C) 2003 Paul C. Buetow, Volker Richter
+ *: Copyright (C) 2004 Paul C. Buetow
+ *: Copyright (C) 2005 EXA Digital Solutions GbR
+ *: Copyright (C) 2006, 2007 Paul C. Buetow
+ *: 
+ *: This program is free software; you can redistribute it and/or
+ *: modify it under the terms of the GNU General Public License
+ *: as published by the Free Software Foundation; either version 2
+ *: of the License, or (at your option) any later version.
+ *: 
+ *: This program is distributed in the hope that it will be useful,
+ *: but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *: GNU General Public License for more details.
+ *: 
+ *: You should have received a copy of the GNU General Public License
+ *: along with this program; if not, write to the Free Software
+ *: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *:*/
+
+/*
+ * This code implements the MD5 message-digest algorithm.
+ * The algorithm is due to Ron Rivest.  This code was
+ * written by Colin Plumb in 1993, no copyright is claimed.
+ * This code is in the public domain; do with it what you wish.
+ *
+ * Equivalent code is available from RSA Data Security, Inc.
+ * This code has been tested against that, and is equivalent,
+ * except that you don't need to include two pages of legalese
+ * with every copy.
+ *
+ * To compute the message digest of a chunk of bytes, declare an
+ * MD5Context structure, pass it to MD5Init, call MD5Update as
+ * needed on buffers full of bytes, and then call MD5Final, which
+ * will fill a supplied 16-byte array with the digest.
+ */
+
+#include <string.h>		/* for memcpy() */
+#include "md5.h"
+
+namespace md5
+{
+
+#ifndef HIGHFIRST
+#define byteReverse(buf, len)	/* Nothing */
+#else
+void byteReverse(unsigned char *buf, unsigned longs);
+
+#ifndef ASM_MD5
+/*
+* Note: this code is harmless on little-endian machines.
+*/
+void
+byteReverse(unsigned char *buf, unsigned longs)
+{
+  uint32 t;
+  do
+  {
+    t = (uint32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
+        ((unsigned) buf[1] << 8 | buf[0]);
+    *(uint32 *) buf = t;
+    buf += 4;
+  }
+  while (--longs);
+}
+#endif
+#endif
+
+/*
+ * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
+ * initialization constants.
+ */
+void
+MD5Init(struct MD5Context *ctx)
+{
+  ctx->buf[0] = 0x67452301;
+  ctx->buf[1] = 0xefcdab89;
+  ctx->buf[2] = 0x98badcfe;
+  ctx->buf[3] = 0x10325476;
+
+  ctx->bits[0] = 0;
+  ctx->bits[1] = 0;
+}
+
+/*
+ * Update context to reflect the concatenation of another buffer full
+ * of bytes.
+ */
+void
+MD5Update(struct MD5Context *ctx, unsigned char const *buf, unsigned len)
+{
+  uint32 t;
+
+  /* Update bitcount */
+
+  t = ctx->bits[0];
+  if ((ctx->bits[0] = t + ((uint32) len << 3)) < t)
+    ctx->bits[1]++;		/* Carry from low to high */
+  ctx->bits[1] += len >> 29;
+
+  t = (t >> 3) & 0x3f;	/* Bytes already in shsInfo->data */
+
+  /* Handle any leading odd-sized chunks */
+
+  if (t)
+  {
+    unsigned char *p = (unsigned char *) ctx->in + t;
+
+    t = 64 - t;
+    if (len < t)
+    {
+      memcpy(p, buf, len);
+      return;
+    }
+    memcpy(p, buf, t);
+    byteReverse(ctx->in, 16);
+    MD5Transform(ctx->buf, (uint32 *) ctx->in);
+    buf += t;
+    len -= t;
+  }
+  /* Process data in 64-byte chunks */
+
+  while (len >= 64)
+  {
+    memcpy(ctx->in, buf, 64);
+    byteReverse(ctx->in, 16);
+    MD5Transform(ctx->buf, (uint32 *) ctx->in);
+    buf += 64;
+    len -= 64;
+  }
+
+  /* Handle any remaining bytes of data. */
+
+  memcpy(ctx->in, buf, len);
+}
+
+/*
+ * Final wrapup - pad to 64-byte boundary with the bit pattern
+ * 1 0* (64-bit count of bits processed, MSB-first)
+ */
+void
+MD5Final(unsigned char digest[16], struct MD5Context *ctx)
+{
+  unsigned count;
+  unsigned char *p;
+
+  /* Compute number of bytes mod 64 */
+  count = (ctx->bits[0] >> 3) & 0x3F;
+
+  /* Set the first char of padding to 0x80.  This is safe since there is
+     always at least one byte free */
+  p = ctx->in + count;
+  *p++ = 0x80;
+
+  /* Bytes of padding needed to make 64 bytes */
+  count = 64 - 1 - count;
+
+  /* Pad out to 56 mod 64 */
+  if (count < 8)
+  {
+    /* Two lots of padding:  Pad the first block to 64 bytes */
+    memset(p, 0, count);
+    byteReverse(ctx->in, 16);
+    MD5Transform(ctx->buf, (uint32 *) ctx->in);
+
+    /* Now fill the next block with 56 bytes */
+    memset(ctx->in, 0, 56);
+  }
+  else
+  {
+    /* Pad block to 56 bytes */
+    memset(p, 0, count - 8);
+  }
+  byteReverse(ctx->in, 14);
+
+  /* Append length in bits and transform */
+  ((uint32 *) ctx->in)[14] = ctx->bits[0];
+  ((uint32 *) ctx->in)[15] = ctx->bits[1];
+
+  MD5Transform(ctx->buf, (uint32 *) ctx->in);
+  byteReverse((unsigned char *) ctx->buf, 4);
+  memcpy(digest, ctx->buf, 16);
+  memset((char *) ctx, 0, sizeof(ctx));	/* In case it's sensitive */
+}
+
+#ifndef ASM_MD5
+
+/* The four core functions - F1 is optimized somewhat */
+
+/* #define F1(x, y, z) (x & y | ~x & z) */
+#define F1(x, y, z) (z ^ (x & (y ^ z)))
+#define F2(x, y, z) F1(z, x, y)
+#define F3(x, y, z) (x ^ y ^ z)
+#define F4(x, y, z) (y ^ (x | ~z))
+
+/* This is the central step in the MD5 algorithm. */
+#define MD5STEP(f, w, x, y, z, data, s) \
+	( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
+
+/*
+ * The core of the MD5 algorithm, this alters an existing MD5 hash to
+ * reflect the addition of 16 longwords of new data.  MD5Update blocks
+ * the data and converts bytes into longwords for this routine.
+ */
+void
+MD5Transform(uint32 buf[4], uint32 const in[16])
+{
+  register uint32 a, b, c, d;
+
+  a = buf[0];
+  b = buf[1];
+  c = buf[2];
+  d = buf[3];
+
+  MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
+  MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
+  MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
+  MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
+  MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
+  MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
+  MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
+  MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
+  MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
+  MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
+  MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
+  MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
+  MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
+  MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
+  MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
+  MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
+
+  MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
+  MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
+  MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
+  MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
+  MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
+  MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
+  MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
+  MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
+  MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
+  MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
+  MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
+  MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
+  MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
+  MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
+  MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
+  MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
+
+  MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
+  MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
+  MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
+  MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
+  MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
+  MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
+  MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
+  MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
+  MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
+  MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
+  MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
+  MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
+  MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
+  MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
+  MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
+  MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
+
+  MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
+  MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
+  MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
+  MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
+  MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
+  MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
+  MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
+  MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
+  MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
+  MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
+  MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
+  MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
+  MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
+  MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
+  MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
+  MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
+
+  buf[0] += a;
+  buf[1] += b;
+  buf[2] += c;
+  buf[3] += d;
+}
+
+#endif
+}
diff --git a/0.8/src/contrib/crypt/md5.h b/0.8/src/contrib/crypt/md5.h
new file mode 100644
index 0000000..9ac8a49
--- /dev/null
+++ b/0.8/src/contrib/crypt/md5.h
@@ -0,0 +1,59 @@
+/*:*
+ *: File: ./src/contrib/crypt/md5.h
+ *: 
+ *: yChat; Homepage: ychat.buetow.org; Version 0.9.0-CURRENT
+ *: 
+ *: Copyright (C) 2003 Paul C. Buetow, Volker Richter
+ *: Copyright (C) 2004 Paul C. Buetow
+ *: Copyright (C) 2005 EXA Digital Solutions GbR
+ *: Copyright (C) 2006, 2007 Paul C. Buetow
+ *: 
+ *: This program is free software; you can redistribute it and/or
+ *: modify it under the terms of the GNU General Public License
+ *: as published by the Free Software Foundation; either version 2
+ *: of the License, or (at your option) any later version.
+ *: 
+ *: This program is distributed in the hope that it will be useful,
+ *: but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *: GNU General Public License for more details.
+ *: 
+ *: You should have received a copy of the GNU General Public License
+ *: along with this program; if not, write to the Free Software
+ *: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *:*/
+
+#ifndef MD5_H
+#define MD5_H
+
+namespace md5
+{
+#ifdef __alpha
+typedef unsigned int uint32;
+#else
+
+typedef unsigned long uint32;
+#endif
+
+struct MD5Context
+{
+  uint32 buf[4];
+  uint32 bits[2];
+  unsigned char in[64];
+};
+
+void MD5Init(struct MD5Context *context);
+void MD5Update(struct MD5Context *context, unsigned char const *buf,
+               unsigned len);
+void MD5Final(unsigned char digest[16], struct MD5Context *context);
+void MD5Transform(uint32 buf[4], uint32 const in[16]);
+
+
+char *
+MD5Crypt(const char *pw, const char *salt);
+/*
+ * This is needed to make RSAREF happy on some MS-DOS compilers.
+ */
+typedef struct MD5Context MD5_CTX;
+}
+#endif /* !MD5_H */
diff --git a/0.8/src/contrib/crypt/md5crypt.cpp b/0.8/src/contrib/crypt/md5crypt.cpp
new file mode 100644
index 0000000..1e30c88
--- /dev/null
+++ b/0.8/src/contrib/crypt/md5crypt.cpp
@@ -0,0 +1,187 @@
+/*:*
+ *: File: ./src/contrib/crypt/md5crypt.cpp
+ *: 
+ *: yChat; Homepage: ychat.buetow.org; Version 0.9.0-CURRENT
+ *: 
+ *: Copyright (C) 2003 Paul C. Buetow, Volker Richter
+ *: Copyright (C) 2004 Paul C. Buetow
+ *: Copyright (C) 2005 EXA Digital Solutions GbR
+ *: Copyright (C) 2006, 2007 Paul C. Buetow
+ *: 
+ *: This program is free software; you can redistribute it and/or
+ *: modify it under the terms of the GNU General Public License
+ *: as published by the Free Software Foundation; either version 2
+ *: of the License, or (at your option) any later version.
+ *: 
+ *: This program is distributed in the hope that it will be useful,
+ *: but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *: GNU General Public License for more details.
+ *: 
+ *: You should have received a copy of the GNU General Public License
+ *: along with this program; if not, write to the Free Software
+ *: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *:*/
+
+/*
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <phk@login.dknet.dk> wrote this file.  As long as you retain this notice you
+ * can do whatever you want with this stuff. If we meet some day, and you think
+ * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
+ * ----------------------------------------------------------------------------
+ */
+
+/*
+ * Ported from FreeBSD to Linux, only minimal changes.  --marekm
+ */
+
+#include <unistd.h>
+/* #include <stdio.h> */
+#include <string.h>
+#include "md5.h"
+
+namespace md5
+{
+
+static unsigned char itoa64[] =		/* 0 ... 63 => ascii - 64 */
+  "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+static void
+to64(char *s, unsigned long v, int n)
+{
+  while (--n >= 0)
+  {
+    *s++ = itoa64[v&0x3f];
+    v >>= 6;
+  }
+}
+
+/*
+ * UNIX password
+ *
+ * Use MD5 for what it is best at...
+ */
+
+char *
+MD5Crypt(const char *pw, const char *salt)
+{
+  static const char *magic = "$1$";	/*
+                          						 * This string is magic for
+                          						 * this algorithm.  Having
+                          						 * it this way, we can get
+                          						 * get better later on
+                          						 */
+  static char     passwd[120], *p;
+  static const char *sp,*ep;
+  unsigned char	final[16];
+  int sl,pl,i,j;
+  MD5_CTX	ctx,ctx1;
+  unsigned long l;
+
+  /* Refine the Salt first */
+  sp = salt;
+
+  /* If it starts with the magic string, then skip that */
+  if (!strncmp(sp,magic,strlen(magic)))
+    sp += strlen(magic);
+
+  /* It stops at the first '$', max 8 chars */
+  for (ep=sp;*ep && *ep != '$' && ep < (sp+8);ep++)
+    continue;
+
+  /* get the length of the true salt */
+  sl = ep - sp;
+
+  MD5Init(&ctx);
+
+  /* The password first, since that is what is most unknown */
+  MD5Update(&ctx,(const unsigned char*)pw,strlen(pw));
+
+  /* Then our magic string */
+  MD5Update(&ctx,(const unsigned char*)magic,strlen(magic));
+
+  /* Then the raw salt */
+  MD5Update(&ctx,(const unsigned char*)sp,sl);
+
+  /* Then just as many characters of the MD5(pw,salt,pw) */
+  MD5Init(&ctx1);
+  MD5Update(&ctx1,(const unsigned char*)pw,strlen(pw));
+  MD5Update(&ctx1,(const unsigned char*)sp,sl);
+  MD5Update(&ctx1,(const unsigned char*)pw,strlen(pw));
+  MD5Final(final,&ctx1);
+  for (pl = strlen(pw); pl > 0; pl -= 16)
+    MD5Update(&ctx,final,pl>16 ? 16 : pl);
+
+  /* Don't leave anything around in vm they could use. */
+  memset(final,0,sizeof final);
+
+  /* Then something really weird... */
+  for (j=0,i = strlen(pw); i ; i >>= 1)
+    if (i&1)
+      MD5Update(&ctx, final+j, 1);
+    else
+      MD5Update(&ctx, (const unsigned char*)pw+j, 1);
+
+  /* Now make the output string */
+  strcpy(passwd,magic);
+  strncat(passwd,sp,sl);
+  strcat(passwd,"$");
+
+  MD5Final(final,&ctx);
+
+  /*
+   * and now, just to make sure things don't run too fast
+   * On a 60 Mhz Pentium this takes 34 msec, so you would
+   * need 30 seconds to build a 1000 entry dictionary...
+   */
+  for (i=0;i<1000;i++)
+  {
+    MD5Init(&ctx1);
+    if (i & 1)
+      MD5Update(&ctx1,(const unsigned char*)pw,strlen(pw));
+    else
+      MD5Update(&ctx1,final,16);
+
+    if (i % 3)
+      MD5Update(&ctx1,(const unsigned char*)sp,sl);
+
+    if (i % 7)
+      MD5Update(&ctx1,(const unsigned char*)pw,strlen(pw));
+
+    if (i & 1)
+      MD5Update(&ctx1,final,16);
+    else
+      MD5Update(&ctx1,(const unsigned char*)pw,strlen(pw));
+    MD5Final(final,&ctx1);
+  }
+
+  p = passwd + strlen(passwd);
+
+  l = (final[ 0]<<16) | (final[ 6]<<8) | final[12];
+  to64(p,l,4);
+  p += 4;
+  l = (final[ 1]<<16) | (final[ 7]<<8) | final[13];
+  to64(p,l,4);
+  p += 4;
+  l = (final[ 2]<<16) | (final[ 8]<<8) | final[14];
+  to64(p,l,4);
+  p += 4;
+  l = (final[ 3]<<16) | (final[ 9]<<8) | final[15];
+  to64(p,l,4);
+  p += 4;
+  l = (final[ 4]<<16) | (final[10]<<8) | final[ 5];
+  to64(p,l,4);
+  p += 4;
+  l =                    final[11]                ;
+  to64(p,l,2);
+  p += 2;
+  *p = '\0';
+
+  /* Don't leave anything around in vm they could use. */
+  memset(final,0,sizeof final);
+
+  return passwd;
+}
+
+}
diff --git a/0.8/src/contrib/xml/README b/0.8/src/contrib/xml/README
new file mode 100644
index 0000000..c03aaad
--- /dev/null
+++ b/0.8/src/contrib/xml/README
@@ -0,0 +1,504 @@
+ATTENTION:
+
+This version of TinyXML has ben very little modified by 
+Paul C. Buetow in 2004 to fit the yChat project.
+
+To get the original source go to 
+http://www.sourceforge.net/projects/tinyxml
+
+/** @mainpage
+
+<h1> TinyXml </h1>
+
+TinyXml is a simple, small, C++ XML parser that can be easily 
+integrating into other programs.
+
+
+<h2> What it does. </h2>
+	
+In brief, TinyXml parses an XML document, and builds from that a 
+Document Object Model (DOM) that can be read, modified, and saved.
+
+XML stands for "eXtensible Markup Language." It allows you to create 
+your own document markups. Where HTML does a very good job of marking 
+documents for browsers, XML allows you to define any kind of document 
+markup, for example a document that describes a "to do" list for an 
+organizer application. XML is a very structured and convenient format.
+All those random file formats created to store application data can 
+all be replaced with XML. One parser for everything.
+
+The best place for the complete, correct, and quite frankly hard to
+read spec is at <a href="http://www.w3.org/TR/2004/REC-xml-20040204/">
+http://www.w3.org/TR/2004/REC-xml-20040204/</a>. An intro to XML
+(that I really like) can be found at 
+<a href="http://skew.org/xml/tutorial/">http://skew.org/xml/tutorial</a>.
+
+There are different ways to access and interact with XML data.
+TinyXml uses a Document Object Model (DOM), meaning the XML data is parsed
+into a C++ objects that can be browsed and manipulated, and then 
+written to disk or another output stream. You can also construct an XML document from
+scratch with C++ objects and write this to disk or another output
+stream.
+
+TinyXml is designed to be easy and fast to learn. It is two headers 
+and four cpp files. Simply add these to your project and off you go. 
+There is an example file - xmltest.cpp - to get you started. 
+
+TinyXml is released under the ZLib license, 
+so you can use it in open source or commercial code. The details
+of the license are at the top of every source file.
+
+TinyXml attempts to be a flexible parser, but with truly correct and
+compliant XML output. TinyXml should compile on any reasonably C++
+compliant system. It does not rely on exceptions or RTTI. It can be 
+compiled with or without STL support. TinyXml fully supports
+the UTF-8 encoding, and the first 64k character entities.
+
+
+<h2> What it doesn't do. </h2>
+
+It doesnt parse or use DTDs (Document Type Definitions) or XSLs
+(eXtensible Stylesheet Language.) There are other parsers out there 
+(check out www.sourceforge.org, search for XML) that are much more fully
+featured. But they are also much bigger, take longer to set up in
+your project, have a higher learning curve, and often have a more
+restrictive license. If you are working with browsers or have more
+complete XML needs, TinyXml is not the parser for you.
+
+The following DTD syntax will not parse at this time in TinyXml:
+
+@verbatim
+	<!DOCTYPE Archiv [
+	 <!ELEMENT Comment (#PCDATA)>
+	]>
+@endverbatim
+
+because TinyXml sees this as a !DOCTYPE node with an illegally 
+embedded !ELEMENT node. This may be addressed in the future.
+
+<h2> Code Status.  </h2>
+
+TinyXml is mature, tested code. It is very stable. If you find
+bugs, please file a bug report is on the sourceforge web site
+(www.sourceforge.net/projects/tinyxml).
+We'll get them straightened out as soon as possible.
+
+There are some areas of improvement; please check sourceforge if you are
+interested in working on TinyXml.
+
+
+<h2> Features </h2>
+
+<h3> Using STL </h3>
+
+TinyXml can be compiled to use or not use STL. When using STL, TinyXml
+uses the std::string class, and fully supports std::istream, std::ostream,
+operator<<, and operator>>. Many API methods have both 'const char*' and
+'const std::string&' forms.
+
+When STL support is compiled out, no STL files are included whatsover. All
+the string classes are implemented by TinyXml itself. API methods
+all use the 'const char*' form for input.
+
+Use the compile time #define:
+
+	TIXML_USE_STL
+
+to compile one version or the other. This can be passed by the compiler,
+or set as the first line of "tinyxml.h".
+
+Note: If compiling the test code in Linux, setting the environment
+variable TINYXML_USE_STL=YES/NO will control STL compilation. In the
+Windows project file, STL and non STL targets are provided. In your project,
+its probably easiest to add the line "#define TIXML_USE_STL" as the first
+line of tinyxml.h.
+
+<h3> UTF-8 </h3>
+
+TinyXml supports UTF-8 allowing to manipulate XML files in any language. TinyXml
+also supports "legacy mode" - the encoding used before UTF-8 support and
+probably best described as "extended ascii".
+
+Normally, TinyXml will try to detect the correct encoding and use it. However,
+by setting the value of TIXML_DEFAULT_ENCODING in the header file, TinyXml
+can be forced to always use one encoding.
+
+TinyXml will assume Legacy Mode until one of the following occurs:
+<ol>
+	<li> If the non-standard but common "UTF-8 lead bytes" (0xef 0xbb 0xbf)
+		 begin the file or data stream, TinyXml will read it as UTF-8. </li>
+	<li> If the declaration tag is read, and it has an encoding="UTF-8", then
+		 TinyXml will read it as UTF-8. </li>
+	<li> If the declaration tag is read, and it has no encoding specified, then
+		 TinyXml will read it as UTF-8. </li>
+	<li> If the declaration tag is read, and it has an encoding="something else", then
+		 TinyXml will read it as Legacy Mode. In legacy mode, TinyXml will 
+		 work as it did before. It's not clear what that mode does exactly, but 
+		 old content should keep working.</li>
+	<li> Until one of the above criteria is met, TinyXml runs in Legacy Mode.</li>
+</ol>
+
+What happens if the encoding is incorrectly set or detected? TinyXml will try
+to read and pass through text seen as improperly encoded. You may get some strange
+results or mangled characters. You may want to force TinyXml to the correct mode.
+
+<b> You may force TinyXml to Legacy Mode by using LoadFile( TIXML_ENCODING_LEGACY ) or
+LoadFile( filename, TIXML_ENCODING_LEGACY ). You may force it to use legacy mode all
+the time by setting TIXML_DEFAULT_ENCODING = TIXML_ENCODING_LEGACY. Likewise, you may 
+force it to TIXML_ENCODING_UTF8 with the same technique.</b>
+
+For English users, using English XML, UTF-8 is the same as low-ASCII. You
+don't need to be aware of UTF-8 or change your code in any way. You can think
+of UTF-8 as a "superset" of ASCII.
+
+UTF-8 is not a double byte format - but it is a standard encoding of Unicode!
+TinyXml does not use or directly support wchar, TCHAR, or Microsofts _UNICODE at this time. 
+It is common to see the term "Unicode" improperly refer to UTF-16, a wide byte encoding
+of unicode. This is a source of confusion.
+
+For "high-ascii" languages - everything not English, pretty much - TinyXml can
+handle all languages, at the same time, as long as the XML is encoded
+in UTF-8. That can be a little tricky, older programs and operating systems
+tend to use the "default" or "traditional" code page. Many apps (and almost all
+modern ones) can output UTF-8, but older or stubborn (or just broken) ones
+still output text in the default code page. 
+
+For example, Japanese systems traditionally use SHIFT-JIS encoding. 
+Text encoded as SHIFT-JIS can not be read by tinyxml. 
+A good text editor can import SHIFT-JIS and then save as UTF-8.
+
+The <a href="http://skew.org/xml/tutorial/">Skew.org link</a> does a great
+job covering the encoding issue.
+
+The test file "utf8test.xml" is an XML containing English, Spanish, Russian,
+and Simplified Chinese. (Hopefully they are translated correctly). The file
+"utf8test.gif" is a screen capture of the XML file, rendered in IE. Note that
+if you don't have the correct fonts (Simplified Chinese or Russian) on your
+system, you won't see output that matches the GIF file even if you can parse
+it correctly. Also note that (at least on my Windows machine) console output
+is in a Western code page, so that Print() or printf() cannot correctly display
+the file. This is not a bug in TinyXml - just an OS issue. No data is lost or 
+destroyed by TinyXml. The console just doesn't render UTF-8.
+
+
+<h3> Entities </h3>
+TinyXml recognizes the pre-defined "character entities", meaning special
+characters. Namely:
+
+@verbatim
+	&amp;	&
+	&lt;	<
+	&gt;	>
+	&quot;	"
+	&apos;	'
+@endverbatim
+
+These are recognized when the XML document is read, and translated to there
+UTF-8 equivalents. For instance, text with the XML of:
+
+@verbatim
+	Far &amp; Away
+@endverbatim
+
+will have the Value() of "Far & Away" when queried from the TiXmlText object,
+and will be written back to the XML stream/file as an ampersand. Older versions
+of TinyXml "preserved" character entities, but the newer versions will translate
+them into characters.
+
+Additionally, any character can be specified by its Unicode code point:
+The syntax "&#xA0;" or "&#160;" are both to the non-breaking space characher.
+
+
+<h3> Streams </h3>
+With TIXML_USE_STL on,
+TiXml has been modified to support both C (FILE) and C++ (operator <<,>>) 
+streams. There are some differences that you may need to be aware of.
+
+C style output:
+	- based on FILE*
+	- the Print() and SaveFile() methods
+
+	Generates formatted output, with plenty of white space, intended to be as 
+	human-readable as possible. They are very fast, and tolerant of ill formed 
+	XML documents. For example, an XML document that contains 2 root elements 
+	and 2 declarations, will still print.
+
+C style input:
+	- based on FILE*
+	- the Parse() and LoadFile() methods
+
+	A fast, tolerant read. Use whenever you don't need the C++ streams.
+
+C++ style ouput:
+	- based on std::ostream
+	- operator<<
+
+	Generates condensed output, intended for network transmission rather than
+	readability. Depending on your system's implementation of the ostream class,
+	these may be somewhat slower. (Or may not.) Not tolerant of ill formed XML:
+	a document should contain the correct one root element. Additional root level
+	elements will not be streamed out.
+
+C++ style input:
+	- based on std::istream
+	- operator>>
+
+	Reads XML from a stream, making it useful for network transmission. The tricky
+	part is knowing when the XML document is complete, since there will almost
+	certainly be other data in the stream. TinyXml will assume the XML data is
+	complete after it reads the root element. Put another way, documents that
+	are ill-constructed with more than one root element will not read correctly.
+	Also note that operator>> is somewhat slower than Parse, due to both 
+	implementation of the STL and limitations of TinyXml.
+
+<h3> White space </h3>
+The world simply does not agree on whether white space should be kept, or condensed.
+For example, pretend the '_' is a space, and look at "Hello____world". HTML, and 
+at least some XML parsers, will interpret this as "Hello_world". They condense white
+space. Some XML parsers do not, and will leave it as "Hello____world". (Remember
+to keep pretending the _ is a space.) Others suggest that __Hello___world__ should become
+Hello___world.
+
+It's an issue that hasn't been resolved to my satisfaction. TinyXml supports the
+first 2 approaches. Call TiXmlBase::SetCondenseWhiteSpace( bool ) to set the desired behavior.
+The default is to condense white space.
+
+If you change the default, you should call TiXmlBase::SetCondenseWhiteSpace( bool )
+before making any calls to Parse XML data, and I don't recommend changing it after
+it has been set.
+
+
+<h3> Handles </h3>
+
+Where browsing an XML document in a robust way, it is important to check
+for null returns from method calls. An error safe implementation can
+generate a lot of code 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
+
+Handles have been introduced to clean this up. Using the TiXmlHandle class,
+the previous code reduces to:
+
+@verbatim
+TiXmlHandle docHandle( &document );
+TiXmlElement* child2 = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).Child( "Child", 1 ).Element();
+if ( child2 )
+{
+	// do something useful
+@endverbatim
+
+Which is much easier to deal with. See TiXmlHandle for more information.
+
+
+<h3> Row and Column tracking </h3>
+Being able to track nodes and attributes back to their origin location
+in source files can be very important for some applications. Additionally,
+knowing where parsing errors occured in the original source can be very
+time saving.
+
+TinyXml can tracks the row and column origin of all nodes and attributes
+in a text file. The TiXmlBase::Row() and TiXmlBase::Column() methods return
+the origin of the node in the source text. The correct tabs can be 
+configured in TiXmlDocument::SetTabSize().
+
+
+<h2> Using and Installing </h2>
+
+To Compile and Run xmltest:
+
+A Linux Makefile and a Windows Visual C++ .dsw file is provided. 
+Simply compile and run. It will write the file demotest.xml to your 
+disk and generate output on the screen. It also tests walking the
+DOM by printing out the number of nodes found using different 
+techniques.
+
+The Linux makefile is very generic and will
+probably run on other systems, but is only tested on Linux. You no
+longer need to run 'make depend'. The dependecies have been
+hard coded.
+
+<h3>Windows project file for VC6</h3>
+<ul>
+<li>tinyxml:		tinyxml library, non-STL </li>
+<li>tinyxmlSTL:		tinyxml library, STL </li>
+<li>tinyXmlTest:	test app, non-STL </li>
+<li>tinyXmlTestSTL: test app, STL </li>
+</ul>
+
+<h3>Linux Make file</h3>
+At the top of the makefile you can set:
+
+PROFILE, DEBUG, and TINYXML_USE_STL. Details (such that they are) are in
+the makefile.
+
+In the tinyxml directory, type "make clean" then "make". The executable
+file 'xmltest' will be created.
+
+
+
+<h3>To Use in an Application:</h3>
+
+Add tinyxml.cpp, tinyxml.h, tinyxmlerror.cpp, tinyxmlparser.cpp, and tinystr.cpp to your
+project or make file. That's it! It should compile on any reasonably
+compliant C++ system. You do not need to enable exceptions or
+RTTI for TinyXml.
+
+
+<h2> How TinyXml works.  </h2>
+
+An example is probably the best way to go. Take:
+@verbatim
+	<?xml version="1.0" standalone=no>
+	<!-- Our to do list data -->
+	<ToDo>
+		<Item priority="1"> Go to the <bold>Toy store!</bold></Item>
+		<Item priority="2"> Do bills</Item>
+	</ToDo>
+@endverbatim
+
+Its not much of a To Do list, but it will do. To read this file 
+(say "demo.xml") you would create a document, and parse it in:
+@verbatim
+	TiXmlDocument doc( "demo.xml" );
+	doc.LoadFile();
+@endverbatim
+
+And its ready to go. Now lets look at some lines and how they 
+relate to the DOM.
+
+@verbatim
+<?xml version="1.0" standalone=no>
+@endverbatim
+
+	The first line is a declaration, and gets turned into the
+	TiXmlDeclaration class. It will be the first child of the
+	document node.
+	
+	This is the only directive/special tag parsed by by TinyXml.
+	Generally directive targs are stored in TiXmlUnknown so the 
+	commands wont be lost when it is saved back to disk.
+
+@verbatim
+<!-- Our to do list data -->
+@endverbatim
+
+	A comment. Will become a TiXmlComment object.
+
+@verbatim
+<ToDo>
+@endverbatim
+
+	The "ToDo" tag defines a TiXmlElement object. This one does not have 
+	any attributes, but does contain 2 other elements.
+
+@verbatim
+<Item priority="1"> 
+@endverbatim
+
+	Creates another TiXmlElement which is a child of the "ToDo" element. 
+	This element has 1 attribute, with the name "priority" and the value 
+	"1".
+
+Go to the 
+
+	A TiXmlText. This is a leaf node and cannot contain other nodes. 
+	It is a child of the "Item" TiXmlElement.
+
+@verbatim
+<bold>
+@endverbatim
+
+	
+	Another TiXmlElement, this one a child of the "Item" element.
+
+Etc.
+
+Looking at the entire object tree, you end up with:
+@verbatim
+TiXmlDocument				"demo.xml"
+	TiXmlDeclaration		"version='1.0'" "standalone=no"
+	TiXmlComment			" Our to do list data"
+	TiXmlElement			"ToDo"
+		TiXmlElement		"Item"		Attribtutes: priority = 1
+			TiXmlText		"Go to the "
+			TiXmlElement    "bold"
+				TiXmlText	"Toy store!"
+	TiXmlElement			"Item"		Attributes: priority=2
+		TiXmlText			"bills"
+@endverbatim
+
+<h2> Documentation </h2>
+
+The documentation is build with Doxygen, using the 'dox' 
+configuration file.
+
+<h2> License </h2>
+
+TinyXml is released under the zlib license:
+
+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.
+
+<h2> References  </h2>
+
+The World Wide Web Consortium is the definitive standard body for 
+XML, and there web pages contain huge amounts of information. 
+
+The definitive spec: <a href="http://www.w3.org/TR/2004/REC-xml-20040204/">
+http://www.w3.org/TR/2004/REC-xml-20040204/</a>
+
+I also recommend "XML Pocket Reference" by Robert Eckstein and published by 
+OReilly...the book that got the whole thing started.
+
+<h2> Contributors, Contacts, and a Brief History </h2>
+
+Thanks very much to everyone who sends suggestions, bugs, ideas, and 
+encouragement. It all helps, and makes this project fun. A special thanks
+to the contributors on the web pages that keep it lively.
+
+So many people have sent in bugs and ideas, that rather than list here 
+we try to give credit due in the "changes.txt" file.
+
+TinyXml was originally written be Lee Thomason. (Often the "I" still
+in the documenation.) Lee reviews changes and releases new versions,
+with the help of Yves Berquin and the tinyXml community.
+
+We appreciate your suggestions, and would love to know if you 
+use TinyXml. Hopefully you will enjoy it and find it useful. 
+Please post questions, comments, file bugs, or contact us at:
+
+www.sourceforge.net/projects/tinyxml
+
+Lee Thomason,
+Yves Berquin
+*/
diff --git a/0.8/src/contrib/xml/tinyxml.cpp b/0.8/src/contrib/xml/tinyxml.cpp
new file mode 100644
index 0000000..727fe87
--- /dev/null
+++ b/0.8/src/contrib/xml/tinyxml.cpp
@@ -0,0 +1,1453 @@
+/*:*
+ *: File: ./src/contrib/xml/tinyxml.cpp
+ *: 
+ *: yChat; Homepage: ychat.buetow.org; Version 0.9.0-CURRENT
+ *: 
+ *: Copyright (C) 2003 Paul C. Buetow, Volker Richter
+ *: Copyright (C) 2004 Paul C. Buetow
+ *: Copyright (C) 2005 EXA Digital Solutions GbR
+ *: Copyright (C) 2006, 2007 Paul C. Buetow
+ *: 
+ *: This program is free software; you can redistribute it and/or
+ *: modify it under the terms of the GNU General Public License
+ *: as published by the Free Software Foundation; either version 2
+ *: of the License, or (at your option) any later version.
+ *: 
+ *: This program is distributed in the hope that it will be useful,
+ *: but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *: GNU General Public License for more details.
+ *: 
+ *: You should have received a copy of the GNU General Public License
+ *: along with this program; if not, write to the Free Software
+ *: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *:*/
+
+/*
+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>
+#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 ];
+      sprintf( buf, "&#x%02X;", (unsigned) ( c & 0xff ) );
+      outString->append( buf, 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 )
+{
+  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;
+}
+
+TiXmlNode* TiXmlNode::FirstChild( const char * _value ) const
+{
+  TiXmlNode* node;
+  for ( node = firstChild; node; node = node->next )
+  {
+    if ( node->SValue() == TIXML_STRING( _value ))
+      return node;
+  }
+  return 0;
+}
+
+TiXmlNode* TiXmlNode::LastChild( const char * _value ) const
+{
+  TiXmlNode* node;
+  for ( node = lastChild; node; node = node->prev )
+  {
+    if ( node->SValue() == TIXML_STRING (_value))
+      return node;
+  }
+  return 0;
+}
+
+TiXmlNode* TiXmlNode::IterateChildren( TiXmlNode* previous ) const
+{
+  if ( !previous )
+  {
+    return FirstChild();
+  }
+  else
+  {
+    assert( previous->parent == this );
+    return previous->NextSibling();
+  }
+}
+
+TiXmlNode* TiXmlNode::IterateChildren( const char * val, TiXmlNode* previous ) const
+{
+  if ( !previous )
+  {
+    return FirstChild( val );
+  }
+  else
+  {
+    assert( previous->parent == this );
+    return previous->NextSibling( val );
+  }
+}
+
+TiXmlNode* TiXmlNode::NextSibling( const char * _value ) const
+{
+  TiXmlNode* node;
+  for ( node = next; node; node = node->next )
+  {
+    if ( node->SValue() == TIXML_STRING (_value))
+      return node;
+  }
+  return 0;
+}
+
+
+TiXmlNode* TiXmlNode::PreviousSibling( const char * _value ) const
+{
+  TiXmlNode* node;
+  for ( node = prev; node; node = node->prev )
+  {
+    if ( node->SValue() == TIXML_STRING (_value))
+      return node;
+  }
+  return 0;
+}
+
+void TiXmlElement::RemoveAttribute( const char * name )
+{
+  TiXmlAttribute* node = attributeSet.Find( name );
+  if ( node )
+  {
+    attributeSet.Remove( node );
+    delete node;
+  }
+}
+
+TiXmlElement* TiXmlNode::FirstChildElement() const
+{
+  TiXmlNode* node;
+
+  for (	node = FirstChild();
+        node;
+        node = node->NextSibling() )
+  {
+    if ( node->ToElement() )
+      return node->ToElement();
+  }
+  return 0;
+}
+
+TiXmlElement* TiXmlNode::FirstChildElement( const char * _value ) const
+{
+  TiXmlNode* node;
+
+  for (	node = FirstChild( _value );
+        node;
+        node = node->NextSibling( _value ) )
+  {
+    if ( node->ToElement() )
+      return node->ToElement();
+  }
+  return 0;
+}
+
+
+TiXmlElement* TiXmlNode::NextSiblingElement() const
+{
+  TiXmlNode* node;
+
+  for (	node = NextSibling();
+        node;
+        node = node->NextSibling() )
+  {
+    if ( node->ToElement() )
+      return node->ToElement();
+  }
+  return 0;
+}
+
+TiXmlElement* TiXmlNode::NextSiblingElement( const char * _value ) const
+{
+  TiXmlNode* node;
+
+  for (	node = NextSibling( _value );
+        node;
+        node = node->NextSibling( _value ) )
+  {
+    if ( node->ToElement() )
+      return node->ToElement();
+  }
+  return 0;
+}
+
+
+
+TiXmlDocument* TiXmlNode::GetDocument() const
+{
+  const 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
+{
+  TiXmlAttribute* node = attributeSet.Find( name );
+
+  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
+{
+  TiXmlAttribute* node = attributeSet.Find( name );
+  if ( !node )
+    return TIXML_NO_ATTRIBUTE;
+
+  return node->QueryIntValue( ival );
+}
+
+
+int TiXmlElement::QueryDoubleAttribute( const char* name, double* dval ) const
+{
+  TiXmlAttribute* node = attributeSet.Find( name );
+  if ( !node )
+    return TIXML_NO_ATTRIBUTE;
+
+  return node->QueryDoubleValue( dval );
+}
+
+
+void TiXmlElement::SetAttribute( const char * name, int val )
+{
+  char buf[64];
+  sprintf( buf, "%d", val );
+  SetAttribute( name, buf );
+}
+
+
+void TiXmlElement::SetDoubleAttribute( const char * name, double val )
+{
+  char buf[128];
+  sprintf( buf, "%f", val );
+  SetAttribute( name, buf );
+}
+
+
+void TiXmlElement::SetAttribute( const char * name, const char * _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 );
+  }
+}
+
+void TiXmlElement::Print( FILE* cfile, int depth ) const
+{
+  int i;
+  for ( i=0; i<depth; i++ )
+  {
+    fprintf( cfile, "    " );
+  }
+
+  fprintf( cfile, "<%s", value.c_str() );
+
+  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;
+
+  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.
+  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;
+}
+
+
+TiXmlDocument::TiXmlDocument() : TiXmlNode( TiXmlNode::DOCUMENT )
+{
+  tabsize = 4;
+  ClearError();
+}
+
+TiXmlDocument::TiXmlDocument( const char * documentName ) : TiXmlNode( TiXmlNode::DOCUMENT )
+{
+  tabsize = 4;
+  value = documentName;
+  ClearError();
+}
+
+
+#ifdef TIXML_USE_STL
+TiXmlDocument::TiXmlDocument( const std::string& documentName ) : TiXmlNode( TiXmlNode::DOCUMENT )
+{
+  tabsize = 4;
+  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 )
+{
+  // Delete the existing data:
+  Clear();
+  location.Clear();
+
+  // 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;
+
+  FILE* file = fopen( value.c_str (), "r" );
+
+  if ( file )
+  {
+    // 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 )
+    {
+      fclose( file );
+      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 );
+
+    const int BUF_SIZE = 2048;
+    char buf[BUF_SIZE];
+
+    while ( fgets( buf, BUF_SIZE, file ) )
+    {
+      data += buf;
+    }
+    fclose( file );
+
+    Parse( data.c_str(), 0, encoding );
+
+    if (  Error() )
+      return false;
+    else
+      return true;
+  }
+  SetError( TIXML_ERROR_OPENING_FILE, 0, 0, TIXML_ENCODING_UNKNOWN );
+  return false;
+}
+
+bool TiXmlDocument::SaveFile( const char * filename ) const
+{
+  // The old c stuff lives on...
+  FILE* fp = fopen( filename, "w" );
+  if ( fp )
+  {
+    Print( fp, 0 );
+    fclose( fp );
+    return true;
+  }
+  return false;
+}
+
+
+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
+{
+  TiXmlNode* node;
+  for ( node=FirstChild(); node; node=node->NextSibling() )
+  {
+    node->Print( cfile, depth );
+    fprintf( cfile, "\n" );
+  }
+}
+
+void TiXmlDocument::StreamOut( TIXML_OSTREAM * out ) 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;
+  }
+}
+
+
+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::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;
+}
+
+
+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];
+  sprintf (buf, "%d", _value);
+  SetValue (buf);
+}
+
+void TiXmlAttribute::SetDoubleValue( double _value )
+{
+  char buf [64];
+  sprintf (buf, "%lf", _value);
+  SetValue (buf);
+}
+
+const int TiXmlAttribute::IntValue() const
+{
+  return atoi (value.c_str ());
+}
+
+const 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, "<!--%s-->", value.c_str() );
+}
+
+void TiXmlComment::StreamOut( TIXML_OSTREAM * stream ) const
+{
+  (*stream) << "<!--";
+  //PutString( value, stream );
+  (*stream) << value;
+  (*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
+{
+  TIXML_STRING buffer;
+  PutString( value, &buffer );
+  fprintf( cfile, "%s", buffer.c_str() );
+}
+
+
+void TiXmlText::StreamOut( TIXML_OSTREAM * stream ) const
+{
+  PutString( value, stream );
+}
+
+
+void TiXmlText::CopyTo( TiXmlText* target ) const
+{
+  TiXmlNode::CopyTo( target );
+}
+
+
+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( 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.
+}
+
+TiXmlAttribute*	TiXmlAttributeSet::Find( const char * name ) const
+{
+  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/0.8/src/contrib/xml/tinyxml.h b/0.8/src/contrib/xml/tinyxml.h
new file mode 100644
index 0000000..9d0015d
--- /dev/null
+++ b/0.8/src/contrib/xml/tinyxml.h
@@ -0,0 +1,1655 @@
+/*:*
+ *: File: ./src/contrib/xml/tinyxml.h
+ *: 
+ *: yChat; Homepage: ychat.buetow.org; Version 0.9.0-CURRENT
+ *: 
+ *: Copyright (C) 2003 Paul C. Buetow, Volker Richter
+ *: Copyright (C) 2004 Paul C. Buetow
+ *: Copyright (C) 2005 EXA Digital Solutions GbR
+ *: Copyright (C) 2006, 2007 Paul C. Buetow
+ *: 
+ *: This program is free software; you can redistribute it and/or
+ *: modify it under the terms of the GNU General Public License
+ *: as published by the Free Software Foundation; either version 2
+ *: of the License, or (at your option) any later version.
+ *: 
+ *: This program is distributed in the hope that it will be useful,
+ *: but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *: GNU General Public License for more details.
+ *: 
+ *: You should have received a copy of the GNU General Public License
+ *: along with this program; if not, write to the Free Software
+ *: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *:*/
+
+#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
+{
+  friend class TiXmlElement;
+public:
+  /// Constructor.
+  TiXmlText (const char * initValue) : TiXmlNode (TiXmlNode::TEXT)
+  {
+    SetValue( initValue );
+  }
+  virtual ~TiXmlText()
+  {}
+
+#ifdef TIXML_USE_STL
+  /// Constructor.
+  TiXmlText( const std::string& initValue ) : TiXmlNode (TiXmlNode::TEXT)
+  {
+    SetValue( initValue );
+  }
+#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;
+
+  virtual const char* Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding );
+
+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:
+};
+
+
+/** 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 );
+
+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 );
+
+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;
+
+#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.
+  */
+  TiXmlElement* RootElement() const
+  {
+    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.
+  */
+  const 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()
+
+  /** 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 );
+
+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;
+};
+
+
+/**
+	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;
+};
+
+
+#endif
+
diff --git a/0.8/src/contrib/xml/tinyxmlerror.cpp b/0.8/src/contrib/xml/tinyxmlerror.cpp
new file mode 100644
index 0000000..066a9d6
--- /dev/null
+++ b/0.8/src/contrib/xml/tinyxmlerror.cpp
@@ -0,0 +1,76 @@
+/*:*
+ *: File: ./src/contrib/xml/tinyxmlerror.cpp
+ *: 
+ *: yChat; Homepage: ychat.buetow.org; Version 0.9.0-CURRENT
+ *: 
+ *: Copyright (C) 2003 Paul C. Buetow, Volker Richter
+ *: Copyright (C) 2004 Paul C. Buetow
+ *: Copyright (C) 2005 EXA Digital Solutions GbR
+ *: Copyright (C) 2006, 2007 Paul C. Buetow
+ *: 
+ *: This program is free software; you can redistribute it and/or
+ *: modify it under the terms of the GNU General Public License
+ *: as published by the Free Software Foundation; either version 2
+ *: of the License, or (at your option) any later version.
+ *: 
+ *: This program is distributed in the hope that it will be useful,
+ *: but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *: GNU General Public License for more details.
+ *: 
+ *: You should have received a copy of the GNU General Public License
+ *: along with this program; if not, write to the Free Software
+ *: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *:*/
+
+/*
+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
+// latin-1, but at least the error messages 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.",
+};
diff --git a/0.8/src/contrib/xml/tinyxmlparser.cpp b/0.8/src/contrib/xml/tinyxmlparser.cpp
new file mode 100644
index 0000000..510cc0b
--- /dev/null
+++ b/0.8/src/contrib/xml/tinyxmlparser.cpp
@@ -0,0 +1,1581 @@
+/*:*
+ *: File: ./src/contrib/xml/tinyxmlparser.cpp
+ *: 
+ *: yChat; Homepage: ychat.buetow.org; Version 0.9.0-CURRENT
+ *: 
+ *: Copyright (C) 2003 Paul C. Buetow, Volker Richter
+ *: Copyright (C) 2004 Paul C. Buetow
+ *: Copyright (C) 2005 EXA Digital Solutions GbR
+ *: Copyright (C) 2006, 2007 Paul C. Buetow
+ *: 
+ *: This program is free software; you can redistribute it and/or
+ *: modify it under the terms of the GNU General Public License
+ *: as published by the Free Software Foundation; either version 2
+ *: of the License, or (at your option) any later version.
+ *: 
+ *: This program is distributed in the hope that it will be useful,
+ *: but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *: GNU General Public License for more details.
+ *: 
+ *: You should have received a copy of the GNU General Public License
+ *: along with this program; if not, write to the Free Software
+ *: Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *:*/
+
+/*
+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>
+
+//#define DEBUG_PARSER
+
+// 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 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 )
+  {
+    // Code contributed by Fletcher Dunn: (modified by lee)
+    switch (*p)
+    {
+    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 (char)(0xef):
+            if ( encoding == TIXML_ENCODING_UTF8 )
+        {
+          if ( *(p+1) && *(p+2) )
+          {
+            // In these cases, don't advance the column. These are
+            // 0-width spaces.
+            if ( *(p+1)==(char)(0xbb) && *(p+2)==(char)(0xbf) )
+              p += 3;
+            else if ( *(p+1)==(char)(0xbf) && *(p+2)==(char)(0xbe) )
+              p += 3;
+            else if ( *(p+1)==(char)(0xbf) && *(p+2)==(char)(0xbf) )
+              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 )
+    {
+      // Skip the stupid Microsoft UTF-8 Byte order marks
+      if (	*(p+0)==(char) 0xef
+           && *(p+1)==(char) 0xbb
+           && *(p+2)==(char) 0xbf )
+      {
+        p += 3;
+        continue;
+      }
+      else if (*(p+0)==(char) 0xef
+               && *(p+1)==(char) 0xbf
+               && *(p+2)==(char) 0xbe )
+      {
+        p += 3;
+        continue;
+      }
+      else if (*(p+0)==(char) 0xef
+               && *(p+1)==(char) 0xbf
+               && *(p+2)==(char) 0xbf )
+      {
+        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;
+    unsigned 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.
+    if (	*(p+0) && *(p+0) == (char)(0xef)
+         && *(p+1) && *(p+1) == (char)(0xbb)
+         && *(p+2) && *(p+2) == (char)(0xbf) )
+    {
+      encoding = TIXML_ENCODING_UTF8;
+    }
+  }
+
+  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 );
+  }
+
+  // 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 )
+  {
+    //TiXmlParsingData data( pError, prevData );
+    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: <!--
+  // - Decleration: <?xml
+  // - Everthing else is unknown to tinyxml.
+  //
+
+  const char* xmlHeader =
+    { "<?xml"
+    };
+  const char* commentHeader =
+    { "<!--"
+    };
+  const char* dtdHeader =
+    { "<!"
+    };
+
+  if ( StringEqual( p, xmlHeader, true, encoding ) )
+  {
+#ifdef DEBUG_PARSER
+    TIXML_LOG( "XML parsing Declaration\n" );
+#endif
+
+    returnNode = new TiXmlDeclaration();
+  }
+  else if ( StringEqual( p, commentHeader, false, encoding ) )
+  {
+#ifdef DEBUG_PARSER
+    TIXML_LOG( "XML parsing Comment\n" );
+#endif
+
+    returnNode = new TiXmlComment();
+  }
+  else if ( StringEqual( p, dtdHeader, false, encoding ) )
+  {
+#ifdef DEBUG_PARSER
+    TIXML_LOG( "XML parsing Unknown(1)\n" );
+#endif
+
+    returnNode = new TiXmlUnknown();
+  }
+  else if (    IsAlpha( *(p+1), encoding )
+               || *(p+1) == '_' )
+  {
+#ifdef DEBUG_PARSER
+    TIXML_LOG( "XML parsing Element\n" );
+#endif
+
+    returnNode = new TiXmlElement( "" );
+  }
+  else
+  {
+#ifdef DEBUG_PARSER
+    TIXML_LOG( "XML parsing Unknown(2)\n" );
+#endif
+
+    returnNode = new TiXmlUnknown();
+  }
+
+  if ( returnNode )
+  {
+    // Set the parent, so it can report errors
+    returnNode->parent = this;
+  }
+  else
+  {
+    if ( doc )
+      doc->SetError( TIXML_ERROR_OUT_OF_MEMORY, 0, 0, TIXML_ENCODING_UNKNOWN );
+  }
+  return returnNode;
+}
+
+#ifdef TIXML_USE_STL
+
+void TiXmlElement::StreamIn (TIXML_ISTREAM * in, TIXML_STRING * tag)
+{
+  // We're called with some amount of pre-parsing. That is, some of "this"
+  // element is in "tag". Go ahead and stream to the closing ">"
+  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 == '>' )
+      break;
+  }
+
+  if ( tag->length() < 3 )
+    return;
+
+  // Okay...if we are a "/>" tag, then we're done. We've read a complete tag.
+  // If not, identify and stream.
+
+  if (    tag->at( tag->length() - 1 ) == '>'
+          && tag->at( tag->length() - 2 ) == '/' )
+  {
+    // All good!
+    return;
+  }
+  else if ( tag->at( tag->length() - 1 ) == '>' )
+  {
+    // There is more. Could be:
+    //		text
+    //		closing tag
+    //		another node.
+    for ( ;; )
+    {
+      StreamWhiteSpace( in, tag );
+
+      // Do we have text?
+      if ( in->good() && in->peek() != '<' )
+      {
+        // Yep, text.
+        TiXmlText text( "" );
+        text.StreamIn( in, tag );
+
+        // What follows text is a closing tag or another node.
+        // Go around again and figure it out.
+        continue;
+      }
+
+      // We now have either a closing tag...or another node.
+      // We should be at a "<", regardless.
+      if ( !in->good() )
+        return;
+      assert( in->peek() == '<' );
+      int tagIndex = tag->length();
+
+      bool closingTag = false;
+      bool firstCharFound = false;
+
+      for ( ;; )
+      {
+        if ( !in->good() )
+          return;
+
+        int c = in->peek();
+        if ( c <= 0 )
+        {
+          TiXmlDocument* document = GetDocument();
+          if ( document )
+            document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );
+          return;
+        }
+
+        if ( c == '>' )
+          break;
+
+        *tag += (char) c;
+        in->get
+        ();
+
+        if ( !firstCharFound && c != '<' && !IsWhiteSpace( c ) )
+        {
+          firstCharFound = true;
+          if ( c == '/' )
+            closingTag = true;
+        }
+      }
+      // If it was a closing tag, then read in the closing '>' to clean up the input stream.
+      // If it was not, the streaming will be done by the tag.
+      if ( closingTag )
+      {
+        if ( !in->good() )
+          return;
+
+        int c = in->get
+                ();
+        if ( c <= 0 )
+        {
+          TiXmlDocument* document = GetDocument();
+          if ( document )
+            document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );
+          return;
+        }
+        assert( c == '>' );
+        *tag += (char) c;
+
+        // We are done, once we've found our closing tag.
+        return;
+      }
+      else
+      {
+        // If not a closing tag, id it, and stream.
+        const char* tagloc = tag->c_str() + tagIndex;
+        TiXmlNode* node = Identify( tagloc, TIXML_DEFAULT_ENCODING );
+        if ( !node )
+          return;
+        node->StreamIn( in, tag );
+        delete node;
+        node = 0;
+
+        // No return: go around from the beginning: text, closing tag, or node.
+      }
+    }
+  }
+}
+#endif
+
+const char* TiXmlElement::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )
+{
+  p = SkipWhiteSpace( p, encoding );
+  TiXmlDocument* document = GetDocument();
+
+  if ( !p || !*p )
+  {
+    if ( document )
+      document->SetError( TIXML_ERROR_PARSING_ELEMENT, 0, 0, encoding );
+    return 0;
+  }
+
+  //	TiXmlParsingData data( p, prevData );
+  if ( data )
+  {
+    data->Stamp( p, encoding );
+    location = data->Cursor();
+  }
+
+  if ( *p != '<' )
+  {
+    if ( document )
+      document->SetError( TIXML_ERROR_PARSING_ELEMENT, p, data, encoding );
+    return 0;
+  }
+
+  p = SkipWhiteSpace( p+1, encoding );
+
+  // Read the name.
+  const char* pErr = p;
+
+  p = ReadName( p, &value, encoding );
+  if ( !p || !*p )
+  {
+    if ( document )
+      document->SetError( TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME, pErr, data, encoding );
+    return 0;
+  }
+
+  TIXML_STRING endTag ("</");
+  endTag += value;
+  endTag += ">";
+
+  // Check for and read attributes. Also look for an empty
+  // tag or an end tag.
+  while ( p && *p )
+  {
+    pErr = p;
+    p = SkipWhiteSpace( p, encoding );
+    if ( !p || !*p )
+    {
+      if ( document )
+        document->SetError( TIXML_ERROR_READING_ATTRIBUTES, pErr, data, encoding );
+      return 0;
+    }
+    if ( *p == '/' )
+    {
+      ++p;
+      // Empty tag.
+      if ( *p  != '>' )
+      {
+        if ( document )
+          document->SetError( TIXML_ERROR_PARSING_EMPTY, p, data, encoding );
+        return 0;
+      }
+      return (p+1);
+    }
+    else if ( *p == '>' )
+    {
+      // Done with attributes (if there were any.)
+      // Read the value -- which can include other
+      // elements -- read the end tag, and return.
+      ++p;
+      p = ReadValue( p, data, encoding );		// Note this is an Element method, and will set the error if one happens.
+      if ( !p || !*p )
+        return 0;
+
+      // We should find the end tag now
+      if ( StringEqual( p, endTag.c_str(), false, encoding ) )
+      {
+        p += endTag.length();
+        return p;
+      }
+      else
+      {
+        if ( document )
+          document->SetError( TIXML_ERROR_READING_END_TAG, p, data, encoding );
+        return 0;
+      }
+    }
+    else
+    {
+      // Try to read an attribute:
+      TiXmlAttribute* attrib = new TiXmlAttribute();
+      if ( !attrib )
+      {
+        if ( document )
+          document->SetError( TIXML_ERROR_OUT_OF_MEMORY, pErr, data, encoding );
+        return 0;
+      }
+
+      attrib->SetDocument( document );
+      const char* pErr = p;
+      p = attrib->Parse( p, data, encoding );
+
+      if ( !p || !*p )
+      {
+        if ( document )
+          document->SetError( TIXML_ERROR_PARSING_ELEMENT, pErr, data, encoding );
+        delete attrib;
+        return 0;
+      }
+
+      // Handle the strange case of double attributes:
+      TiXmlAttribute* node = attributeSet.Find( attrib->Name() );
+      if ( node )
+      {
+        node->SetValue( attrib->Value() );
+        delete attrib;
+        return 0;
+      }
+
+      attributeSet.Add( attrib );
+    }
+  }
+  return p;
+}
+
+
+const char* TiXmlElement::ReadValue( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )
+{
+  TiXmlDocument* document = GetDocument();
+
+  const char* pWithWhiteSpace = p;
+  // Read in text and elements in any order.
+  p = SkipWhiteSpace( p, encoding );
+  while ( p && *p )
+  {
+    if ( *p != '<' )
+    {
+      // Take what we have, make a text element.
+      TiXmlText* textNode = new TiXmlText( "" );
+
+      if ( !textNode )
+      {
+        if ( document )
+          document->SetError( TIXML_ERROR_OUT_OF_MEMORY, 0, 0, encoding );
+        return 0;
+      }
+
+      if ( TiXmlBase::IsWhiteSpaceCondensed() )
+      {
+        p = textNode->Parse( p, data, encoding );
+      }
+      else
+      {
+        // Special case: we want to keep the white space
+        // so that leading spaces aren't removed.
+        p = textNode->Parse( pWithWhiteSpace, data, encoding );
+      }
+
+      if ( !textNode->Blank() )
+        LinkEndChild( textNode );
+      else
+        delete textNode;
+    }
+    else
+    {
+      // We hit a '<'
+      // Have we hit a new element or an end tag?
+      if ( StringEqual( p, "</", false, encoding ) )
+      {
+        return p;
+      }
+      else
+      {
+        TiXmlNode* node = Identify( p, encoding );
+        if ( node )
+        {
+          p = node->Parse( p, data, encoding );
+          LinkEndChild( node );
+        }
+        else
+        {
+          return 0;
+        }
+      }
+    }
+    p = SkipWhiteSpace( p, encoding );
+  }
+
+  if ( !p )
+  {
+    if ( document )
+      document->SetError( TIXML_ERROR_READING_ELEMENT_VALUE, 0, 0, encoding );
+  }
+  return p;
+}
+
+
+#ifdef TIXML_USE_STL
+void TiXmlUnknown::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* TiXmlUnknown::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )
+{
+  TiXmlDocument* document = GetDocument();
+  p = SkipWhiteSpace( p, encoding );
+
+  //	TiXmlParsingData data( p, prevData );
+  if ( data )
+  {
+    data->Stamp( p, encoding );
+    location = data->Cursor();
+  }
+  if ( !p || !*p || *p != '<' )
+  {
+    if ( document )
+      document->SetError( TIXML_ERROR_PARSING_UNKNOWN, p, data, encoding );
+    return 0;
+  }
+  ++p;
+  value = "";
+
+  while ( p && *p && *p != '>' )
+  {
+    value += *p;
+    ++p;
+  }
+
+  if ( !p )
+  {
+    if ( document )
+      document->SetError( TIXML_ERROR_PARSING_UNKNOWN, 0, 0, encoding );
+  }
+  if ( *p == '>' )
+    return p+1;
+  return p;
+}
+
+#ifdef TIXML_USE_STL
+void TiXmlComment::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 == '>'
+         && tag->at( tag->length() - 2 ) == '-'
+         && tag->at( tag->length() - 3 ) == '-' )
+    {
+      // All is well.
+      return;
+    }
+  }
+}
+#endif
+
+
+const char* TiXmlComment::Parse( const char* p, TiXmlParsingData* data, TiXmlEncoding encoding )
+{
+  TiXmlDocument* document = GetDocument();
+  value = "";
+
+  p = SkipWhiteSpace( p, encoding );
+
+  //	TiXmlParsingData data( p, prevData );
+  if ( data )
+  {
+    data->Stamp( p, encoding );
+    location = data->Cursor();
+  }
+  const char* startTag = "<!--";
+  const char* endTag   = "-->";
+
+  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();
+
+  //	TiXmlParsingData data( p, prevData );
+  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 )
+{
+  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 = "";
+  //	TiXmlParsingData data( p, prevData );
+  if ( data )
+  {
+    data->Stamp( p, encoding );
+    location = data->Cursor();
+  }
+  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;
+  }
+  //	TiXmlParsingData data( p, prevData );
+  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;
+}
+