//pugxml.h
///////////////////////////////////////////////////////////////////////////////
//
// Pug XML Parser - Version 1.0002
// --------------------------------------------------------
// Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
// Released into the Public Domain. Use at your own risk.
// See pugxml.xml for further information, history, etc.
// Contributions by Neville Franks (readonly@getsoft.com).
//
///////////////////////////////////////////////////////////////////////////////

#if !defined(_PUGXML_)
#define _PUGXML_
#pragma once

//#define PUGOPT_MEMFIL //Uncomment to enable memory-mapped file parsing support.
//#define PUGOPT_NONSEG //Uncomment to enable non-destructive (non-segmenting) parsing support.


#ifdef PUGOPT_MEMFIL
#	ifndef PUGOPT_NONSEG
#		define PUGOPT_NONSEG //PUGOPT_MEMFIL implies PUGOPT_NONSEG.
#	endif
#endif


#include <iostream>
#include <ostream>
#include <string>
#if defined(PUGOPT_MEMFIL) | defined(PUGOPT_NONSEG)
#	include <assert.h>
#endif


#ifndef HIWORD
#	define HIWORD(X) ((unsigned short)((unsigned long)(X)>>16))
#	define LOWORD(X) ((unsigned short)((unsigned long)(X)&0xFFFF))
#endif


//<summary>
//	Library variant ID. The ID 0x58475550 is owned by Kristen Wegner. You *MUST* 
//	provide your own unique ID if you modify or fork the code in this library to 
//	your own purposes. If you change this then *you* are now the maintainer, not me. 
//	Change also in the package section of pugxml.xml, and append yourself to the 
//	authors section.
//</summary>
#define PUGAPI_INTERNAL_VARIANT 0x58475550
//<summary>Major version. Increment for each major release. Only change if you own the variant.</summary>
#define PUGAPI_INTERNAL_VERSION_MAJOR 1
//<summary>Minor version. Increment for each minor release. Only change if you own the variant ID.</summary>
#define PUGAPI_INTERNAL_VERSION_MINOR 2

#define PUGAPI_INTERNAL_VERSION ((PUGAPI_INTERNAL_VERSION_MINOR&0xFFFF)|PUGAPI_INTERNAL_VERSION_MAJOR<<16)


#define PUGDEF_ATTR_NAME_SIZE 128
#define PUGDEF_ATTR_VALU_SIZE 256
#define PUGDEF_ELEM_NAME_SIZE 256


//<summary>The PugXML Parser namespace.</summary>
namespace pug
{

//<summary>The Library Variant ID. See PUGAPI_INTERNAL_VARIANT for an explanation.</summary>
//<returns>The current Library Variant ID.</returns>
inline static unsigned long lib_variant(){ return PUGAPI_INTERNAL_VARIANT; }
//<summary>The library version. High word is major version. Low word is minor version.</summary>
//<returns>The current Library Version.</returns>
inline static unsigned long lib_version(){ return PUGAPI_INTERNAL_VERSION; }


//<summary>A 'name=value' XML attribute structure.</summary>
typedef struct t_xml_attribute_struct
{
	TCHAR*			name;			//Pointer to attribute name.
	bool			name_insitu;	//True if 'name' is a segment of the original parse string.
#ifdef PUGOPT_NONSEG
	unsigned int	name_size;		//Length of element name.
#endif
	TCHAR*			value;			//Pointer to attribute value.
	bool			value_insitu;	//True if 'value' is a segment of the original parse string.
#ifdef PUGOPT_NONSEG
	unsigned int	value_size;		//Length of element name.
#endif
}
	xml_attribute_struct;


//<summary>Tree node classification.</summary>
//<remarks>See 'xml_node_struct::type'.</remarks>
typedef enum t_xml_node_type
{
	node_null,			//An undifferentiated entity.
	node_document,		//A document tree's absolute root.
	node_element,		//E.g. '&lt;...&gt;'
	node_pcdata,		//E.g. '&gt;...&lt;'
	node_cdata,			//E.g. '&lt;![CDATA[...]]&gt;'
	node_comment,		//E.g. '&lt;!--...--&gt;'
	node_pi,			//E.g. '&lt;?...?&gt;'
	node_include,		//E.g. '&lt;![INCLUDE[...]]&gt;'
	node_doctype,		//E.g. '&lt;!DOCTYPE ...&gt;'.
	node_dtd_entity,	//E.g. '&lt;!ENTITY ...&gt;'.
	node_dtd_attlist,	//E.g. '&lt;!ATTLIST ...&gt;'.
	node_dtd_element,	//E.g. '&lt;!ELEMENT ...&gt;'.
	node_dtd_notation	//E.g. '&lt;!NOTATION ...&gt;'.
}
	xml_node_type;


static const unsigned long parse_grow = 4; //Default child element & attribute space growth increment.


//Parser Options
static const unsigned long parse_minimal		= 0x00000000; //Unset the following flags.
static const unsigned long parse_pi				= 0x00000002; //Parse '&lt;?...?&gt;'
static const unsigned long parse_doctype		= 0x00000004; //Parse '&lt;!DOCTYPE ...&gt;' section, setting '[...]' as data member.
static const unsigned long parse_comments		= 0x00000008; //Parse &lt;!--...--&gt;'
static const unsigned long parse_cdata			= 0x00000010; //Parse '&lt;![CDATA[...]]&gt;', and/or '&lt;![INCLUDE[...]]&gt;'
static const unsigned long parse_escapes		= 0x00000020; //Not implemented.
static const unsigned long parse_trim_pcdata	= 0x00000040; //Trim '&gt;...&lt;'
static const unsigned long parse_trim_attribute = 0x00000080; //Trim 'foo="..."'.
static const unsigned long parse_trim_cdata		= 0x00000100; //Trim '&lt;![CDATA[...]]&gt;', and/or '&lt;![INCLUDE[...]]&gt;'
static const unsigned long parse_trim_entity	= 0x00000200; //Trim '&lt;!ENTITY name ...&gt;', etc.
static const unsigned long parse_trim_doctype	= 0x00000400; //Trim '&lt;!DOCTYPE [...]&gt;'
static const unsigned long parse_trim_comment	= 0x00000800; //Trim &lt;!--...--&gt;'
static const unsigned long parse_wnorm			= 0x00001000; //Normalize all entities that are flagged to be trimmed.
static const unsigned long parse_dtd			= 0x00002000; //If parse_doctype set, then parse whatever is in data member ('[...]').
static const unsigned long parse_dtd_only		= 0x00004000; //If parse_doctype|parse_dtd set, then parse only '&lt;!DOCTYPE [*]&gt;'
static const unsigned long parse_default		= 0x0000FFFF;
static const unsigned long parse_noset			= 0x80000000;


//<summary>An XML document tree node.</summary>
typedef struct t_xml_node_struct
{
	t_xml_node_struct*		parent;				//Pointer to parent
	TCHAR*					name;				//Pointer to element name.
#ifdef PUGOPT_NONSEG
	unsigned int			name_size;			//Length of element name. Since 19 Jan 2003 NF.
#endif
	bool					name_insitu;		//True if 'name' is a segment of the original parse string.
	xml_node_type			type;				//Node type; see xml_node_type.
	unsigned int			attributes;			//Count attributes.
	unsigned int			attribute_space;	//Available pointer space in 'attribute'.
	xml_attribute_struct**	attribute;			//Array of pointers to attributes; see xml_attribute_struct.
	unsigned int			children;			//Count children in member 'child'.
	unsigned int			child_space;		//Available pointer space in 'child'.
	t_xml_node_struct**		child;				//Array of pointers to children.
	TCHAR*					value;				//Pointer to any associated string data.
#ifdef PUGOPT_NONSEG
	unsigned int			value_size;			//Length of element data. Since 19 Jan 2003 NF.
#endif
	bool					value_insitu;		//True if 'data' is a segment of the original parse string.
}
xml_node_struct;


//<summary>Concatenate 'rhs' to 'lhs', growing 'rhs' if neccessary.</summary>
//<param name="lhs">Pointer to pointer to receiving string. Note: If '*lhs' is not null, it must have been dynamically allocated using 'malloc'.</param>
//<param name="rhs">Source.</param>
//<returns>Success if 'realloc' was successful.</returns>
//<remarks>'rhs' is resized and 'rhs' is concatenated to it.</remarks>
inline static bool strcatgrow(TCHAR** lhs,const TCHAR* rhs)
{
	if(!*lhs) //Null, so first allocate.
	{
		*lhs = (TCHAR*) malloc(1UL*sizeof(TCHAR));
		**lhs = 0; //Zero-terminate.
	}
	size_t ulhs = _tcslen(*lhs);
	size_t urhs = _tcslen(rhs);
	TCHAR* temp = (TCHAR*) realloc(*lhs,(ulhs+urhs+1UL)*sizeof(TCHAR));
	if(!temp) return false; //Realloc failed.
	memcpy(temp+ulhs,rhs,urhs*sizeof(TCHAR)); //Concatenate.
	temp[ulhs+urhs] = 0; //Terminate it.
	*lhs = temp;
	return true;
}


inline static bool chartype_symbol(TCHAR c) //Character is alphanumeric, -or- '_', -or- ':', -or- '-', -or- '.'.
{ return (_istalnum(c)||c==_T('_')||c==_T(':')||c==_T('-')||c==_T('.')); }
inline static bool chartype_space(TCHAR c) //Character is greater than 0 or character is less than exclamation.
{ return (c>0 && c<_T('!')); }
inline static bool chartype_enter(TCHAR c) //Character is '&lt;'.
{ return (c==_T('<')); }
inline static bool chartype_leave(TCHAR c) //Character is '&gt;'.
{ return (c==_T('>')); }
inline static bool chartype_close(TCHAR c) //Character is '/'.
{ return (c==_T('/')); }
inline static bool chartype_equals(TCHAR c) //Character is '='.
{ return (c==_T('=')); }
inline static bool chartype_special(TCHAR c) //Character is '!'.
{ return (c==_T('!')); }
inline static bool chartype_pi(TCHAR c) //Character is '?'.
{ return (c==_T('?')); }
inline static bool chartype_dash(TCHAR c) //Character is '-'.
{ return (c==_T('-')); }
inline static bool chartype_quote(TCHAR c) //Character is &quot;&lsquo;&quot; -or- &lsquo;&quot;&lsquo;.
{ return (c==_T('"')||c==_T('\'')); }
inline static bool chartype_lbracket(TCHAR c) //Character is '['.
{ return (c==_T('[')); }
inline static bool chartype_rbracket(TCHAR c) //Character is ']'.
{ return (c==_T(']')); }


#ifdef PUGOPT_NONSEG


//<summary>Concatenate 'rhs' to 'lhs', growing 'lhs' if neccessary.</summary>
//<param name="lhs">Pointer to pointer to receiving string. Note: If '*lhs' is not null, it must have been dynamically allocated using 'malloc'.</param>
//<param name="rhs">Source.</param>
//<param name="lsize">Specifies the length of *lhs in bytes and returns its new length.</param>
//<param name="rsize">Specifies the length of *rhs in bytes.</param>
//<returns>Success if 'realloc' was successful.</returns>
//<remarks>'lhs' is resized and 'rhs' is concatenated to it.</remarks>
inline static bool strcatgrown_impl(TCHAR** lhs,const TCHAR* rhs,unsigned int& lsize,unsigned int rsize)
{
	if(!*lhs) //Null, allocate and copy.
	{
		*lhs = (TCHAR*) malloc(rsize+sizeof(TCHAR));
		if(!*lhs)
		{
			lsize = 0;
			return false; //Allocate failed.
		}
		memcpy(*lhs,rhs,rsize); //Concatenate.
		*(*lhs + rsize) = 0; //Terminate it.
		lsize = rsize;
	}
	else //Reallocate. NF I don't think this is right for MBCS, nor is code in 'StrCatGrow()'.
	{
		TCHAR* temp = (TCHAR*) realloc(*lhs,lsize + rsize + sizeof(TCHAR));
		if(!temp) return false; //Realloc failed.
		memcpy(temp+lsize,rhs,rsize); //Concatenate.
		lsize += rsize; //Set new length.
		temp[lsize] = 0; //Terminate it.
		*lhs = temp;
	}
	return true;
}

//<summary>Concatenate 'rhs' to 'lhs', growing 'lhs' if neccessary.</summary>
//<param name="lhs">Pointer to pointer to receiving string. Note: If '*lhs' is not null, it must have been dynamically allocated using 'malloc'.</param>
//<param name="rhs">Source.</param>
//<param name="lsize">Specifies the length of *lhs in bytes and returns its new length.</param>
//<returns>Success if 'realloc' was successful.</returns>
//<remarks>'lhs' is resized and 'rhs' is concatenated to it.</remarks>
inline static bool strcatgrown(TCHAR** lhs,const TCHAR* rhs,unsigned int& lsize)
{
	const unsigned int rsize = _tcslen(rhs) * sizeof(TCHAR);
	return pug::strcatgrown_impl(lhs,rhs,lsize,rsize);
}

//<summary>Trim leading and trailing whitespace.</summary>
//<param name="s">Pointer to pointer to string.</param>
//<param name="len">Specifies the length of *s in bytes and returns its new length.</param>
//<returns>Success.</returns>
//<remarks>*s is modified to point to the first non-white character in the string.</remarks>
inline static bool strwtrim(TCHAR** s,unsigned int& len)
{
	if(!s || !*s) return false;
	TCHAR* pse = *s + len;
	while(*s < pse && pug::chartype_space(**s)) //Find first non-white character.
		++*s; //As long as we hit whitespace, increment the string pointer.
	for(; *s < --pse;) //As long as we hit whitespace, decrement.
	{
		if(!pug::chartype_space(*pse))
		{
			len = pse + 1 - *s;
			break;
		}
	}
	return true;
}


#else


//<summary>Trim leading and trailing whitespace.</summary>
//<param name="s">Pointer to pointer to string.</param>
//<returns>Success.</returns>
inline static bool strwtrim(TCHAR** s)
{
	if(!s || !*s) return false;
	while(**s > 0 && **s < _T('!')) ++*s; //As long as we hit whitespace, increment the string pointer.
	const TCHAR* temp = *s;
	while(0 != *temp++); //Find the terminating null.
	long i, n = (long)(temp-*s-1);
	--n; //Start from the last string TCHAR.
	for(i=n; (i > -1) && (*s)[i] > 0 && (*s)[i] < _T('!'); --i); //As long as we hit whitespace, decrement.
	if(i<n) (*s)[i+1] = 0; //Zero-terminate.
	return true;
}


//<summary>
//	In situ trim leading and trailing whitespace, then convert all consecutive 
//	whitespace to a single space TCHAR.
//</summary>
//<param name="s">Pointer to pointer to string.</param>
//<returns>Success.</returns>
inline static bool strwnorm(TCHAR** s)
{
	if(!s || !*s) return false; //No string to normalize.
	while(**s > 0 && **s < _T('!')) ++(*s); //As long as we hit whitespace, increment the string pointer.
	const TCHAR* temp = *s;
	while(0 != *temp++); //Find the terminating null.
	long n = (long)(temp-*s-1);
	TCHAR* norm = (TCHAR*)malloc(sizeof(TCHAR)*(n+1)); //Allocate a temporary normalization buffer.
	if(!norm) return false; //Allocation failed.
	memset(norm,0,sizeof(TCHAR)*(n+1)); //Zero it.
	long j = 1;
	norm[0] = (*s)[0];
	for(long i=1; i<n; ++i) //For each character, starting at offset 1.
	{
		if((*s)[i] < _T('!')) //Whitespace-like.
		{
			if((*s)[i-1] >= _T('!')) //Previous was not whitespace-like.
			{
				norm[j] = _T(' '); //Convert to a space TCHAR.
				++j; //Normalization buffer grew by one TCHAR.
			}
		}
		else { norm[j] = (*s)[i]; ++j; } //Not whitespace, so just copy over.
	}
	if(j < n) //Normalization buffer is actually different that input.
	{
		_tcsncpy(*s,norm,j); //So, copy it back to input.
		(*s)[j] = 0; //Zero-terminate.
	}
	free(norm); //Don't need this anymore.
	--n; //Start from the last string TCHAR.
	int iTemp=n;
	for(int i=n; (i > -1) && (*s)[i] > 0 && (*s)[i] < _T('!'); --i){iTemp=i;} //Find the first non-whitespace from the end.
	if(iTemp<n) (*s)[iTemp+1] = 0; //Truncate it.
	return true;

}

#endif


//<summary>Set structure string member to given value.</summary>
//<param name="dest">Pointer to pointer to destination.</param>
//<param name="src">Source.</param>
//<param name="insitu">Pointer to boolean in-situ string flag.</param>
//<returns>True if member was set to the new value.</returns>
//<remarks>
//	If 'src' is larger than 'dest' then 'dest' is resized, in which case 
//	it is probably no longer in-situ,and 'in_situ' is set to false. If 
//	'dest' is already no longer in-situ, and 'src' is too small then the 
//	existing memory pointed to is freed. If 'dest' is larger than or equal 
//	to 'dest' then it is merely copied with no resize.
//</remarks>
inline static bool strcpyinsitu
	(
		TCHAR**			dest,
		const TCHAR*	src,
		bool*			insitu
#ifdef PUGOPT_NONSEG
		,
		unsigned int&	destlen
#endif
	)
{
	if(!dest || !src || !insitu) return false; //Bad argument(s), so fail.
#ifndef PUGOPT_NONSEG //Always use heap for our r/o string.
	size_t l = (*dest) ? _tcslen(*dest) : 0; //How long is destination?
	if(l >= _tcslen(src)) //Destination is large enough, so just copy.
	{
		_tcscpy(*dest,src); //Copy.
		return TRUE; //Success.
	}
	else //Destination is too small.
#endif
	{
		if(*dest && !*insitu) free(*dest); //If destination is not in-situ, then free it.
		*dest = NULL; //Mark destination as NULL, forcing 'StrCatGrow' to 'malloc.
#ifdef PUGOPT_NONSEG
		if(strcatgrown(dest,src,destlen)) //Allocate & copy source to destination
#else
		if(strcatgrow(dest,src)) //Allocate & copy source to destination
#endif
		{
			*insitu = false; //Mark as no longer being in-situ, so we can free it later.
			return TRUE; //Success.
		}
	}
	return false; //Failure.
}


//<summary>Character set pattern match.</summary>
//<param name="lhs">String or expression for left-hand side of comparison.</param>
//<param name="rhs">String for right-hand side of comparison.</param>
//<remarks>Used by 'strcmpwild'.</remarks>
inline int strcmpwild_cset(const TCHAR** src,const TCHAR** dst)
{
	int find = 0;
	int excl = 0;
	int star = 1;
	if(**src == _T('!'))
	{
		excl = 1;
		++(*src);
	}
	while(**src != _T(']') || star == 1)
	{
		if(find == 0)
		{
			if(**src == _T('-') && *(*src-1) < *(*src+1) && *(*src+1) != _T(']') && star == 0)
			{
				if(**dst >= *(*src-1) && **dst <= *(*src+1))
				{
					find = 1;
					++(*src);
				}
			}
			else if(**src == **dst) find = 1;
		}
		++(*src);
		star = 0;
	}
	if(excl == 1) find = (1 - find);
	if(find == 1) ++(*dst);
	return find;
}


int strcmpwild_impl(const TCHAR* src,const TCHAR* dst); //Forward declaration.


//<summary>Wildcard pattern match.</summary>
//<param name="lhs">String or expression for left-hand side of comparison.</param>
//<param name="rhs">String for right-hand side of comparison.</param>
//<remarks>Used by 'strcmpwild'.</remarks>
int strcmpwild_astr(const TCHAR** src,const TCHAR** dst)
{
	int find = 1;
	++(*src);
	while((**dst != 0 && **src == _T('?')) || **src == _T('*'))
	{
		if(**src == _T('?')) ++(*dst);
		++(*src);
	}
	while(**src == _T('*')) ++(*src);
	if(**dst == 0 && **src != 0) return 0;
	if(**dst == 0 && **src == 0) return 1;
	else
	{
		if(strcmpwild_impl(*src,*dst) == 0)
		{
			do
			{
				++(*dst);
				while(**src != **dst && **src != _T('[') && **dst != 0) 
					++(*dst);
			}
			while((**dst != 0) ? strcmpwild_impl(*src,*dst) == 0 : 0 != (find=0));
		}
		if(**dst == 0 && **src == 0) find = 1;
		return find;
	}
}


//<summary>Compare two strings, with globbing, and character sets.</summary>
//<param name="lhs">String or expression for left-hand side of comparison.</param>
//<param name="rhs">String for right-hand side of comparison.</param>
//<remarks>Used by 'strcmpwild'.</remarks>
int strcmpwild_impl(const TCHAR* src,const TCHAR* dst)
{
	int find = 1;
	for(; *src != 0 && find == 1 && *dst != 0; ++src)
	{
		switch(*src)
		{
		case _T('?'): ++dst; break;
		case _T('['): ++src; find = strcmpwild_cset(&src,&dst); break;
		case _T('*'): find = strcmpwild_astr(&src,&dst); --src; break;
		default : find = (int) (*src == *dst); ++dst;
		}
	}
	while(*src == _T('*') && find == 1) ++src;
	return (int) (find == 1 && *dst == 0 && *src == 0);
}

//<summary>Compare two strings, with globbing, and character sets.</summary>
//<param name="lhs">String or expression for left-hand side of comparison.</param>
//<param name="rhs">String for right-hand side of comparison.</param>
//<returns>
//	Returns 1 if src does not match dst, or -1 if either src or dst are null, 
//	or 0 if src matches dst.
//</returns>
//<remarks>
//	Simple regular expressions are permitted in 'src': The character '*' matches
//	zero or more characters up to the next pattern, or the end of the string. The 
//	'?' character matches any single character. Character sets and negation are 
//	also permitted, for example, '[abcd]', '[a-zA-Z]', etc.
//</remarks>
inline int strcmpwild(const TCHAR* src,const TCHAR* dst) 
{
	if(!src || !dst) return -1;
	return (strcmpwild_impl(src,dst)==1)?0:1;
}


//<summary>Allocate & init an xml_attribute_struct structure.</summary>
//<returns>Pointer to new xml_attribute_struct structure.</returns>
inline static xml_attribute_struct* new_attribute(void)
{
	xml_attribute_struct* p = (xml_attribute_struct*)malloc(sizeof(xml_attribute_struct)); //Allocate one attribute.
	if(p) //If allocation succeeded.
	{
		p->name = p->value = 0; //No name or value.
#ifdef PUGOPT_NONSEG
		p->name_size = p->value_size = 0; //Lengths of zero.
#endif
		p->name_insitu = p->value_insitu = true; //Default to being in-situ of the parse string.
	}
	return p;
}


//<summary>Allocate & init an xml_node_struct structure.</summary>
//<param name="type">Desired node type.</param>
//<returns>Pointer to new xml_node_struct structure.</returns>
inline static xml_node_struct* new_node(xml_node_type type = node_element)
{
	xml_node_struct* p = (xml_node_struct*)malloc(sizeof(xml_node_struct)); //Allocate one node.
	if(p) //If allocation succeeded.
	{
		p->name = p->value = 0; //No name or data.
#ifdef PUGOPT_NONSEG
		p->name_size = p->value_size = 0;
#endif
		p->type = type; //Set the desired type.
		p->attributes = p->children = 0; //No attributes or children.
		p->name_insitu = p->value_insitu = true; //Default to being in-situ of the parse string.
		if
		(
			type != node_document	&& //None of these will have attributes.
			type != node_pcdata		&&
			type != node_cdata		&&
			type != node_include	&&
			type != node_comment
		)
			p->attribute = (xml_attribute_struct**)malloc(sizeof(xml_attribute_struct*)); //Allocate one attribute.
		else p->attribute = NULL;
		p->attribute_space = (p->attribute) ? 1 : 0;
		if
		(
			type == node_element || //Only these will have children.
			type == node_doctype ||
			type == node_document
		)
			p->child = (xml_node_struct**)malloc(sizeof(xml_node_struct*)); //Allocate one child.
		else p->child = NULL;
		p->child_space = (p->child) ? 1 : 0;
	}
	return p;
}


//<summary>Allocate & append a new xml_node_struct onto the given parent.</summary>
//<param name="parent">Pointer to parent node.</param>
//<param name="grow">Pointer space growth increment.</param>
//<param name="type">Desired node type.</param>
//<returns>Pointer to new node.</returns>
//<remarks>Child pointer space of 'node' may be reallocated.</remarks>
inline static xml_node_struct* append_node(xml_node_struct* parent,long grow,xml_node_type type = node_element)
{
	if(!parent) return NULL; //Must have a parent.
	if(parent->children == parent->child_space) //Out of pointer space.
	{
		xml_node_struct** t = (xml_node_struct**)realloc(parent->child,sizeof(xml_node_struct*)*(parent->child_space+grow)); //Grow pointer space.
		if(t) //Reallocation succeeded.
		{
			parent->child = t;
			parent->child_space += grow; //Update the available space.
		}
	}
	xml_node_struct* child = new_node(type); //Allocate a new child.
	child->parent = parent; //Set it's parent pointer.
	parent->child[parent->children] = child; //Set the parent's child pointer.
	parent->children++; //One more child.
	return child;
}


//<summary>Allocate & append a new attribute to the given xml_node_struct.</summary>
//<param name="node">Pointer to parent node.</param>
//<param name="grow">Pointer space growth increment.</param>
//<returns>Pointer to appended xml_attribute_struct.</returns>
//<remarks>Attribute pointer space of 'node' may be reallocated.</remarks>
inline static xml_attribute_struct* append_attribute(xml_node_struct* node,long grow)
{
	if(!node) return NULL;
	xml_attribute_struct* a = new_attribute();
	if(!a) return NULL;
	if(node->attributes == node->attribute_space) //Out of space, so grow.
	{
		xml_attribute_struct** t = (xml_attribute_struct**)realloc(node->attribute,sizeof(xml_node_struct*)*(node->attribute_space+grow));
		if(t)
		{
			node->attribute = t;
			node->attribute_space += grow;
		}
	}
	node->attribute[node->attributes] = a;
	node->attributes++;
	return a;
}


//<summary>Non-recursively free a tree.</summary>
//<param name="root">
//	Pointer to the root of the tree. Note: 'root' must have been dynamically 
//	allocated using 'malloc' or 'realloc', as 'free_node' tries to also free 
//	the structure pointed to by 'root'.
//</param>
//<remarks>'root' no longer points to a valid structure.</remarks>
inline static void free_node(xml_node_struct* node)
{
	if(!node) return;

	register xml_node_struct* cursor = node;

	//Free all children of children.
	do
	{
LOC_STEP_INTO:
		for(; cursor->children>0; --cursor->children) //Free each child in turn; 'children' keeps count while we jump around.
		{
			register xml_node_struct* t = cursor->child[cursor->children-1]; //Take a pointer to the child.
			if(t && t->children) //If the child has children.
			{
				cursor = t; //Step in.
				goto LOC_STEP_INTO; //Step into this node.
			}
			else if(t)
			{
				if(t->attributes) //Child has attributes.
				{
					register unsigned int n = t->attributes; //Free each attribute.
					for(register unsigned int i=0; i<n; ++i)
					{
						if(t->attribute[i]->name && !t->attribute[i]->name_insitu)
							free(t->attribute[i]->name);
						if(t->attribute[i]->value && !t->attribute[i]->value_insitu)
							free(t->attribute[i]->value);
						free(t->attribute[i]);
					}
				}
				if(t->attribute) free(t->attribute); //Free attribute pointer space.
				if(t->child) free(t->child); //Free child pointer space.
				if(t->name && !t->name_insitu) free(t->name);
				if(t->value && !t->value_insitu) free(t->value);
				free(t); //Free the child node.
			}
		}
		cursor = cursor->parent; //Step out.
	}
	while(cursor->children); //While there are children.
	//Finally, free the root's children & the root itself.
	if(cursor->attributes)
	{
		register unsigned int n = cursor->attributes;
		for(register unsigned int i=0; i<n; ++i)
		{
			if(cursor->attribute[i]->name && !cursor->attribute[i]->name_insitu)
				free(cursor->attribute[i]->name);
			if(cursor->attribute[i]->value && !cursor->attribute[i]->value_insitu)
				free(cursor->attribute[i]->value);
			free(cursor->attribute[i]);
		}
	}
	if(cursor->attribute) free(cursor->attribute); //Free attribute pointer space.
	if(cursor->child) free(cursor->child); //Free child pointer space.
	if(cursor->name && !cursor->name_insitu) free(cursor->name); //Free name & data.
	if(cursor->value && !cursor->value_insitu) free(cursor->value);
	free(cursor); //Free the root itself.
}

//<summary>Recursively free a tree.</summary>
//<param name="root">Pointer to the root of the tree.</param>
//<remarks>Not used.</remarks>
inline static void free_node_recursive(xml_node_struct* root)
{
	if(root)
	{
		unsigned int n = root->attributes;
		register unsigned int i;
		for(i=0; i<n; i++)
		{
			if(root->attribute[i]->name && !root->attribute[i]->name_insitu)
				free(root->attribute[i]->name);
			if(root->attribute[i]->value && !root->attribute[i]->value_insitu)
				free(root->attribute[i]->value);
			free(root->attribute[i]);
		}
		free(root->attribute);
		n = root->children;
		for(i=0; i<n; i++)
			free_node_recursive(root->child[i]);
		free(root->child);
		if(root->name && !root->name_insitu) free(root->name);
		if(root->value && !root->value_insitu) free(root->value);
		free(root);
	}
}


//<summary>Parser utilities.</summary>
#define SKIPWS()			{ while(chartype_space(*s)) ++s; if(*s==0) return s; }
#define OPTSET(OPT)			( optmsk & OPT )
#define PUSHNODE(TYPE)		{ cursor = append_node(cursor,growby,TYPE); }
#define POPNODE()			{ cursor = cursor->parent; }
#define SCANFOR(X)			{ while(*s!=0 && !(X)) ++s; if(*s==0) return s; }
#define SCANWHILE(X)		{ while((X)) ++s; if(*s==0) return s; }
#ifndef PUGOPT_NONSEG
#	define ENDSEG()			{ ch = *s; *s = 0; ++s; if(*s==0) return s; }
#else
#	define ENDSEG()			{ ch = *s; ++s; if(*s==0) return s; }
#	define SETLEN()			( cursor->value_size = s - cursor->value )
#	define ENDSEGDAT()		{ ch = *s; SETLEN(); ++s; if(*s==0) return s; } 
#	define ENDSEGNAM(S)		{ ch = *s; S->name_size = s - S->name; ++s; if(*s==0) return s; } 
#	define ENDSEGATT(S)		{ ch = *s; S->value_size = s - S->value; ++s; if(*s==0) return s; }
#endif


//<summary>Static single-pass in-situ parse the given xml string.</summary>
//<param name="s">Pointer to XML-formatted string.</param>
//<param name="root">Pointer to root.</param>
//<param name="grow">Pointer space growth increment.</param>
//<param name="optmsk">Parse options mask.</param>
//<returns>Last string position or null.</returns>
//<remarks>
//	Input string is zero-segmented if 'PUGOPT_NONSEG' is not defined. Memory 
//	may have been allocated to 'root' (free with 'free_node').
//</remarks>
static TCHAR* parse(register TCHAR* s,xml_node_struct* xmldoc,long growby,unsigned long optmsk = parse_default)
{
	if(!s || !xmldoc) return s;
	TCHAR ch = 0; //Current char, in cases where we must null-terminate before we test.
	xml_node_struct* cursor = xmldoc; //Tree node cursor.
	TCHAR* mark = s; //Marked string position for temporary look-ahead.
	while(*s!=0)
	{
LOC_SEARCH: //Obliviously search for next element.
		SCANFOR(chartype_enter(*s)); //Find the next '<'.
		if(chartype_enter(*s))
		{
			++s;
LOC_CLASSIFY: //What kind of element?
			if(chartype_pi(*s)) //'<?...'
			{
				++s;
				if(chartype_symbol(*s) && OPTSET(parse_pi))
				{
					mark = s;
					SCANFOR(chartype_pi(*s)); //Look for terminating '?'.
#ifndef PUGOPT_NONSEG
					if(chartype_pi(*s)) *s = _T('/'); //Same semantics as for '<.../>', so fudge it.
#endif
					s = mark;
					PUSHNODE(node_pi); //Append a new node on the tree.
					goto LOC_ELEMENT; //Go read the element name.
				}
				else //Bad PI or parse_pi not set.
				{
					SCANFOR(chartype_leave(*s)); //Look for '>'.
					++s;
					mark = 0;
					continue;
				}
			}
			else if(chartype_special(*s)) //'<!...'
			{
				++s;
				if(chartype_dash(*s)) //'<!-...'
				{
					++s;
					if(OPTSET(parse_comments) && chartype_dash(*s)) //'<!--...'
					{
						++s;
						PUSHNODE(node_comment); //Append a new node on the tree.
						cursor->value = s; //Save the offset.
						while(*s!=0 && *(s+1) && *(s+2) && !((chartype_dash(*s) && chartype_dash(*(s+1))) && chartype_leave(*(s+2)))) ++s; //Scan for terminating '-->'.
						if(*s==0) return s;
#ifdef PUGOPT_NONSEG
						SETLEN(); //NF 19 Jan 2003.
#else
						*s = 0; //Zero-terminate this segment at the first terminating '-'.
#endif
						if(OPTSET(parse_trim_comment)) //Trim whitespace.
						{
#ifdef PUGOPT_NONSEG
							strwtrim(&cursor->value,cursor->value_size);
#else
							if(OPTSET(parse_wnorm)) strwnorm(&cursor->value);
							else strwtrim(&cursor->value);
#endif
						}
						s += 2; //Step over the '\0-'.
						POPNODE(); //Pop since this is a standalone.
						goto LOC_LEAVE; //Look for any following PCDATA.
					}
					else
					{
						while(*s!=0 && *(s+1)!=0 && *(s+2)!=0 && !((chartype_dash(*s) && chartype_dash(*(s+1))) && chartype_leave(*(s+2)))) ++s; //Scan for terminating '-->'.
						if(*s==0) return s;
						s += 2;
						goto LOC_LEAVE; //Look for any following PCDATA.
					}
				}
				else if(chartype_lbracket(*s)) //'<![...'
				{
					++s;
					if(*s==_T('I')) //'<![I...'
					{
						++s;
						if(*s==_T('N')) //'<![IN...'
						{
							++s;
							if(*s==_T('C')) //'<![INC...'
							{
								++s;
								if(*s==_T('L')) //'<![INCL...'
								{
									++s;
									if(*s==_T('U')) //'<![INCLU...'
									{
										++s;
										if(*s==_T('D')) //'<![INCLUD...'
										{
											++s;
											if(*s==_T('E')) //'<![INCLUDE...'
											{
												++s;
												if(chartype_lbracket(*s)) //'<![INCLUDE[...'
												{
													++s;
													if(OPTSET(node_cdata))
													{
														PUSHNODE(node_include); //Append a new node on the tree.
														cursor->value = s; //Save the offset.
														while(!(chartype_rbracket(*s) && chartype_rbracket(*(s+1)) && chartype_leave(*(s+2)))) ++s; //Scan for terminating ']]>'.
														if(chartype_rbracket(*s))
														{
#ifdef PUGOPT_NONSEG
															SETLEN(); //NF 19 Jan 2003.
#else
															*s = 0; //Zero-terminate this segment.
#endif
															++s;
															if(OPTSET(parse_trim_cdata)) //Trim whitespace.
															{
#ifdef PUGOPT_NONSEG
																strwtrim(&cursor->value, cursor->value_size);
#else
																if(OPTSET(parse_wnorm)) strwnorm(&cursor->value);
																else strwtrim(&cursor->value);
#endif
															}
														}
														POPNODE(); //Pop since this is a standalone.
													}
													else //Flagged for discard, but we still have to scan for the terminator.
													{
														while(*s!=0 && *(s+1)!=0 && *(s+2)!=0 && !(chartype_rbracket(*s) && chartype_rbracket(*(s+1)) && chartype_leave(*(s+2)))) ++s; //Scan for terminating ']]>'.
														++s;
													}
													++s; //Step over the last ']'.
													goto LOC_LEAVE; //Look for any following PCDATA.
												}
											}
										}
									}
								}
							}
						}
					}
					else if(*s==_T('C')) //'<![C...'
					{
						++s;
						if(*s==_T('D')) //'<![CD...'
						{
							++s;
							if(*s==_T('A')) //'<![CDA...'
							{
								++s;
								if(*s==_T('T')) //'<![CDAT...'
								{
									++s;
									if(*s==_T('A')) //'<![CDATA...'
									{
										++s;
										if(chartype_lbracket(*s)) //'<![CDATA[...'
										{
											++s;
											if(OPTSET(parse_cdata))
											{
												PUSHNODE(node_cdata); //Append a new node on the tree.
												cursor->value = s; //Save the offset.
												while(*s!=0 && *(s+1)!=0 && *(s+2)!=0 && !(chartype_rbracket(*s) && chartype_rbracket(*(s+1)) && chartype_leave(*(s+2)))) ++s; //Scan for terminating ']]>'.
												if(*(s+2)==0) return s; //Very badly formed.
												if(chartype_rbracket(*s))
												{
#ifdef PUGOPT_NONSEG
													SETLEN(); //NF 19 Jan 2003.
#else
													*s = 0; //Zero-terminate this segment.
#endif
													++s;
													if(OPTSET(parse_trim_cdata)) //Trim whitespace.
													{
#ifdef PUGOPT_NONSEG
														strwtrim(&cursor->value,cursor->value_size);
#else
														if(OPTSET(parse_wnorm)) strwnorm(&cursor->value);
														else strwtrim(&cursor->value);
#endif
													}
												}
												POPNODE(); //Pop since this is a standalone.
											}
											else //Flagged for discard, but we still have to scan for the terminator.
											{
												while(*s!=0 && *(s+1)!=0 && *(s+2)!=0 && !(chartype_rbracket(*s) && chartype_rbracket(*(s+1)) && chartype_leave(*(s+2)))) ++s; //Scan for terminating ']]>'.
												++s;
											}
											++s; //Step over the last ']'.
											goto LOC_LEAVE; //Look for any following PCDATA.
										}
									}
								}
							}
						}
					}
					continue; //Probably a corrupted CDATA section, so just eat it.
				}
				else if(*s==_T('D')) //'<!D...'
				{
					++s;
					if(*s==_T('O')) //'<!DO...'
					{
						++s;
						if(*s==_T('C')) //'<!DOC...'
						{
							++s;
							if(*s==_T('T')) //'<!DOCT...'
							{
								++s;
								if(*s==_T('Y')) //'<!DOCTY...'
								{
									++s;
									if(*s==_T('P')) //'<!DOCTYP...'
									{
										++s;
										if(*s==_T('E')) //'<!DOCTYPE...'
										{
											++s;
											SKIPWS(); //Eat any whitespace.
											xml_attribute_struct* a = 0;
											if(OPTSET(parse_doctype))
											{
												PUSHNODE(node_doctype); //Append a new node on the tree.
												a = append_attribute(cursor,3); //Store the DOCTYPE name.
												a->value = a->name = s; //Save the offset.
											}
											SCANWHILE(chartype_symbol(*s)); //'<!DOCTYPE symbol...'
#ifdef PUGOPT_NONSEG
											if(OPTSET(parse_doctype))
												a->name_size = a->value_size = s - a->value; //Save the length. rem: Before ENDSEG()
#endif
											ENDSEG(); //Save char in 'ch', terminate & step over.
											if(chartype_space(ch)) SKIPWS(); //Eat any whitespace.
LOC_DOCTYPE_SYMBOL:
											if(chartype_symbol(*s))
											{
												mark = s;
												SCANWHILE(chartype_symbol(*s)); //'...symbol SYSTEM...'
												if(OPTSET(parse_doctype))
												{
													a = append_attribute(cursor,1);
													a->value = a->name = mark;
#ifdef PUGOPT_NONSEG
													a->value_size = a->name_size = s - mark; //NF 19 Jan 2003.
#else
													*s = 0;
#endif
												}
												++s;
												SKIPWS();
											}
											if(chartype_quote(*s)) //'...SYSTEM "..."'
											{
LOC_DOCTYPE_QUOTE:
												ch = *s;
												++s;
												mark = s;
												while(*s!=0 && *s != ch) ++s;
												if(*s!=0)
												{
													if(OPTSET(parse_doctype))
													{
														a = append_attribute(cursor,1);
														a->value = mark;
#ifdef PUGOPT_NONSEG
														a->value_size = s - mark; //NF 19 Jan 2003.
#else
														*s = 0;
#endif
													}
													++s;
													SKIPWS(); //Eat whitespace.
													if(chartype_quote(*s)) goto LOC_DOCTYPE_QUOTE; //Another quoted section to store.
													else if(chartype_symbol(*s)) goto LOC_DOCTYPE_SYMBOL; //Not wellformed, but just parse it.
												}
											}
											if(chartype_lbracket(*s)) //'...[...'
											{
												++s; //Step over the bracket.
												if(OPTSET(parse_doctype)) cursor->value = s; //Store the offset.
												unsigned int bd = 1; //Bracket depth counter.
												while(*s!=0) //Loop till we're out of all brackets.
												{
													if(chartype_rbracket(*s)) --bd;
													else if(chartype_lbracket(*s)) ++bd;
													if(bd == 0) break;
													++s;
												}
												//Note: 's' now points to end of DTD, i.e.: ']'.
												if(OPTSET(parse_doctype))
												{
													//Note: If we aren't parsing the DTD ('!parse_dtd', etc.) then it is stored in the DOM as one whole chunk.
#ifdef PUGOPT_NONSEG
													SETLEN(); //NF 19 Jan 2003
#else
													*s = 0; //Zero-terminate.
#endif
													if(OPTSET(parse_dtd)||OPTSET(parse_dtd_only))
													{
														if(OPTSET(parse_dtd))
														{
#ifdef PUGOPT_NONSEG
															TCHAR svch = *s;
															try
															{
																*s = 0; //Zero-terminate.
																parse(cursor->value,cursor,growby,optmsk); //Parse it.
															}
															catch(...){ assert(false); }
															*s = svch;
#else
															parse(cursor->value,cursor,growby,optmsk); //Parse it.
#endif
														}
														if(OPTSET(parse_dtd_only)) return (s+1); //Flagged to parse DTD only, so leave here.
													}
													else if(OPTSET(parse_trim_doctype)) //Trim whitespace.
													{
#ifdef PUGOPT_NONSEG
														strwtrim(&cursor->value, cursor->value_size);
#else
														if(OPTSET(parse_wnorm)) strwnorm(&cursor->value);
														else strwtrim(&cursor->value);
#endif
													}
													++s; //Step over the zero.
													POPNODE(); //Pop since this is a standalone.
												}
												SCANFOR(chartype_leave(*s));
												continue;
											}
											//Fall-through; make sure we pop.
											POPNODE(); //Pop since this is a standalone.
											continue;
										}
									}
								}
							}
						}
					}
				}
				else if(chartype_symbol(*s)) //An inline DTD tag.
				{
					mark = s;
					SCANWHILE(chartype_symbol(*s));
					ENDSEG(); //Save char in 'ch', terminate & step over.
					xml_node_type e = node_dtd_entity;
#ifdef PUGOPT_NONSEG
					const unsigned int dtdilen = (s - 1) - mark;
					if(_tcsncmp(mark,_T("ATTLIST"),max((7*sizeof(TCHAR)),dtdilen))==0) e = node_dtd_attlist;
					else if(_tcsncmp(mark,_T("ELEMENT"),max((7*sizeof(TCHAR)),dtdilen))==0) e = node_dtd_element;
					else if(_tcsncmp(mark,_T("NOTATION"),max((8*sizeof(TCHAR)),dtdilen))==0) e = node_dtd_notation;
#else
					if(_tcscmp(mark,_T("ATTLIST"))==0) e = node_dtd_attlist;
					else if(_tcscmp(mark,_T("ELEMENT"))==0) e = node_dtd_element;
					else if(_tcscmp(mark,_T("NOTATION"))==0) e = node_dtd_notation;
#endif
					PUSHNODE(e); //Append a new node on the tree.
					if(*s!=0 && chartype_space(ch))
					{
						SKIPWS(); //Eat whitespace.
						if(chartype_symbol(*s) || *s==_T('%'))
						{
							mark = s;
							if(*s==_T('%')) //Could be '<!ENTITY % name' -or- '<!ENTITY %name'
							{
#ifdef PUGOPT_NONSEG
								//Note: For memory-mapped file support we need to treat 's' as read-only so we can't do '*(s-1) = _T('%');' below.
								cursor->name = mark; //Sort out extraneous whitespace when we retrieve it. TODO: Whitespace cleanup.
#endif
								++s;
								if(chartype_space(*s))
								{
									SKIPWS(); //Eat whitespace.
#ifndef PUGOPT_NONSEG
									*(s-1) = _T('%');
									cursor->name = (s-1);
#endif
								}
#ifndef PUGOPT_NONSEG
								else cursor->name = mark;
#endif
							}
							else cursor->name = s;
							SCANWHILE(chartype_symbol(*s));
#ifdef PUGOPT_NONSEG
							cursor->name_size = s - cursor->name;
#endif
							ENDSEG(); //Save char in 'ch', terminate & step over.
							if(chartype_space(ch))
							{
								SKIPWS(); //Eat whitespace.
								if(e == node_dtd_entity) //Special case; may have multiple quoted sections w/anything inside.
								{
									cursor->value = s; //Just store everything here.
									bool qq = false; //Quote in/out flag.
									while(*s != 0) //Loop till we find the right sequence.
									{
										if(!qq && chartype_quote(*s)){ ch = *s; qq = true; }
										else if(qq && *s == ch) qq = false;
										else if(!qq && chartype_leave(*s)) //Not in quoted reqion and '>' hit.
										{
#ifdef PUGOPT_NONSEG
											SETLEN(); //NF 19 Jan 2003.
#else
											*s = 0;
#endif
											++s;
											if(OPTSET(parse_trim_entity))
											{
#ifdef PUGOPT_NONSEG
												strwtrim(&cursor->value,cursor->value_size);
#else
												if(OPTSET(parse_wnorm)) strwnorm(&cursor->value);
												else strwtrim(&cursor->value);
#endif
											}
											POPNODE();
											goto LOC_SEARCH;
										}
										++s;
									}
									if(OPTSET(parse_trim_entity))
									{
#ifdef PUGOPT_NONSEG
										strwtrim(&cursor->value, cursor->value_size);
#else
										if(OPTSET(parse_wnorm)) strwnorm(&cursor->value);
										else strwtrim(&cursor->value);
#endif
									}
								}
								else
								{
									cursor->value = s;
									SCANFOR(chartype_leave(*s)); //Just look for '>'.
#ifdef PUGOPT_NONSEG
									SETLEN(); //NF 19 Jan 2003.
#else
									*s = 0;
#endif
									++s;
									if(OPTSET(parse_trim_entity))
									{
#ifdef PUGOPT_NONSEG
										strwtrim(&cursor->value, cursor->value_size);
#else
										if(OPTSET(parse_wnorm)) strwnorm(&cursor->value);
										else strwtrim(&cursor->value);
#endif
									}
									POPNODE();
									goto LOC_SEARCH;
								}
							}
						}
					}
					POPNODE();
				}
			}
			else if(chartype_symbol(*s)) //'<#...'
			{
				cursor = append_node(cursor,growby); //Append a new node to the tree.
LOC_ELEMENT: //Scan for & store element name.
				cursor->name = s;
				SCANWHILE(chartype_symbol(*s)); //Scan for a terminator.
#ifdef PUGOPT_NONSEG
				cursor->name_size = s - cursor->name; //Note: Before ENDSEG().
#endif
				ENDSEG(); //Save char in 'ch', terminate & step over.
				if
					(
					*s!=0 &&
					(
					chartype_close(ch) //'</...'
#ifdef PUGOPT_NONSEG
					//||
					//chartype_pi(ch) //Treat '?>' as '/>' NF 19 Jan 2003
#endif
					)
					)
				{
					SCANFOR(chartype_leave(*s)); //Scan for '>', stepping over the tag name.
					POPNODE(); //Pop.
					continue;
				}
				else if(*s!=0 && !chartype_space(ch)) goto LOC_PCDATA; //No attributes, so scan for PCDATA.
				else if(*s!=0 && chartype_space(ch))
				{
					SKIPWS(); //Eat any whitespace.
LOC_ATTRIBUTE:
					if(chartype_symbol(*s)) //<... #...
					{
						xml_attribute_struct* a = append_attribute(cursor,growby); //Make space for this attribute.
						a->name = s; //Save the offset.
						SCANWHILE(chartype_symbol(*s)); //Scan for a terminator.
#ifdef PUGOPT_NONSEG
						ENDSEGNAM(a);
#else
						ENDSEG(); //Save char in 'ch', terminate & step over.
#endif
						if(*s!=0 && chartype_space(ch)) SKIPWS(); //Eat any whitespace.
						if(*s!=0 && (chartype_equals(ch) || chartype_equals(*s))) //'<... #=...'
						{
							if(chartype_equals(*s)) ++s;
							SKIPWS(); //Eat any whitespace.
							if(chartype_quote(*s)) //'<... #="...'
							{
								ch = *s; //Save quote char to avoid breaking on "''" -or- '""'.
								++s; //Step over the quote.
								a->value = s; //Save the offset.
								SCANFOR(*s == ch); //Scan for the terminating quote, or '>'.
#ifdef PUGOPT_NONSEG
								ENDSEGATT(a);
#else
								ENDSEG(); //Save char in 'ch', terminate & step over.
#endif
								if(OPTSET(parse_trim_attribute)) //Trim whitespace.
								{
#ifdef PUGOPT_NONSEG
									strwtrim(&a->value,a->value_size);
#else
									if(OPTSET(parse_wnorm)) strwnorm(&a->value);
									else strwtrim(&a->value);
#endif
								}
								if(chartype_leave(*s)){ ++s; goto LOC_PCDATA; }
								else if(chartype_close(*s))
								{
									++s;
									POPNODE();
									SKIPWS(); //Eat any whitespace.
									if(chartype_leave(*s)) ++s;
									goto LOC_PCDATA;
								}
								if(chartype_space(*s)) //This may indicate a following attribute.
								{
									SKIPWS(); //Eat any whitespace.
									goto LOC_ATTRIBUTE; //Go scan for additional attributes.
								}
							}
						}
						if(chartype_symbol(*s)) goto LOC_ATTRIBUTE;
						else if(*s!=0 && cursor->type == node_pi)
						{
#ifdef PUGOPT_NONSEG
							SCANFOR(chartype_pi(*s)); //compliments change where we don't fudge to '/>' when we find the PI. NF 20 Jan 2003
							SKIPWS(); //Eat any whitespace.
							if(chartype_pi(*s)) ++s;
#else
							SCANFOR(chartype_close(*s));
							SKIPWS(); //Eat any whitespace.
							if(chartype_close(*s)) ++s;
#endif
							SKIPWS(); //Eat any whitespace.
							if(chartype_leave(*s)) ++s;
							POPNODE();
							goto LOC_PCDATA;
						}
					}
				}
LOC_LEAVE:
				if(chartype_leave(*s)) //'...>'
				{
					++s; //Step over the '>'.
LOC_PCDATA: //'>...<'
					mark = s; //Save this offset while searching for a terminator.
					SKIPWS(); //Eat whitespace if no genuine PCDATA here.
					if(chartype_enter(*s)) //We hit a '<...', with only whitespace, so don't bother storing anything.
					{
						if(chartype_close(*(s+1))) //'</...'
						{
							SCANFOR(chartype_leave(*s)); //Scan for '>', stepping over any end-tag name.
							POPNODE(); //Pop.
							continue; //Continue scanning.
						}
						else goto LOC_SEARCH; //Expect a new element enter, so go scan for it.
					}
					s = mark; //We hit something other than whitespace; restore the original offset.
					PUSHNODE(node_pcdata); //Append a new node on the tree.
					cursor->value = s; //Save the offset.
					SCANFOR(chartype_enter(*s)); //'...<'
#ifdef PUGOPT_NONSEG
					ENDSEGDAT();
#else
					ENDSEG(); //Save char in 'ch', terminate & step over.
#endif
					if(OPTSET(parse_trim_pcdata)) //Trim whitespace.
					{
#ifdef PUGOPT_NONSEG
						strwtrim(&cursor->value,cursor->value_size);
#else
						if(OPTSET(parse_wnorm)) strwnorm(&cursor->value);
						else strwtrim(&cursor->value);
#endif
					}
					POPNODE(); //Pop since this is a standalone.
					if(chartype_enter(ch)) //Did we hit a '<...'?
					{
						if(chartype_close(*s)) //'</...'
						{
							SCANFOR(chartype_leave(*s)); //'...>'
							POPNODE(); //Pop.
							goto LOC_LEAVE;
						}
						else if(chartype_special(*s)) goto LOC_CLASSIFY; //We hit a '<!...'. We must test this here if we want comments intermixed w/PCDATA.
						else if(*s) goto LOC_CLASSIFY;
						else return s;
					}
				}
				//Fall-through A.
				else if(chartype_close(*s)) //'.../'
				{
					++s;
					if(chartype_leave(*s)) //'.../>'
					{
						POPNODE(); //Pop.
						++s;
						continue;
					}
				}
			}
			//Fall-through B.
			else if(chartype_close(*s)) //'.../'
			{
				SCANFOR(chartype_leave(*s)); //'.../>'
				POPNODE(); //Pop.
				continue;
			}
		}
	}
	return s;
}


//<summary>Read data from the file at 'path' into the buffer. Free with 'free'.</summary>
//<param name="path">File path.</param>
//<param name="buffer">Pointer to pointer to string to recieve buffer.</param>
//<param name="size">Pointer to count bytes read and stored in 'buffer'.</param>
//<param name="tempsize">Temporary read buffer size.</param>
//<returns>Success if file at 'path' was opened and bytes were read into memory.</returns>
//<remarks>Memory is allocated at '*buffer'. Free with 'free'.</remarks>
inline static bool load_file(const TCHAR* path,TCHAR** buffer,unsigned long* size,unsigned long tempsize = 40960)
{
	if(!path || !buffer || !size) return false;
	*size = 0;
	*buffer = 0;
	HANDLE file_handle = CreateFile(path,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
	if(file_handle == INVALID_HANDLE_VALUE) return false;
	TCHAR* temp = (TCHAR*) malloc(sizeof(TCHAR)*tempsize);
	if(!temp) return false;
	unsigned long read_bytes = 0;
	ZeroMemory(temp,sizeof(TCHAR)*tempsize);
	while(ReadFile(file_handle,(void*)temp,tempsize-1,&read_bytes,0) && read_bytes && strcatgrow(buffer,temp))
	{
		*size += read_bytes;
		ZeroMemory(temp,sizeof(TCHAR)*tempsize);
	}
	CloseHandle(file_handle);
	free(temp);
	return (*size) ? true : false;
}


//<summary>A void pointer array. Used by various xml_node::find* functions.</summary>
class pointer_array
{
//Internal Data Members
protected:
	unsigned int	_size; //Count items.
	unsigned int	_room; //Available space.
	void**			_data; //The list.
	unsigned int	_grow; //Grow by increment.
public:
	//<summary>Default constructor.</summary>
	//<param name="grow">Array growth increment.</param>
	pointer_array(unsigned int grow = 4):
		_size(0),
			_room(0),
			_data(NULL),
			_grow(grow)
		{
			_data = (void**)malloc(sizeof(void*)*_grow);
			_room = (_data) ? _grow : 0;
		}
		~pointer_array(){ if(_data) free(_data); }
public:
	bool empty(){ return (_size == 0); } //True if there is no data in the array.
	void remove_all(){ _size = 0; } //Remove all data elements from the array.
	void clear() //Free any allocated memory.
	{
		if(_data)
		{
			_data = (void**)realloc(_data,sizeof(void*)*_grow); //Reallocate to first growth increment.
			_room = _grow; //Mark it as such.
			_size = 0; //Mark array as empty.
		}
	}
	virtual void*& operator[](unsigned int i) //Access element at subscript, or dummy value if overflow.
	{
		static void* dummy = 0;
		if(i < _size) return _data[i]; else return dummy;
	}
	unsigned int size(){ return _size; } //Count data elements in the array.
	virtual void* at(unsigned int i){ if(i < _size) return _data[i]; else return NULL; } //Access element at subscript, or NULL if overflow.
	long push_back(void* element) //Append a new element to the array.
	{
		if(_data) //Fail if no array.
		{
			if(_size < _room) //There is enough allocated space.
			{
				_data[_size] = element; //Set it.
				_size++; //Increment our count of elements.
				return _size-1; //Return the element's subscript.
			}
			else //Not enough room.
			{
				void** temp = (void**)realloc(_data,sizeof(void*)*(_size+_grow)); //Grow the array.
				if(temp) //Reallocation succeeded.
				{
					_room += _grow; //Increment available space.
					_data = temp; //Assign reallocated value to array pointer.
					_data[_size] = element; //Set the element to be added.
					_size++; //Increment our count of elements.
					return _size-1; //Return the element's subscript.
				}
			}
		}
		return -1; //Something failed, so return a bad subscript.
	}
};


//<summary>A simple indentation stack.</summary>
//<remarks>Used by xml_node::outer_xml function.</remarks>
class indent_stack
{
//Internal Data Members
protected:
	TCHAR	_inch; //The indent character.
	TCHAR*	_stac; //The aggregate indent string (stack).
	int		_size; //Current depth (avoids using '_tcslen' on push/pop).
//Construction/Destruction
public:
	//<summary>Default constructor.</summary>
	//<param name="c">Indent character.</param>
	indent_stack(TCHAR c = _T('\t')):
		_inch(c),
			_stac(0) ,
			_size(0)
		{
			_stac = (TCHAR*)malloc(sizeof(TCHAR)); //Allocate.
			*_stac = 0; //Zero-terminate.
		}
		//Destructor.
		virtual ~indent_stack(){ if(_stac) free(_stac); }
//Stack Operators
public:
	//<summary>Grow indent string by one indent character.</summary>
	//<remarks>Reallocates the indent string.</remarks>
	void push()
	{
		if(_inch && _stac)
		{
			_size++;
			_stac = (TCHAR*)realloc(_stac,sizeof(TCHAR)*(_size+1));
			_stac[_size-1] = _inch;
			_stac[_size] = 0;
		}
	}
	//<summary>Shrink the indent string by one indent character.</summary>
	void pop()
	{
		if(_inch && _stac && _size > 0)
		{
			_size--;
			_stac = (TCHAR*)realloc(_stac,sizeof(TCHAR)*(_size+1));
			_stac[_size] = 0;
		}
	}
	//<summary>Accesses the indent depth.</summary>
	//<returns>The current indent string, or "" if empty.</returns>
	const TCHAR* depth(){ return (_inch && _stac) ? _stac : _T(""); }
};


//<summary>
//	Stream output. Recursively writes the given xml_node_struct structure to 
//	the given stream. NOTE: Use this recursive implementation for debug purposes 
//	only, since a large tree may cause a stack overflow.
//</summary>
//<param name="os">Reference to output stream.</param>
//<param name="indent">Reference to indentation stack.</param>
//<param name="node">Pointer to the node.</param>
//<param name="breaks">Use linebreaks?</param>
//<returns>
//	String data is written to stream. Indent stack may be altered.
//	If you want to make this prettier, and to avoid propagating whitespace,
//	you will have to trim excess whitespace from the PCDATA sections.
//</returns>
inline static void outer_xml(std::basic_ostream<TCHAR,std::char_traits<TCHAR> > & os,indent_stack& indent,xml_node_struct* node,bool breaks = true)
{
	if(node && os.good()) //There is a node and ostream is OK.
	{
		register unsigned int n, i;
		os << indent.depth();
		switch(node->type)
		{
		case node_dtd_attlist:
			if(node->name)
			{
#ifdef PUGOPT_NONSEG
				os << _T("<!ATTLIST ");
				os.write( node->name, node->name_size );
#else
				os << _T("<!ATTLIST ") << node->name;
#endif
				if(node->value)
#ifdef PUGOPT_NONSEG
				{
					os << _T(" ");
					os.write( node->value, node->value_size );
				}
#else
					os << _T(" ") << node->value;
#endif

				os << _T(">");
			}
			break;
		case node_dtd_element:
			if(node->name)
			{
#ifdef PUGOPT_NONSEG
				os << _T("<!ELEMENT ");
				os.write( node->name, node->name_size );
				if(node->value)
				{
					os << _T(" ");
					os.write( node->value, node->value_size );
				}
#else
				os << _T("<!ELEMENT ") << node->name;
				if(node->value) os << _T(" ") << node->value;
#endif
				os << _T(">");
			}
			break;
		case node_dtd_entity:
			if(node->name)
			{
#ifdef PUGOPT_NONSEG
				os << _T("<!ENTITY ");
				os.write( node->name, node->name_size );
				if(node->value)
				{
					os << _T(" ");
					os.write( node->value, node->value_size );
				}
#else
				os << _T("<!ENTITY ") << node->name;
				if(node->value) os << _T(" ") << node->value;
#endif
				os << _T(">");
			}
			break;
		case node_dtd_notation:
			if(node->name)
			{
#ifdef PUGOPT_NONSEG
				os << _T("<!NOTATION ");
				os.write( node->name, node->name_size );
				if(node->value)
				{
					os << _T(" ");
					os.write( node->value, node->value_size );
				}
#else
				os << _T("<!NOTATION ") << node->name;
				if(node->value) os << _T(" ") << node->value;
#endif
				os << _T(">");
			}
			break;
		case node_doctype:
			os << _T("<!DOCTYPE");
			n = node->attributes;
			for(i=0; i<n; ++i)
			{
				os << _T(" ");
				if(node->attribute[i]->name)
#ifdef PUGOPT_NONSEG
					os.write( node->attribute[i]->name, node->attribute[i]->name_size );
#else
					os << node->attribute[i]->name;
#endif
				else if(node->attribute[i]->value)
#ifdef PUGOPT_NONSEG
				{
					os << _T("\"");
					os.write( node->attribute[i]->value, node->attribute[i]->value_size );
					os << _T("\"");
				}
#else
					os << _T("\"") << node->attribute[i]->value << _T("\"");
#endif
			}
			if(node->children)
			{
				if(breaks) os << std::endl;
				else os << _T(" ");
				os << _T("[");
				if(breaks) os << std::endl;
				else os << _T(" ");
				n = node->children;
				indent.push(); //Push the indent stack.
				for(i=0; i<n; ++i)
				{
					if
					(
						node->child[i] && //There is a child at i.
						(
							node->child[i]->type == node_dtd_attlist	|| //Skip all other types.
							node->child[i]->type == node_dtd_element	||
							node->child[i]->type == node_dtd_entity		||
							node->child[i]->type == node_dtd_notation
						)
					)
						outer_xml(os,indent,node->child[i],breaks);
				}
				indent.pop(); //Pop the indent stack.
				os << _T("]");
			}
			else if(node->value)
#ifdef PUGOPT_NONSEG
			{
				os << _T(" [");
				os.write(node->value,node->value_size);
				os << _T("]");
			}
#else
				os << _T(" [") << node->value << _T("]");
#endif
			os << _T(">");
			break;
		case node_pcdata:
#ifdef PUGOPT_NONSEG
			if(node->value) os.write(node->value,node->value_size);
#else
			if(node->value) os << node->value;
#endif
			break;
		case node_cdata:
#ifdef PUGOPT_NONSEG
			if(node->value)
			{
				os << _T("<![CDATA[");
				os.write(node->value,node->value_size);
				os << _T("]]>");
			}
#else
			if(node->value) os << _T("<![CDATA[") << node->value << _T("]]>");
#endif
			break;
		case node_include:
#ifdef PUGOPT_NONSEG
			if(node->value)
			{
				os << _T("<![INCLUDE[");
				os.write(node->value, node->value_size);
				os << _T("]]>");
			}
#else
			if(node->value) os << _T("<![INCLUDE[") << node->value << _T("]]>");
#endif
			break;
		case node_comment:
#ifdef PUGOPT_NONSEG
			if(node->value)
			{
				os << _T("<!--");
				os.write(node->value, node->value_size);
				os << _T("-->");
			}
#else
			if(node->value) os << _T("<!--") << node->value << _T("-->");
#endif
			break;
		case node_element:
		case node_pi:
			os << _T("<");
			if(node->type==node_pi) os << _T("?");
			if(node->name)
#ifdef PUGOPT_NONSEG
				os.write(node->name,node->name_size);
#else
				os << node->name;
#endif
			else os << _T("anonymous");
			n = node->attributes;
			for(i=0; i<n; ++i)
			{
				if(node->attribute[i] && node->attribute[i]->name)
				{
#ifdef PUGOPT_NONSEG
					os << _T(" ");
					os.write(node->attribute[i]->name,node->attribute[i]->name_size);
					if(node->attribute[i]->value)
					{
						os << _T("=\"");
						os.write(node->attribute[i]->value,node->attribute[i]->value_size);
						os << _T("\"");
					}
#else
					os << _T(" ") << node->attribute[i]->name;
					if(node->attribute[i]->value) os << _T("=\"") << node->attribute[i]->value << _T("\"");
#endif
				}
			}
			n = node->children;
			if(n && node->type == node_element)
			{
				os << _T(">");
				if(n == 1 && node->child[0]->type == node_pcdata)
				{
					if(node->child[0] && node->child[0]->value)
#ifdef PUGOPT_NONSEG
						os.write(node->child[0]->value,node->child[0]->value_size);
#else
						os << node->child[0]->value;
#endif
				}
				else
				{
					if(breaks) os << std::endl;
					indent.push();
					for(i=0; i<n; ++i) pug::outer_xml(os,indent,node->child[i],breaks);
					indent.pop();
					os << indent.depth();
				}
				os << _T("</");
#ifdef PUGOPT_NONSEG
				if(node->name)
					os.write(node->name, node->name_size);
#else
				if(node->name) os << node->name;
#endif
				os << _T(">");
			}
			else
			{
				if(node->type==node_pi) os << _T("?>");
				else os << _T("/>");
			}
			break;
		default: break;
		}
		if(breaks) os << std::endl;
		os.flush();
	}
}


//<summary>Abstract iterator class for interating over a node's members.</summary>
//<remarks>Used as base class for 'xml_node_iterator' and 'xml_attribute_iterator'.</remarks>
template <class _Ty,class _Diff,class _Pointer,class _Reference>
class xml_iterator : public std::_Ranit<_Ty,_Diff,_Pointer,_Reference>
{
protected:
	xml_node_struct* _vref; //A pointer to the node over which to iterate.
	long _sscr; //Current subscript of element.
public:
	xml_iterator() : _vref(0), _sscr(-1) {} //Default constructor.
	xml_iterator(xml_node_struct* vref,long sscr = 0) : _vref(vref), _sscr(sscr){ } //Initializing constructor.
	xml_iterator(const xml_iterator& r) : _vref(r._vref), _sscr(r._sscr){ } //Copy constructor.
	virtual ~xml_iterator(){} //Destructor.
public:
	virtual bool good() = 0; //Internal validity of '_vref'.
	virtual bool oob() = 0; //Out of bounds check for '_sscr' with respect to '_vref'. Returns true if '_sscr' is O.O.B.
public:
	virtual long subscript(){ return _sscr; } //Get subscript value;
	virtual void subscript(long new_subscript){ _sscr = new_subscript; } //Set subscript value;
public:
	virtual xml_iterator& operator=(const xml_iterator& rhs){ _vref = rhs._vref; _sscr = rhs._sscr; return *this; } //Assignment.
	virtual bool operator==(const xml_iterator& rhs){ return (_sscr == rhs._sscr); } //True if this is equal to RHS.
	virtual bool operator!=(const xml_iterator& rhs){ return (_sscr != rhs._sscr); } //True if this is not equal to RHS.
	virtual bool operator<(const xml_iterator& rhs){ return (_sscr < rhs._sscr); } //True if this subscript is less than RHS.
	virtual bool operator>(const xml_iterator& rhs){ return (_sscr > rhs._sscr); } //True if this subscript is greater than RHS.
	virtual bool operator<=(const xml_iterator& rhs){ return (_sscr <= rhs._sscr); } //True if this subscript is less than or equal to RHS.
	virtual bool operator>=(const xml_iterator& rhs){ return (_sscr >= rhs._sscr); } //True if this subscript is greater than or equal to RHS.
	virtual xml_iterator& operator++(){ _sscr++; return *this; } //Increment the iterator (subscript).
	virtual xml_iterator& operator--(){ _sscr--; return *this; } //Decrement the iterator (subscript).
	virtual _Ty& operator*() = 0; //Dereference operator.
	virtual _Ty* operator->() = 0;
};

class xml_node; //Forward decl.


//<summary>Abstract tree walker class for xml_node::traverse().</summary>
class xml_tree_walker
{
protected:
	long _deep; //Current node depth.
public:
	xml_tree_walker() : _deep(0) {} //Default constructor.
	virtual ~xml_tree_walker(){} //Destructor.
public:
	virtual void push(){ ++_deep; } //Increment node depth.
	virtual void pop(){ --_deep; } //Decrement node depth.
	virtual long depth(){ return (_deep > 0) ? _deep : 0; } //Access node depth.
public:
	//<summary>Callback when traverse on a given root node begins.</summary>
	//<returns>Returning false will abort the traversal.</returns>
	//<remarks>Override this to implement your own custom behavior.</remarks>
	virtual bool begin(xml_node&){ return true; }
	//<summary>Callback for each node that is hit on traverse.</summary>
	//<returns>Returning false will abort the traversal.</returns>
	virtual bool for_each(xml_node&) = 0;
	//<summary>Callback when traverse on a given root node ends.</summary>
	//<returns>Returning false will abort the traversal.</returns>
	//<remarks>Override this to implement your own custom behavior.</remarks>
	virtual bool end(xml_node&){ return true; }
};


//<summary>Provides a light-weight wrapper for manipulating xml_attribute_struct structures.</summary>
//<remarks>
//	Note: xml_attribute does not create any memory for the attribute it wraps; 
//	it only wraps a pointer to an existing xml_attribute_struct.
//</remarks>
class xml_attribute
{
//Internal Data Members
protected:
	xml_attribute_struct* _attr; //The internal attribute pointer.
//Construction/Destruction
public:
	xml_attribute() : _attr(NULL) {} //Default constructor.
	xml_attribute(xml_attribute_struct* attr) : _attr(attr) {} //Initializing constructor.
	xml_attribute(const xml_attribute& r) : _attr(r._attr) {} //Copy constructor.
	virtual ~xml_attribute(){} //Destructor.
//Operators
public:
	void attach(xml_attribute_struct* v){ _attr = v; }
	xml_attribute& operator=(const xml_attribute& r){ _attr = r._attr; return *this; } //Assign internal pointer.
	bool operator==(const xml_attribute& r){ return (_attr == r._attr); } //Compare internal pointer.
	bool operator!=(const xml_attribute& r){ return (_attr != r._attr); }
	operator xml_attribute_struct*(){ return _attr; }
	//<summary>Cast attribute value as std::string. If not found, return empty.</summary>
	//<returns>The std::string attribute value, or empty.</returns>
	//<remarks>Note: Modifying this will not change the value, e.g. read only.</remarks>
	/*operator std::string()
	{
		std::string temp;
		if(!empty() && has_value())
		{
#ifdef PUGOPT_NONSEG
			temp.append(_attr->value,_attr->value_size);
#else
			temp = _attr->value;
#endif
		}
		return temp;
	}*/
	//<summary>Cast attribute value as integral character string. If not found, return NULL.</summary>
	//<returns>Integral character string attribute value, or NULL.</returns>
	//<remarks>Warning: Modifying this may corrupt portions of the document tree.</remarks>
	operator const TCHAR*()
	{
		if(empty() || !has_value()) return NULL;
		return _attr->value;
	}
	//<summary>Cast attribute value as long. If not found, return 0.</summary>
	//<returns>Attribute value as long, or 0.</returns>
	//<remarks>Note: Modifying this will not change the value, e.g. read only.</remarks>
	operator long()
	{
		if(empty() || !has_value()) return 0;
#ifdef PUGOPT_NONSEG
		TCHAR temp[PUGDEF_ATTR_VALU_SIZE];
		unsigned int valulen = sizeof(temp)-1;
		const unsigned int maxlen = valulen ? min(valulen,_attr->value_size) : _attr->value_size;
		_tcsncpy(temp,_attr->value,maxlen);
		temp[maxlen] = 0;
		return _tcstol(temp,NULL,10);
#else
		return _tcstol(_attr->value,NULL,10);
#endif
	}
	//<summary>Cast attribute value as double. If not found, return 0.0.</summary>
	//<returns>Attribute value as double, or 0.0.</returns>
	//<remarks>Note: Modifying this will not change the value, e.g. read only.</remarks>
	operator double()
	{
		if(empty() || !has_value()) return 0.0;
#ifdef PUGOPT_NONSEG
		TCHAR temp[PUGDEF_ATTR_VALU_SIZE];
		unsigned int valulen = sizeof(temp)-1;
		const unsigned int maxlen = valulen ? min(valulen,_attr->value_size) : _attr->value_size;
		_tcsncpy(temp,_attr->value,maxlen);
		temp[maxlen] = 0;
		return _tcstod(temp,0);
#else
		return _tcstod(_attr->value,0);
#endif
	}
	//<summary>Cast attribute value as bool. If not found, return false.</summary>
	//<returns>Attribute value as bool, or false.</returns>
	//<remarks>Note: Modifying this will not change the value, e.g. read only.</remarks>
	operator bool()
	{
		if(empty() || !has_value()) return false;
		if(*(_attr->value))
		{
			return //Only look at first char:
			(
				*(_attr->value) == _T('1') || //1*
				*(_attr->value) == _T('t') || //t* (true)
				*(_attr->value) == _T('T') || //T* (True|TRUE)
				*(_attr->value) == _T('y') || //y* (yes)
				*(_attr->value) == _T('Y') //Y* (Yes|YES)
			)
				? true : false; //Return true if matches above, else false.
		}
	}
	//<summary>Set attribute to std::string.</summary>
	//<param name="rhs">Value std::string to set.</param>
	//<returns>Reference to xml_attribute.</returns>
	//xml_attribute& operator=(const std::string& rhs){ value(rhs.c_str()); return *this; }
	//<summary>Set attribute to string.</summary>
	//<param name="rhs">Value string to set.</param>
	//<returns>Reference to xml_attribute.</returns>
	xml_attribute& operator=(const TCHAR* rhs){ if(rhs) value(rhs); return *this; }
	//<summary>Set attribute to long.</summary>
	//<param name="rhs">Value long to set.</param>
	//<returns>Reference to xml_attribute.</returns>
	xml_attribute& operator=(long rhs)
	{
		TCHAR temp[32] = {0};
		_stprintf(temp,_T("%ld"),rhs);
		value(temp);
		return *this;
	}
	//<summary>Set attribute to double.</summary>
	//<param name="rhs">Value double to set.</param>
	//<returns>Reference to xml_attribute.</returns>
	xml_attribute& operator=(double rhs)
	{
		TCHAR temp[32] = {0};
		_stprintf(temp,_T("%lf"),rhs);
		value(temp);
		return *this;
	}
	//<summary>Set attribute to bool.</summary>
	//<param name="rhs">Value bool to set.</param>
	//<returns>Reference to xml_attribute.</returns>
	xml_attribute& operator=(bool rhs)
	{
		value(rhs?_T("true"):_T("false"));
		return *this;
	}
	//<summary>Right-shift attribute value to std::string.</summary>
	//<param name="rhs">Reference to std::string to set.</param>
	//<returns>Reference to xml_attribute.</returns>
	/*xml_attribute& operator>>(std::string& rhs)
	{
#ifdef PUGOPT_NONSEG
		rhs.clear();
		rhs.append(_attr->value,_attr->value_size);
#else
		rhs = value();
#endif
		return *this;
	}*/
	//<summary>Right-shift attribute value to long.</summary>
	//<param name="rhs">Reference to long to set.</param>
	//<returns>Reference to xml_attribute.</returns>
	xml_attribute& operator>>(long& rhs){ rhs = (long)*this; return *this; }
	//<summary>Right-shift attribute value to double.</summary>
	//<param name="rhs">Reference to double to set.</param>
	//<returns>Reference to xml_attribute.</returns>
	xml_attribute& operator>>(double& rhs){ rhs = (double)*this; return *this; }
	//<summary>Right-shift attribute value to bool.</summary>
	//<param name="rhs">Reference to bool to set.</param>
	//<returns>Reference to xml_attribute.</returns>
	xml_attribute& operator>>(bool& rhs){ rhs = (bool)*this; return *this; }
	//<summary>Left-shift attribute value to long.</summary>
	//<param name="lhs">Reference to long to set.</param>
	//<param name="rhs">Reference to xml_attribute to read.</param>
	//<returns>Reference to long.</returns>
	friend long& operator<<(long& lhs,xml_attribute& rhs){ lhs = (long)rhs; return lhs; }
	//<summary>Left-shift attribute value to double.</summary>
	//<param name="lhs">Reference to double to set.</param>
	//<param name="rhs">Reference to xml_attribute to read.</param>
	//<returns>Reference to double.</returns>
	friend double& operator<<(double& lhs,xml_attribute& rhs){ lhs = (double)rhs; return lhs; }
	//<summary>Left-shift attribute value to bool.</summary>
	//<param name="lhs">Reference to bool to set.</param>
	//<param name="rhs">Reference to xml_attribute to read.</param>
	//<returns>Reference to bool.</returns>
	friend bool& operator<<(bool& lhs,xml_attribute& rhs){ lhs = (bool)rhs; return lhs; }
	//<summary>Left-shift long to attribute value.</summary>
	//<param name="lhs">Reference to xml_attribute to set.</param>
	//<param name="rhs">Reference to long to read.</param>
	//<returns>Reference to xml_attribute.</returns>
	friend xml_attribute& operator<<(xml_attribute& lhs,const long rhs){ lhs = rhs; return lhs; }
	//<summary>Left-shift double to attribute value.</summary>
	//<param name="lhs">Reference to xml_attribute to set.</param>
	//<param name="rhs">Reference to double to read.</param>
	//<returns>Reference to xml_attribute.</returns>
	friend xml_attribute& operator<<(xml_attribute& lhs,const double& rhs){ lhs = rhs; return lhs; }
	//<summary>Left-shift bool to attribute value.</summary>
	//<param name="lhs">Reference to xml_attribute to set.</param>
	//<param name="rhs">Reference to bool to read.</param>
	//<returns>Reference to xml_attribute.</returns>
	friend xml_attribute& operator<<(xml_attribute& lhs,const bool& rhs){ lhs = rhs; return lhs; }
public:
	bool empty(){ return (_attr == NULL); } //True if the internal xml_attribute_struct pointer is NULL.
	bool has_name(){ return (!empty() && _attr->name); } //True if the attribute has a name.
	bool has_value(){ return (!empty() && _attr->value); } //True if the attribute has a value.
#ifdef PUGOPT_NONSEG
	bool has_name(const TCHAR* name) { return (name && !empty() && has_name() && _tcsncmp(_attr->name,name,_attr->name_size)==0); } //Is named 'name'.
	bool has_value(const TCHAR* value) { return (value && !empty() && has_value() && _tcsncmp(_attr->value,value,_attr->value_size)==0); } //Has value 'value'.
#else
	bool has_name(const TCHAR* name) { return (name && !empty() && has_name() && _tcscmp(_attr->name,name)==0); } //Is named 'name'.
	bool has_value(const TCHAR* value) { return (value && !empty() && has_value() && _tcscmp(_attr->value,value)==0); } //Has value 'value'.
#endif
public:
	const TCHAR* name(){ return (!empty() && _attr->name) ? _attr->name : _T(""); } //Access the attribute name.
#ifdef PUGOPT_NONSEG
	const unsigned int name_size(){ return (!empty()) ? _attr->name_size : 0; } //Access the attribute name length (for PUGOPT_NONSEG).
#endif
	bool name(TCHAR* new_name) //Set the attribute name.
	{
		if(!empty() && new_name)
#ifdef PUGOPT_NONSEG
			return strcpyinsitu(&_attr->name,new_name,&_attr->name_insitu,_attr->name_size);
#else
			return strcpyinsitu(&_attr->name,new_name,&_attr->name_insitu);
#endif
		return false;
	}
	const TCHAR* value(){ return (!empty()) ? _attr->value : _T(""); } //Access the attribute value.
#ifdef PUGOPT_NONSEG
	const unsigned int value_size(){ return (!empty()) ? _attr->value_size : 0; } //Access the attribute name length (for PUGOPT_NONSEG).
#endif
	bool value(const TCHAR* new_value) //Set the attribute value.
	{
		if(!empty() && new_value)
#ifdef PUGOPT_NONSEG
			return strcpyinsitu(&_attr->value,new_value,&_attr->value_insitu,_attr->value_size);
#else
			return strcpyinsitu(&_attr->value,new_value,&_attr->value_insitu);
#endif
		return false;
	}
};


class xml_node; //Forward declaration.


//<summary>Forward wrapper for any as-yet undefined class.</summary>
//<remarks>
//	Used by xml_node_iterator, and xml_attribute_iterator to assist with
//	operator->(), and operator*() mapping to xml_node and xml_attribute
//	types.
//</remarks>
template <typename TYPE> class forward_class 
{
protected:
	TYPE* _obj; //The class, internal.
public:
	forward_class() : _obj(NULL) { _obj = new TYPE(); } //Default constructor.
	forward_class(const TYPE& r) : _obj(NULL) { _obj = new TYPE(r); } //Copy constructor.
	virtual ~forward_class(){ if(_obj) delete _obj; } //Destructor.
public:
	TYPE& operator* (){ return *_obj; }	//Dereference to the class.
	TYPE* operator->(){ return _obj; }	//Class member selection.
	operator TYPE (){ return *_obj; }	//Cast as class type.
	operator TYPE&(){ return *_obj; }	//Cast as class type reference.
	operator TYPE*(){ return _obj; }	//Cast as class type pointer.
};


//<summary>Provides a light-weight wrapper for manipulating xml_node_struct structures.</summary>
class xml_node
{
//Internal Data Members
protected:

	xml_node_struct* _root; //Pointer to node root.
	xml_node_struct _dummy; //Utility.

//Construction/Destruction
public:

	//<summary>Default constructor.</summary>
	//<remarks>
	//	Node root points to a dummy 'xml_node_struct' structure. Test for this 
	//	with 'empty'.
	//</remarks>
	xml_node(): _root(0)
	{
		memset(&_dummy,0,sizeof(xml_node_struct));
		_dummy.type = node_null;
		_dummy.parent = &_dummy;
		_root = &_dummy;
	}

	//<summary>Construct, wrapping the given 'xml_node_struct' pointer.</summary>
	//<param name="p">Pointer to node to wrap.</param>
	//<remarks>It is possible that 'p' is NULL, so test for this with 'empty'.</remarks>
	xml_node(xml_node_struct* p): _root(p) { memset(&_dummy,0,sizeof(xml_node_struct)); }

	//<summary>Copy constructor.</summary>
	//<param name="r">Reference to node.</param>
	//<remarks>
	//	Only the root pointer is assigned, so both classes now in fact point 
	//	to the same structure.
	//</remarks>
	xml_node(const xml_node& r): _root(r._root) {}

	//<summary>Destructor.</summary>
	virtual ~xml_node(){}
	
	//<summary>Attach to the given structure.</summary>
	//<param name="p">Pointer to node structure to wrap.</param>
	//<returns>Pointer to previous node structure.</returns>
	xml_node_struct* attach(xml_node_struct* p)
	{
		xml_node_struct* prev = _root;
		_root = p;
		return prev;
	}

//Iteration
public:

	//<summary>Child node iterator.</summary>
	class xml_node_iterator : public xml_iterator<xml_node,long,xml_node*,xml_node&>
	{
	protected:
		forward_class<xml_node> _wrap; //Wrapper for xml_node.
	public:
		xml_node_iterator() : _wrap(), xml_iterator<xml_node,long,xml_node*,xml_node&>() {} //Default constructor.
		xml_node_iterator(xml_node_struct* vref,long sscr = 0) : _wrap(), xml_iterator<xml_node,long,xml_node*,xml_node&>(vref,sscr) { } //Initializing constructor.
		xml_node_iterator(const xml_node_iterator& r) : _wrap(), xml_iterator<xml_node,long,xml_node*,xml_node&>(r) { } //Copy constructor.
		virtual bool good() //Internal validity.
		{
			if
			(
				_vref != 0			&& //Pointing to some node.
				_vref->child != 0	&& //The node has an array of children.
				_vref->children > 0    //There are 1 or more children in the array.
			)
				return true;
			return false;
		}
		virtual bool oob() //Out of bounds check.
		{
			if
			(
				!good()		|| //There is no data over which to iterate.
				_sscr < 0	|| //Subscript is out of range.
				_sscr >= (long)_vref->children
			)
				return true;
			return false;
		}
		//<summary>Pointer dereference for current xml_node.<summary>
		//<returns>
		//	Reference to the internal xml_node object, which wraps the 
		//	xml_node_struct corresponding to the node at the
		//	current subscript.
		//</returns>
		virtual xml_node& operator*()
		{
			if(!oob()) _wrap->attach(_vref->child[_sscr]);
			else _wrap->attach(NULL);
			return (xml_node&)_wrap;
		}
		virtual xml_node* operator->() //Member selection for current xml_node.
		{
			if(!oob()) _wrap->attach(_vref->child[_sscr]);
			else _wrap->attach(NULL);
			return (xml_node*)_wrap;
		}
	};

	//<summary>Attribute iterator.</summary>
	class xml_attribute_iterator : public xml_iterator<xml_attribute,long,xml_attribute*,xml_attribute&>
	{
	protected:
		forward_class<xml_attribute> _wrap;
	public:
		xml_attribute_iterator() : _wrap(), xml_iterator<xml_attribute,long,xml_attribute*,xml_attribute&>() {} //Default constructor.
		xml_attribute_iterator(xml_node_struct* vref,long sscr = 0) : _wrap(), xml_iterator<xml_attribute,long,xml_attribute*,xml_attribute&>(vref,sscr) { } //Initializing constructor.
		xml_attribute_iterator(const xml_attribute_iterator& r) : _wrap(), xml_iterator<xml_attribute,long,xml_attribute*,xml_attribute&>(r) { } //Copy constructor.
		virtual bool good() //Internal validity check.
		{
			if
			(
				_vref != 0				&& //Pointing to some node.
				_vref->attribute != 0	&& //The node has an array of children.
				_vref->attributes > 0	   //There are 1 or more children in the array.
			)
				return true;
			return false;
		}
		virtual bool oob() //Out of bounds check.
		{
			if
			(
				!good()		|| //There is no data over which to iterate.
				_sscr < 0	|| //Subscript is out of range.
				_sscr >= (long)_vref->attributes //For 'end'
			)
				return true;
			return false;
		}
		//<summary>Pointer dereference for current xml_attribute.</summary>
		//<returns>
		//	Reference to the internal xml_attribute object, which wraps the 
		//	xml_attribute_struct corresponding to the attribute at the
		//	current subscript.
		//</returns>
		virtual xml_attribute& operator*() 
		{
			if(!oob()) _wrap->attach(_vref->attribute[_sscr]);
			else _wrap->attach(NULL);
			return (xml_attribute&)_wrap;
		}
		//<summary>Member selection for current xml_attribute.</summary>
		//<returns></returns>
		virtual xml_attribute* operator->()
		{
			if(!oob()) _wrap->attach(_vref->attribute[_sscr]);
			else _wrap->attach(NULL);
			return (xml_attribute*)_wrap;
		}
	};

	//<summary>Base iterator type (for child nodes). Same as 'child_iterator'.</summary>
	typedef xml_node_iterator iterator;
	//<summary>Base iterator type (for child nodes). Same as 'iterator'.</summary>
	typedef xml_node_iterator child_iterator;
	//<summary>Base iterator type (for sibling nodes). Same as 'iterator'.</summary>
	typedef xml_node_iterator sibling_iterator;
	//<summary>Attribute iterator type.</summary>
	typedef xml_attribute_iterator attribute_iterator;

	//<summary>Access the begin iterator for this node's collection of child nodes.</summary>
	//<returns>The begin iterator for this node's collection of child nodes.</returns>
	//<remarks>Same as 'children_begin'.</remarks>
	iterator begin(){ return iterator(_root,0); }
	//<summary>Access the end iterator for this node's collection of child nodes.</summary>
	//<returns>The end iterator for this node's collection of child nodes.</returns>
	//<remarks>Same as 'children_end'.</remarks>
	iterator end(){ return iterator(_root,_root->children); }
	//<summary>Erase the given node from node's collection of child nodes.</summary>
	//<returns>The begin iterator for this node's collection of child nodes.</returns>
	//<remarks>Same as 'children_erase'.</remarks>
	iterator erase(iterator where){ remove_child((unsigned int)where.subscript()); return iterator(_root,0); }
	
	//<summary>Access the begin iterator for this node's collection of child nodes.</summary>
	//<returns>The begin iterator for this node's collection of child nodes.</returns>
	//<remarks>Same as 'begin'.</remarks>
	child_iterator children_begin(){ return child_iterator(_root,0); }
	//<summary>Access the end iterator for this node's collection of child nodes.</summary>
	//<returns>The end iterator for this node's collection of child nodes.</returns>
	//<remarks>Same as 'end'.</remarks>
	child_iterator children_end(){ return child_iterator(_root,_root->children); }
	//<summary>Erase the given node from node's collection of child nodes.</summary>
	//<returns>The begin iterator for this node's collection of child nodes.</returns>
	//<remarks>Same as 'erase'.</remarks>
	child_iterator children_erase(child_iterator where){ remove_child((unsigned int)where.subscript()); return child_iterator(_root,0); }
	
	//<summary>Access the begin iterator for this node's collection of attributes.</summary>
	//<returns>The begin iterator for this node's collection of attributes.</returns>
	attribute_iterator attributes_begin(){ return attribute_iterator(_root,0); }
	//<summary>Access the end iterator for this node's collection of attributes.</summary>
	//<returns>The end iterator for this node's collection of attributes.</returns>
	attribute_iterator attributes_end(){ return attribute_iterator(_root,_root->attributes); }
	//<summary>Erase the given attribute from node's collection of attributes.</summary>
	//<returns>The begin iterator for this node's collection of attributes.</returns>
	attribute_iterator attributes_erase(attribute_iterator where){ remove_attribute((unsigned int)where.subscript()); return attribute_iterator(_root,0); }

	//<summary>Access the begin iterator for this node's collection of siblings.</summary>
	//<returns>The begin iterator for this node's collection of siblings.</returns>
	sibling_iterator siblings_begin(){ if(!empty()) return sibling_iterator(_root->parent,0); return sibling_iterator(); }
	//<summary>Access the end iterator for this node's collection of siblings.</summary>
	//<returns>The end iterator for this node's collection of siblings.</returns>
	sibling_iterator siblings_end(){ if(!empty()) return sibling_iterator(_root->parent,_root->parent->children); return sibling_iterator(); }
	//<summary>Erase the given sibling from node's collection of siblings.</summary>
	//<returns>The begin iterator for this node's collection of siblings.</returns>
	sibling_iterator siblings_erase(sibling_iterator where){ parent().remove_child((unsigned int)where.subscript()); return iterator(_root->parent,0); }

//Overloaded Operators
public:

	operator xml_node_struct*(){ return _root; } //Cast as xml_node_struct pointer.
	operator void*(){ return (void*)_root; } //Cast root as void*.
	xml_node& operator=(const xml_node& r){ _root = r._root; return *this; } //Assign to xml_node_struct pointer.
	bool operator==(const xml_node& r){ return (_root == r._root); } //True if this has the same internal xml_node_struct pointer value.
	xml_node operator[](unsigned int i){ return child(i); } //Access the child at subscript.

//Node Classification
public:

	bool empty() { return (_root == 0 || _root->type == node_null); } //Node pointer is null, or type is node_null. Same as type_null.
	bool type_null() { return empty(); } //Node pointer is null, or type is node_null. Same as empty.
	bool type_document() { return (_root && _root == _root->parent && _root->type == node_document); } //Node is tree root.
	bool type_element() { return (_root && _root->type == node_element); } //Node is an element.
	bool type_comment() { return (_root && _root->type == node_comment); } //Node is a comment.
	bool type_pcdata() { return (_root && _root->type == node_pcdata); } //Node is PCDATA.
	bool type_cdata() { return (_root && _root->type == node_cdata); } //Node is CDATA.
	bool type_include() { return (_root && _root->type == node_include); } //Node is INCLUDE.
	bool type_pi() { return (_root && _root->type == node_pi); } //Node is a processing instruction.
	bool type_doctype() { return (_root && _root->type == node_doctype); } //Node is DOCTYPE.
	bool type_dtd_item() { return (_root && _root->type > node_doctype); } //Node is NODE_DTD_*.
	bool type_dtd_attlist() { return (_root && _root->type == node_dtd_attlist); } //Node is node_dtd_attlist.
	bool type_dtd_element() { return (_root && _root->type == node_dtd_element); } //Node is node_dtd_element.
	bool type_dtd_entity() { return (_root && _root->type == node_dtd_entity); } //Node is node_dtd_entity.
	bool type_dtd_notation() { return (_root && _root->type == node_dtd_notation); } //Node is node_dtd_notation.

//Member Inventory
public:

	bool has_value() { return (!empty() && _root->value != 0); } //Node has data (comment, CDATA or PCDATA).
	bool has_child_nodes() { return (!empty() && children() > 0); } //Node has 1 or more children.
	bool has_attributes() { return (!empty() && attributes() > 0); } //Node has 1 or more attributes.
	bool has_siblings() { return (!empty() && siblings() > 0); } //Node has one or more siblings.
	bool has_name() { return (!empty() && _root->name != 0); } //Node has a name.
	bool has_name(const std::string& name) { return has_name(name.c_str()); } //Node is named 'name'.
	bool has_attribute(const std::string& name) { return has_attribute(name.c_str()); } //Node has an attribute named 'name'.
#ifdef PUGOPT_NONSEG
	bool has_name(const TCHAR* name) const { return (name && _root && _root->name && _tcsncmp(_root->name,name,_root->name_size)==0); } //Node is named 'name'.
#else
	bool has_name(const TCHAR* name) const { return (name && _root && _root->name && strcmpwild(name,_root->name)==0); } //Node is named 'name'.
#endif
	bool has_attribute(const TCHAR* name){ return (mapto_attribute_idx(name) > -1); } //Node has an attribute named name.

//Member Accessors
public:

#ifdef PUGOPT_NONSEG

	//<summary>Access node name if any.</summary>
	//<returns>Name, or dummy value if the no name.</returns>
	//<remarks>Only returns up to 'PUGDEF_ELEM_NAME_SIZE' chars of name.</remarks>
	const TCHAR* name()
	{
		static TCHAR temp[PUGDEF_ELEM_NAME_SIZE] = {0};
		if(has_name())
		{
			_tcsncpy(temp,_root->name,_root->name_size);
			temp[_root->name_size<PUGDEF_ELEM_NAME_SIZE?_root->name_size:(PUGDEF_ELEM_NAME_SIZE-1)] = 0;
			return temp;
		}
		return _T("");
	}
	unsigned int name_size(){ return (has_name()) ? _root->name_size : 0; } //Get node name length if any, else 0.
	unsigned int value_size(){ return (has_value()) ? _root->value_size : 0; } //Get node value length if any, else 0.
	inline bool matches_attribute_name(const TCHAR* name,const unsigned int namelen,const int i) const { return (_tcsncmp(name,_root->attribute[i]->name,max(namelen,_root->attribute[i]->name_size))==0); } //There is an attribute at 'i' named 'name'.
	inline bool matches_child_name(const TCHAR* name,const unsigned int namelen,const int i) const { return (_tcsncmp(name,_root->child[i]->name,max(namelen,_root->child[i]->name_size))==0); } //There is a child at 'i' named 'name'.
	inline bool matches_name(const TCHAR* name,const unsigned int namelen,xml_node_struct* node) const { return (_tcsncmp(name,node->name,max(namelen,node->name_size))==0); } //This is named 'name'.
	inline bool matches_value(const TCHAR* data,const unsigned int datalen,xml_node_struct* node) const { return (_tcsncmp(data,node->value,max(datalen,node->value_size))==0); } //This is valued 'value'.
	inline bool matches_attribute_name(const TCHAR* name,const unsigned int namelen,xml_attribute_struct* attr) const { return (_tcsncmp(name,attr->name,max(namelen,attr->name_size))==0); } //The given attribute is named 'name'.
	inline bool matches_attribute_name_value(const TCHAR* value,const unsigned int valulen,xml_attribute_struct* attr) const { return (_tcsncmp(value,attr->value,max(valulen,attr->value_size))==0); } //The given attribute is valued 'value'.
#else
	const TCHAR* name(){ return (has_name()) ? _root->name : _T(""); } //Access pointer to node name if any, else empty string.
	inline bool matches_attribute_name(const TCHAR* name,const unsigned int i) const { return (strcmpwild(name,_root->attribute[i]->name)==0); } //There is an attribute at 'i' named 'name'.
	inline bool matches_child_name(const TCHAR* name,const unsigned int i) const { return (strcmpwild(name,_root->child[i]->name)==0); } //There is a child at 'i' named 'name'.
	inline bool matches_name(const TCHAR* name,xml_node_struct* node) const { return (strcmpwild(name,node->name)==0); } //This is named 'name'.
	inline bool matches_value(const TCHAR* data,xml_node_struct* node) const { return (strcmpwild(data,node->value)==0); } //This is valued 'value'.
	inline bool matches_attribute_name(const TCHAR* attribute,xml_attribute_struct* attr) const { return (strcmpwild(attribute,attr->name)==0); } //The given attribute is named 'name'.
	inline bool matches_attribute_name_value(const TCHAR* value,xml_attribute_struct* attr) const { return (strcmpwild(value,attr->value)==0); } //The given attribute is valued 'value'.
#endif
	xml_node_type type() const { return (_root) ? (xml_node_type)_root->type : node_null; } //Access node entity type.
	const TCHAR* value() { return (has_value()) ? _root->value : _T(""); } //Access pointer to data if any, else empty string.
	unsigned int children() const { return _root->children; } //Access node's child count.
	xml_node child(unsigned int i){ return (i < children()) ? xml_node(_root->child[i]) : xml_node(); } //Access child node at subscript as xml_node or xml_node(NULL) if bad subscript.
	unsigned int attributes() const { return _root->attributes; } //Access node's attribute count.
	xml_attribute attribute(unsigned int i){ return (i < attributes()) ? xml_attribute(_root->attribute[i]) : xml_attribute(); } //Access attribute at subscript if any, else empty attribute.
	//<summary>Access or create the attribute having 'name'.</summary>
	//<param name="name">Name of attribute to access/create.</param>
	//<returns>Reference to xml_attribute wrapper.</returns>
	xml_attribute attribute(const std::string& name){ return attribute(name.c_str()); }
	//<summary>Access or create the attribute having 'name'.</summary>
	//<param name="name">Name of attribute to access/create.</param>
	//<returns>Reference to xml_attribute wrapper.</returns>
	xml_attribute attribute(const TCHAR* name)
	{
		xml_attribute_struct* attr = mapto_attribute_ptr(name);
		if(!attr) attr = append_attribute(name,_T(""));
		return xml_attribute(attr);
	}
	const unsigned int siblings(){ return (!type_document()) ? _root->parent->children : 0; } //Access node's sibling count (parent's child count).
	xml_node sibling(unsigned int i){ return (!type_document() && i < siblings()) ? xml_node(_root->parent->child[i]) : xml_node(); } //Access sibling node at subscript as xml_node or xml_node(NULL) if bad subscript.
	xml_node parent(){ return (!type_document()) ? xml_node(_root->parent) : xml_node(); } //Access node's parent if any, else xml_node(NULL)

	//<summary>Return the first child that has data's data. If none, return NULL.</summary>
	//<param name="value">Returns a copy of the data.</param>
	//<param name="valuelen">Specifies the maximum number of characters to copy into value.</param>
	//<returns>Pointer to value if exists, else NULL.</returns>
	//<remarks>
	//	Used to get the PCDATA for the current element. This handles elements 
	//	like: &lt;LINE&gt;&lt;STAGEDIR&gt;Aside&lt;/STAGEDIR&gt;Thy father, 
	//	Pompey, would ne'er have&lt;/LINE&gt;, where 'this' points to &lt;LINE&gt;.
	//</remarks>
	TCHAR* child_value(TCHAR* value,const unsigned int valuelen)const
	{
		if(_root->children)
		{
			for(register unsigned int i=0; i < _root->children; ++i)
			{
				xml_node_struct* node = _root->child[i];
				if(node->value)
				{
					const unsigned int n =
#ifdef PUGOPT_NONSEG
						min(valuelen,node->value_size);
#else
						min(valuelen,_tcslen(node->value));
#endif
					_tcsncpy(value,node->value,n);
					value[n] = 0;
					break;
				}
			}
			return value;
		}
		return NULL;
	}

//Name-To-Object Mapping
public:

	//<summary>Map an attribute name to a pointer to that attribute, if found.</summary>
	//<param name="name">Reference to name of attribute to find.</param>
	//<returns>Pointer to attribute, or NULL if not found.</returns>
	//<remarks>Implement your own hash table if you have a great many attributes.</remarks>
	xml_attribute_struct* mapto_attribute_ptr(const std::string& name){ return mapto_attribute_ptr(name.c_str()); }

	//<summary>Map an attribute name to a pointer to that attribute, if found.</summary>
	//<param name="name">Pointer to name of attribute to find.</param>
	//<returns>Pointer to attribute, or NULL if not found.</returns>
	//<remarks>Implement your own hash table if you have a great many attributes.</remarks>
	xml_attribute_struct* mapto_attribute_ptr(const TCHAR* name)
	{
		if(!_root || !name) return NULL;
		register unsigned int n = _root->attributes;
#ifdef PUGOPT_NONSEG
		const int namelen = _tcslen(name);
#endif
		for(register unsigned int i=0; i<n; ++i)
#ifdef PUGOPT_NONSEG
			if(matches_attribute_name(name,namelen,i))
#else
			if(matches_attribute_name(name,i))
#endif
				return _root->attribute[i];
		return NULL;
	}

	//<summary>Map an attribute name to the index of that attribute, if found.</summary>
	//<param name="name">Pointer to name of attribute to find.</param>
	//<returns>Index of attribute, or -1 if not found.</returns>
	//<remarks>Implement your own hash table if you have a great many attributes.</remarks>
	int mapto_attribute_idx(const TCHAR* name)
	{
		if(!_root || !name) return -1;
		register unsigned int n = _root->attributes;
#ifdef PUGOPT_NONSEG
		const int namelen = _tcslen(name);
#endif
		for(register unsigned int i=0; i<n; ++i)
#ifdef PUGOPT_NONSEG
			if(matches_attribute_name(name,namelen,i))
#else
			if(matches_attribute_name(name,i))
#endif
				return i;
		return -1;
	}

	//<summary>Map a child name to a pointer to the first instance, if found.</summary>
	//<param name="name">Reference to name of child to find.</param>
	//<returns>Index of child, or -1 if not found.</returns>
	//<remarks>Implement your own hash table if you have a great many children.</remarks>
	xml_node_struct* mapto_child_ptr(const std::string& name){ return mapto_child_ptr(name.c_str()); }

	//<summary>Map a child name to a pointer to the first instance, if found.</summary>
	//<param name="name">Pointer to name of child to find.</param>
	//<returns>Index of child, or -1 if not found.</returns>
	//<remarks>Implement your own hash table if you have a great many children.</remarks>
	xml_node_struct* mapto_child_ptr(const TCHAR* name)
	{
		if(!_root || !name) return NULL;
		register unsigned int n = _root->children;
#ifdef PUGOPT_NONSEG
		const int namelen = _tcslen(name);
#endif
		for(register unsigned int i=0; i<n; ++i)
		{
			if
				(
				_root->child[i]->name &&
#ifdef PUGOPT_NONSEG
				matches_child_name(name,namelen,i)
#else
				matches_child_name(name,i)
#endif
				)
				return _root->child[i];
		}
		return NULL;
	}

	//<summary>Map a child name to the index of the first instance, if found.</summary>
	//<param name="name">Reference to name of child to find.</param>
	//<returns>Index of child, or -1 if not found.</returns>
	//<remarks>Implement your own hash table if you have a great many children.</remarks>
	int mapto_child_idx(const std::string& name){ return mapto_child_idx(name.c_str()); }

	//<summary>Map a child name to the index of the first instance, if found.</summary>
	//<param name="name">Pointer to name of child to find.</param>
	//<returns>Index of child, or -1 if not found.</returns>
	//<remarks>Implement your own hash table if you have a great many children.</remarks>
	int mapto_child_idx(const TCHAR* name)
	{
		if(!_root || !name) return -1;
		register unsigned int n = _root->children;
#ifdef PUGOPT_NONSEG
		const int namelen = _tcslen(name);
#endif
		for(register unsigned int i=0; i<n; ++i)
		{
			if
				(
				_root->child[i]->name &&
#ifdef PUGOPT_NONSEG
				matches_child_name(name,namelen,i)
#else
				matches_child_name(name,i)
#endif
				)
				return i;
		}
		return -1;
	}

//Traversal Helpers
public:

	//<summary>Find all elements having the given name.</summary>
	//<param name="name">Reference to name of child to find.</param>
	//<param name="found">Reference to xml_node_list or pointer_array to receive the matching elements.
	void all_elements_by_name(const std::string& name,pointer_array& found){ all_elements_by_name(name.c_str(),found); }

	//<summary>Find all elements having the given name.</summary>
	//<param name="name">Pointer to name of child to find.</param>
	//<param name="found">Reference to xml_node_list or pointer_array to receive the matching elements.</param>
	void all_elements_by_name(const TCHAR* name,pointer_array& found)
	{
		if(empty() || !name) return; //Invalid node, so fail.
		if(_root->children > 0) //Has children.
		{
#ifdef PUGOPT_NONSEG
			const unsigned int namelen = _tcslen(name);
#endif
			register unsigned int n = _root->children; //For each child.
			for(register unsigned int i=0; i<n; ++i)
			{
				if
					(
					_root->child[i] && //There is a child at i.
					_root->child[i]->name && //The child has a name.
#ifdef PUGOPT_NONSEG
					matches_child_name(name,namelen,i)
#else
					matches_child_name(name,i)
#endif
					)
					found.push_back(_root->child[i]); //push_back it to the array.
				if(_root->child[i]->children) //If there are children.
				{
					xml_node subsearch(_root->child[i]); //Wrap it up for ease.
					subsearch.all_elements_by_name(name,found); //Find any matching children.
				}
			}
		}
	}

	//<summary>
	//	Recursively-implemented depth-first find the first matching element. 
	//	Use for shallow drill-downs.
	//</summary>
	//<param name="name">Const reference to name of element to find.</param>
	//<returns>Valid xml_node if such element named 'name' is found.</returns>
	//<remarks>xml_node may be invalid if not found; test with 'empty'.</remarks>
	xml_node first_element_by_name(const std::string& name){ return first_element_by_name(name.c_str()); }

	//<summary>
	//	Recursively-implemented depth-first find the first matching element. 
	//	Use for shallow drill-downs.
	//</summary>
	//<param name="name">Pointer to name of element to find.</param>
	//<returns>Valid xml_node if such element named 'name' is found.</returns>
	//<remarks>xml_node may be invalid if not found; test with 'empty'.</remarks>
	xml_node first_element_by_name(const TCHAR* name)
	{
		if(empty() || !name) return xml_node(); //Invalid node, so fail.
		if(_root->children > 0) //Has children.
		{
			register unsigned int n = _root->children; //For each child.
#ifdef PUGOPT_NONSEG
			const int namelen = _tcslen(name);
#endif
			for(register unsigned int i=0; i<n; ++i)
			{
				if
				(
					_root->child[i]->name &&
#ifdef PUGOPT_NONSEG
					matches_child_name(name,namelen,i)
#else
					matches_child_name(name,i)
#endif
				)
					return xml_node(_root->child[i]);
				else if(_root->child[i]->children)
				{
					xml_node subsearch(_root->child[i]); //Wrap it up for ease.
					xml_node found = subsearch.first_element_by_name(name);
					if(!found.empty()) return found; //Found.
				}
			}
		}
		return xml_node(); //Not found.
	}

	//<summary>
	//	Recursively-implemented depth-first find the first matching element 
	//	also having matching PCDATA.
	//</summary>
	//<param name="name">Reference to name of element to find.</param>
	//<param name="value">Reference to PCDATA to find.</param>
	//<returns>Valid xml_node if such element named 'name' is found with PCDATA 'value'.</returns>
	//<remarks>xml_node may be invalid if not found; test with 'empty'.</remarks>
	xml_node first_element_by_value(const std::string& name,const std::string& value){ return first_element_by_value(name.c_str(),value.c_str()); }

	//<summary>
	//	Recursively-implemented depth-first find the first matching element 
	//	also having matching PCDATA.
	//</summary>
	//<param name="name">Pointer to name of element to find.</param>
	//<param name="value">Pointer to PCDATA to find.</param>
	//<returns>Valid xml_node if such element named 'name' is found with PCDATA 'value'.</returns>
	//<remarks>xml_node may be invalid if not found; test with 'empty'.</remarks>
	xml_node first_element_by_value(const TCHAR* name,const TCHAR* value)
	{
		if(empty() || !name || !value) return xml_node(); //Invalid node, so fail.
		if(_root->children > 0) //Has children.
		{
			register unsigned int n = _root->children; //For each child.
#ifdef PUGOPT_NONSEG
			const unsigned int namelen = _tcslen(name);
			const unsigned int valulen = _tcslen(value);
#endif
			for(register unsigned int i=0; i<n; ++i)
			{
				if
				(
					_root->child[i] && //There is a child at i.
					_root->child[i]->name && //The child has a name.
#ifdef PUGOPT_NONSEG
					matches_child_name(name,namelen,i)
#else
					matches_child_name(name,i)
#endif
				)
				{
					register unsigned int m = _root->child[i]->children; //For each child of child.
					for(register unsigned int j=0; j<m; ++j)
					{
						if
						(
							_root->child[i]->child[j] && //There is a child at j.
							_root->child[i]->child[j]->type == node_pcdata && //It is of the PCDATA type.
							_root->child[i]->child[j]->value && //It has data.
#ifdef PUGOPT_NONSEG
							matches_value(value,valulen,_root->child[i]->child[j])
#else
							matches_value(value,_root->child[i]->child[j])
#endif
						)
							return xml_node(_root->child[i]); //Wrap it up and return.
					}
				}
				else if(_root->child[i] && _root->child[i]->children) //The child has children.
				{
					xml_node subsearch(_root->child[i]); //Wrap it up for ease.
					xml_node found = subsearch.first_element_by_value(name,value); //Search any children.
					if(!found.empty()) return found; //Found.
				}
			}
		}
		return xml_node(); //Not found.
	}

	//<summary>
	//	Recursively-implemented depth-first find the first matching element 
	//	also having matching attribute.
	//</summary>
	//<param name="name">Reference to name of element to find.</param>
	//<param name="attr_name">Reference to name of attribute to find.</param>
	//<param name="attr_value">Reference to attribute value to find.</param>
	//<returns>Valid xml_node if such element named 'name' is found.</returns>
	//<remarks>xml_node may be invalid if not found; test with 'empty'.</remarks>
	xml_node first_element_by_attribute(const std::string& name,const std::string& attr_name,const std::string& attr_value){ return first_element_by_attribute(name.c_str(),attr_name.c_str(),attr_value.c_str()); }

	//<summary>
	//	Recursively-implemented depth-first find the first matching element 
	//	also having matching attribute.
	//</summary>
	//<param name="name">Pointer to name of element to find.</param>
	//<param name="attr_name">Pointer to name of attribute to find.</param>
	//<param name="attr_value">Pointer to attribute value to find.</param>
	//<returns>Valid xml_node if such element named 'name' is found.</returns>
	//<remarks>xml_node may be invalid if not found; test with 'empty'.</remarks>
	xml_node first_element_by_attribute(const TCHAR* name,const TCHAR* attr_name,const TCHAR* attr_value)
	{
		if(empty() || !name || !attr_name || !attr_value) return xml_node(); //Invalid data, so fail.
		if(_root->children > 0) //Has children.
		{
#ifdef PUGOPT_NONSEG
			const unsigned int namelen = _tcslen(name);
			const unsigned int attrlen = _tcslen(attr_name);
			const unsigned int valulen = _tcslen(attr_value);
#endif
			register unsigned int n = _root->children; //For each child.
			for(register unsigned int i=0; i<n; ++i)
			{
				if
				(
					_root->child[i] && //There is a child at i.
					_root->child[i]->name && //The child has a name.
#ifdef PUGOPT_NONSEG
					matches_name(name,namelen,_root->child[i])
#else
					matches_name(name,_root->child[i])
#endif
				)
				{
					register unsigned int m = _root->child[i]->attributes; //For each attribute of child.
					for(register unsigned int j=0; j<m; ++j)
					{
						if
						(
							_root->child[i]->attribute[j] && //There is an attribute at j.
							_root->child[i]->attribute[j]->name && //The attribute has a name.
#ifdef PUGOPT_NONSEG
							matches_attribute_name(attr_name,attrlen,_root->child[i]->attribute[j]) &&
#else
							matches_attribute_name(attr_name,_root->child[i]->attribute[j]) &&
#endif
							_root->child[i]->attribute[j]->value && //The attribute has a value.
#ifdef PUGOPT_NONSEG
							matches_attribute_name_value(attr_value,valulen,_root->child[i]->attribute[j])
#else
							matches_attribute_name_value(attr_value,_root->child[i]->attribute[j])
#endif
						)
							return xml_node(_root->child[i]); //Wrap it up and return.
					}
				}
				else if(_root->child[i] && _root->child[i]->children)
				{
					xml_node subsearch(_root->child[i]); //Wrap it up for ease.
					xml_node found = subsearch.first_element_by_attribute(name,attr_name,attr_value); //Search any children.
					if(!found.empty()) return found; //Found.
				}
			}
		}
		return xml_node(); //Not found.
	}

	//<summary>
	//	Recursively-implemented depth-first find the first matching entity. 
	//	Use for shallow drill-downs.
	//</summary>
	//<param name="name">Pointer to name of element to find.</param>
	//<returns>Valid xml_node if such element named 'name' is found.</returns>
	//<remarks>xml_node may be invalid if not found; test with 'empty'.</remarks>
	xml_node first_node(xml_node_type type)
	{
		if(!_root) return xml_node();
		if(_root->children > 0) //Has children.
		{
			register unsigned int n = _root->children; //For each child.
			for(register unsigned int i=0; i<n; ++i)
			{
				if(_root->child[i]->type==type)
					return xml_node(_root->child[i]);
				else if(_root->child[i]->children)
				{
					xml_node subsearch(_root->child[i]);
					xml_node found = subsearch.first_node(type);
					if(!found.empty()) return found; //Found.
				}
			}
		}
		return xml_node(); //Not found.
	}

	//<summary>Move to the absolute root of the document tree.</summary>
	//<returns>True if the current node is valid.</returns>
	//<remarks>Member '_root' may now point to absolute root of the document.</remarks>
	bool moveto_root()
	{
		if(empty()) return false; //Nowhere to go.
		while(!type_document()) _root = _root->parent; //Keep stepping out until we hit the root.
		return true; //Success.
	}

	//<summary>Move to the current node's parent.</summary>
	//<returns>true if there is a parent and cursor is not parent, and cursor points thereto.</returns>
	//<remarks>'_root' may now point to parent.</remarks>
	bool moveto_parent()
	{
		if(empty() || type_document()) return false; //Invalid, or at the root (has no parent).
		_root = _root->parent; //Move to parent.
		return true; //Success.
	}

	//<summary>
	//	Move to the current node's sibling at subscript. Equivalent to 
	//	'moveto_child' following 'moveto_parent'.
	//</summary>
	//<param name="i">Subscript of sibling to move cursor to.</param>
	//<returns>True if valid subscript, and cursor points thereto.</returns>
	//<remarks>If matching co-node was found, '_root' points thereto.</remarks>
	bool moveto_sibling(unsigned int i)
	{
		if(empty()) return false; //Nowhere to go.
		xml_node_struct* restore = _root; //Save position in case invalid subscript & we want to restore.
		if(moveto_parent()) //Try to move to parent.
		{
			if(i < children()) //Subscript is in range. (Assume parent *does* have children.)
			{
				_root = _root->child[i]; //Move to child at subscript ('sibling').
				return true; //Success.
			}
		}
		_root = restore; //Bad subscript, or parent move; restore.
		return false;
	}

	//<summary>Move to the current node's first sibling matching given name.</summary>
	//<param name="name">Element name of sibling to move to.</param>
	//<returns>True if sibling was found, and cursor points thereto.</returns>
	//<remarks>If matching co-node was found, '_root' points thereto.</remarks>
	bool moveto_first_sibling(const std::string& name){ return moveto_first_sibling(name.c_str()); }

	//<summary>Move to the current node's first sibling matching given name.</summary>
	//<param name="name">Element name of sibling to move to.</param>
	//<returns>True if sibling was found, and cursor points thereto.</returns>
	//<remarks>If matching co-node was found, '_root' points thereto.</remarks>
	bool moveto_first_sibling(const TCHAR* name)
	{
		if(empty() || !name) return false; //Nowhere to go, or nothing to find.
		xml_node_struct* restore = _root; //Save position in case invalid subscript & we want to restore.
		if(moveto_parent()) //Try to move to parent.
		{
#ifdef PUGOPT_NONSEG
			const unsigned int namelen = _tcslen(name);
#endif
			register unsigned int n = children(); //Search for matching name
			for(register unsigned int i=0; i<n; ++i)
			{
				//NF 24 Jan 2003 Changed to get child(i) just once per iteration.
				xml_node node = child(i); //Access child node at subscript as xml_node or xml_node(NULL) if bad subscript.
				if(node.type_element()||node.type_pi()) //Other types won't have names.
				{
#ifdef PUGOPT_NONSEG
					if(_tcsncmp(name,node.name(),max(namelen,node.name_size()))==0) //Do names match?
#else
					if(strcmpwild(name,node.name())==0) //Do names match?
#endif
					{
						_root = node; //Move there.
						return true; //Success.
					}
				}
			}
		}
		_root = restore; //Failed to locate any such sibling; restore position.
		return false;
	}

	//<summary>Move to the current node's child at subscript.</summary>
	//<param name="i">Subscript of child to move cursor to.</param>
	//<returns>true if valid subscript, and cursor points thereto.</returns>
	//<remarks>If matching sub-node was found, '_root' points thereto.</remarks>
	bool moveto_child(unsigned int i)
	{
		if(empty()) return false; //Null, so no children.
		if(has_child_nodes() && i < children()) //Has children and subscript is in bounds.
		{
			_root = child(i); //Move to the child at i.
			return true; //Success.
		}
		return false; //Failure.
	}

	//<summary>Move to the current node's child matching given name.</summary>
	//<param name="name">Element name of child to move to if found.</param>
	//<returns>True if child was found, and cursor points thereto.</returns>
	//<remarks>If matching sub-node was found, '_root' points thereto.</remarks>
	bool moveto_child(const std::string& name){ return moveto_child(name.c_str()); }

	//<summary>Move to the current node's child matching given name.</summary>
	//<param name="name">Element name of child to move to if found.</param>
	//<returns>True if child was found, and cursor points thereto.</returns>
	//<remarks>If matching sub-node was found, '_root' points thereto.</remarks>
	bool moveto_child(const TCHAR* name)
	{
		if(empty() || !name || !has_child_nodes()) return false; //The node is null, a name was not specified, or node has no children.
#ifdef PUGOPT_NONSEG
		const unsigned int namelen = _tcslen(name);
#endif
		register unsigned int n = children(); //For each child.
		for(register unsigned int i=0; i<n; ++i)
		{
			//NF 24 Jan 2003: Changed to get child(i) just once per iteration.
			xml_node node = child(i); //Access child node at subscript as xml_node or xml_node(NULL) if bad subscript.
#ifdef PUGOPT_NONSEG
			if(_tcsncmp(name,node.name(),max(namelen,node.name_size()))==0) //Do names match?
#else
			if(strcmpwild(name,node.name())==0) //If the name is identical with 'name'.
#endif
			{
				_root = node; //Move to it.
				return true; //Success.
			}
		}
		return false; //Failure.
	}

	//<summary>Move to the current node's next sibling by position and name.</summary>
	//<param name="name">Name of sibling to move to if found.</param>
	//<returns>True if there is a next sibling, and cursor points thereto.</returns>
	bool moveto_next_sibling(const std::string& name){ return moveto_next_sibling(name.c_str()); }

	//<summary>Move to the current node's next sibling by position and name.</summary>
	//<param name="name">Name of sibling to move to if found.</param>
	//<returns>True if there is a next sibling, and cursor points thereto.</returns>
	bool moveto_next_sibling(const TCHAR* name)
	{
		if(empty() || type_document() || !_root->parent || !name) return false; //Null, or at root, or no name, so there are no valid matches.
#ifdef PUGOPT_NONSEG
		const unsigned int namelen = _tcslen(name);
#endif
		register unsigned int n = _root->parent->children; //For each child of parent.
		for(register unsigned int i=0; i<(n-1); ++i)
		{
			if
			(
				_root->parent->child[i] && //There is a child at i.
				_root->parent->child[i] == _root && //The child is identical with this node.
				i < (n-1) //This is not the last child.
			)
			{
				for(++i; i<n; ++i) //For each following child.
				{
					if
					(
						_root->parent->child[i] && //There is a child at i.
						_root->parent->child[i]->name && //The child's name is not null.
#ifdef PUGOPT_NONSEG
						matches_name(name,namelen,_root->parent->child[i])
#else
						matches_name(name,_root->parent->child[i])
#endif
					)
					{
						moveto_sibling(i); //Move to it.
						return true; //Success.
					}
				}
			}
		}
		return false; //Failure.
	}

	//<summary>Move to the current node's next sibling by position.</summary>
	//<returns>True if there is a next sibling, and cursor points thereto.</returns>
	bool moveto_next_sibling()
	{
		if(empty() || type_document() || !_root->parent) return false; //Null or at root, so there are no valid siblings.
		register unsigned int n = _root->parent->children; //For each child of parent (each sibling).
		for(register unsigned int i=0; i<(n-1); ++i)
		{
			if
			(
				_root->parent->child[i] && //There is a child at i.
				_root->parent->child[i] == _root && //The child is identical with this node.
				i < (n-1) //This is not the last child.
			)
			{
				for(++i; i<n; ++i) //For each following child.
				{
					if(_root->parent->child[i]) //There is a child at i.
					{
						moveto_sibling(i); //Move to it.
						return true; //Success.
					}
				}
			}
		}
		return false; //Failure.
	}

	//<summary>Compile the absolute node path from root as a text string.</summary>
	//<param name="delimiter">Delimiter string to insert between element names.</param>
	//<returns>Path string (e.g. with '/' as delimiter, '/document/.../this'.</returns>
//	std::string path(const TCHAR* delimiter = _T("/"))
//	{
//		TCHAR* path = NULL; //Current path.
//		TCHAR* temp; //Temporary pointer.
//		xml_node cursor = *this; //Make a copy.
//#ifdef PUGOPT_NONSEG
//		unsigned int destlen = 0;
//		strcatgrown_impl(&path,cursor.name(),destlen,cursor.name_size()); //Get this name.
//#else
//		strcatgrow(&path,cursor.name()); //Get this name.
//#endif
//		while(cursor.moveto_parent() && !cursor.type_document()) //Loop to parent (stopping on actual root because it has no name).
//		{
//			temp = NULL; //Mark as null so 'strcatgrow' will allocate memory.
//#ifdef PUGOPT_NONSEG
//			destlen = 0;
//			strcatgrown_impl(&temp,cursor.name(),destlen,cursor.name_size()); //Append next element name.
//#else
//			strcatgrow(&temp,cursor.name()); //Append next element name.
//#endif
//			strcatgrow(&temp,delimiter); //Append delimiter.
//			strcatgrow(&temp,path); //Append current path.
//			free(path); //Free the old path.
//			path = temp; //Set path as new string.
//		}
//		temp = NULL;
//		strcatgrow(&temp,delimiter); //Prepend final delimiter.
//		strcatgrow(&temp,path); //Append current path.
//		free(path); //Free the old path.
//		std::string returns = temp; //Set path as new string.
//		free(temp);
//		return returns; //Return the path;
//	}
	
	//<summary>Search for a node by path.</summary>
	//<param name="path">
	//	Path string; e.g. './foo/bar' (relative to node), '/foo/bar' (relative 
	//	to root), '../foo/bar' (pop relative position).
	//</param>
	//<param name="delimiter">Delimiter string to use in tokenizing path.</param>
	//<returns>Matching node, or xml_node(NULL) if not found.</returns>
	//xml_node first_element_by_path(const std::string& path,const std::string& delimiter = "/"){ return first_element_by_path(path.c_str(),delimiter.c_str()); }

	//<summary>Search for a node by path.</summary>
	//<param name="path">
	//	Path string; e.g. './foo/bar' (relative to node), '/foo/bar' (relative 
	//	to root), '../foo/bar' (pop relative to position).
	//</param>
	//<param name="delimiter">Delimiter string to use in tokenizing path.</param>
	//<returns>Matching node, or xml_node(NULL) if not found.</returns>
	//<remarks>To-do: Support XPath-style queries.</remarks>
	xml_node first_element_by_path(const TCHAR* path,const TCHAR* delimiter = _T("/"))
	{
		if(!path) return xml_node();
		TCHAR* temp = NULL;
		pointer_array path_segments; //Array of path segments.
		xml_node found = *this; //Current search context.
		strcatgrow(&temp,path);
		TCHAR* name = _tcstok(temp,delimiter);
		while(name) //Tokenize the whole path.
		{
			path_segments.push_back((void*)name); //push_back it to array.
			name = _tcstok(NULL,delimiter); //Get the next token,
		}
		register unsigned int n = path_segments.size();
		if(n == 0) return xml_node(); //Return null node if no path segments.
		if(path[0]==delimiter[0]) found.moveto_root(); //Absolute path; e.g. '/foo/bar'
		for(register unsigned int i = 0; i<n; ++i) //For each path segment.
		{
			name = (TCHAR*)path_segments.at(i);
			if(name)
			{
				if(*name==_T('.')) //Is '.' or '..'
				{
					if(_tcscmp(name,_T(".."))==0) found.moveto_parent(); //Pop.
					else continue; //Ignore '.' since it is redundant if path is './path'.
				}
				else
				{
					register unsigned int j, m = found.children(); //For each child.
					for(j=0; j<m; ++j)
					{
						if(found.child(j).has_name(name)) //Name matches?
						{
							found = found.child(j); //Move to this child.
							goto NEXT_ELEM; //Search next path segment.
						}
					}
					if(found.moveto_next_sibling(found.name())) //Find next sibling having same name.
					{
						if(i > 0) --i; //Try the previous path segment.
						goto NEXT_ELEM;
					}
					else //Move to parent to search further.
					{
						if(!found.type_document() && found.moveto_parent() && !found.type_document()) //Not root and stepped to parent and parent is not root.
						{
							if(i > 0) --i; //Try the previous path segment.
							if(found.moveto_next_sibling(found.name())) //Try to find next sibling having same name.
							{
								if(i > 0) --i; //Try the previous path segment.
								goto NEXT_ELEM;
							}
						}
					}
				}
			}
NEXT_ELEM:;
			if(found.type_document()) //Can't move up any higher, so fail.
			{
				free(temp); //Got to free this.
				return xml_node(); //Return null node.
			}
		}
		free(temp); //Got to free this.
		return found; //Return the matching node.
	}

	//<summary>Recursively traverse the tree.</summary>
	//<param name="walker">Reference to tree walker derived from xml_tree_walker.</param>
	//<returns>True if traversal was not halted by xml_tree_walker::for_each() callback.</returns>
	bool traverse(xml_tree_walker& walker)
	{
		if(walker.depth() == 0 && !walker.begin(*this)) return false; //Send the callback for begin traverse if depth is zero.
		if(!empty()) //Don't traveres if this is a null node.
		{
			walker.push(); //Increment the walker depth counter.
			register unsigned int n = _root->children; //For each child.
			for(register unsigned int i=0; i<n; ++i)
			{
				if(_root->child[i]) //There is a child at i.
				{
					xml_node subsearch(_root->child[i]); //Wrap it.
					if(!(walker.for_each(subsearch) && subsearch.traverse(walker)))
						return false; //Traversal was aborted.
				}
			}
			walker.pop(); //Decrement the walker depth counter.
		}
		if(walker.depth() == 0 && !walker.end(*this)) return false; //Send the callback for end traverse if depth is zero.
		return true;
	}

//Editorial Helpers
public:

	//<summary>Set element name.</summary>
	//<param name="new_name">New element name.</param>
	//<returns>Success.</returns>
	bool name(const std::string& new_name){ return name(new_name.c_str()); }

	//<summary>Set element name.</summary>
	//<param name="new_name">New element name.</param>
	//<returns>Success.</returns>
	bool name(const TCHAR* new_name)
	{
		if((type_element() || type_pi()) && new_name)
#ifdef PUGOPT_NONSEG
			return strcpyinsitu(&_root->name,new_name,&_root->name_insitu,_root->name_size );
#else
			return strcpyinsitu(&_root->name,new_name,&_root->name_insitu);
#endif
		return false;
	}

	//<summary>Set node data.</summary>
	//<param name="value">New data (PCDATA, CDATA, or comment) value.</param>
	//<returns>Success.</returns>
	bool value(const std::string& new_value){ return value(new_value.c_str()); }

	//<summary>Set node data.</summary>
	//<param name="value">New data (PCDATA, CDATA, or comment) value.</param>
	//<returns>Success.</returns>
	bool value(const TCHAR* new_value)
	{
		if((type_pcdata() || type_cdata() || type_comment()) && new_value)
#ifdef PUGOPT_NONSEG
			return strcpyinsitu(&_root->value,new_value,&_root->value_insitu,_root->value_size);
#else
			return strcpyinsitu(&_root->value,new_value,&_root->value_insitu);
#endif
		return false;
	}

	//<summary>Remove attribute at the given subscript.</summary>
	//<param name="i">Subscript.</param>
	//<returns>Success.</returns>
	bool remove_attribute(unsigned int i)
	{
		unsigned int n = _root->attributes;
		if(i < n)
		{
			xml_attribute_struct* temp = _root->attribute[i];
			--n;
			for(unsigned int j=i; j<n; ++j)
				_root->attribute[j] = _root->attribute[j+1];
			_root->attribute[n] = NULL;
			if(!temp->name_insitu) free(temp->name);
			if(!temp->value_insitu) free(temp->value);
			free(temp);
			--_root->attributes;
			return true;
		}
		return false;
	}

	//<summary>Remove attribute having the given name.</summary>
	//<param name="name">Name of attribute to delete.</param>
	//<returns>Success.</returns>
	bool remove_attribute(const std::string& name){ return remove_attribute(name.c_str()); }

	//<summary>Remove attribute having the given name.</summary>
	//<param name="name">Name of attribute to delete.</param>
	//<returns>Success.</returns>
	bool remove_attribute(const TCHAR* name)
	{
		int i = mapto_attribute_idx(name);
		if(i > -1) return remove_attribute((unsigned int)i);
		return false;
	}

	//<summary>Append a new attribute to the node list of attributes.</summary>
	//<param name="name">Name.</param>
	//<param name="value">Value thereof.</param>
	//<returns>Attribute structure wrapper.</returns>
	//<remarks>Pointer space may be grown, memory for name/value members allocated.</remarks>
	xml_attribute append_attribute(const std::string& name,const std::string& value){ return append_attribute(name.c_str(),value.c_str()); }

	//<summary>Append a new attribute to the node list of attributes.</summary>
	//<param name="name">Name.</param>
	//<param name="value">Value thereof.</param>
	//<returns>Attribute structure wrapper.</returns>
	//<remarks>Pointer space may be grown, memory for name/value members allocated.</remarks>
	xml_attribute append_attribute(const TCHAR* name,const TCHAR* value)
	{
		if(!name || !value) return xml_attribute(); //We must have both to proceed.
		xml_attribute_struct* p = pug::append_attribute(_root,1); //Append/allocate a new attribute structure.
		if(p) //If append/allocate succeeded.
		{
#ifdef PUGOPT_NONSEG
			strcatgrown(&p->name,name,p->name_size); //Append the name.
			strcatgrown(&p->value,value,p->value_size); //Append the name.
#else
			strcatgrow(&p->name,name); //Append the name.
			strcatgrow(&p->value,value); //Append the name.
#endif
			p->name_insitu = p->value_insitu = false; //Mark as not part of original parse string.
			return xml_attribute(p); //Success.
		}
		return xml_attribute(); //Failure; return an empty.
	}

	//<summary>Append a new attribute of type long to the node list of attributes.</summary>
	//<param name="name">Name.</param>
	//<param name="value">Value thereof.</param>
	//<returns>Attribute structure wrapper.</returns>
	//<remarks>Pointer space may be grown, memory for name/value members allocated.</remarks>
	xml_attribute append_attribute(const TCHAR* name,long value)
	{
		if(!name) return false;
		TCHAR temp[32] = {0};
		_stprintf(temp,_T("%ld"),value);
		return append_attribute(name,temp);
	}

	//<summary>Append a new attribute of type double to the node list of attributes.</summary>
	//<param name="name">Name.</param>
	//<param name="value">Value thereof.</param>
	//<returns>Attribute structure wrapper.</returns>
	//<remarks>Pointer space may be grown, memory for name/value members allocated.</remarks>
	xml_attribute append_attribute(const TCHAR* name,double value)
	{
		if(!name) return false;
		TCHAR temp[32] = {0};
		_stprintf(temp,_T("%lf"),value);
		return append_attribute(name,temp);
	}

	//<summary>Append a new attribute of type bool to the node list of attributes.</summary>
	//<param name="name">Name.</param>
	//<param name="value">Value thereof.</param>
	//<returns>Attribute structure wrapper.</returns>
	//<remarks>Pointer space may be grown, memory for name/value members allocated.</remarks>
	xml_attribute append_attribute(const TCHAR* name,bool value)
	{
		if(!name) return false;
		return append_attribute(name,((value)?_T("true"):_T("false")));
	}

	//<summary>Set the current node entity type.</summary>
	//<param name="new_type">New type to set.</param>
	//<returns>Previous type.</returns>
	//<remarks>If has children and now is not node_element, children are obscured.</remarks>
	xml_node_type type(xml_node_type new_type)
	{
		xml_node_type prev = _root->type; //Save old type.
		_root->type = new_type; //Set new type.
		return prev; //Return old type.
	}

	//<summary>
	//	Allocate & append a child node of the given type at the end of the 
	//	current node array of children.
	//</summary>
	//<param name="type">New child node type.</param>
	//<returns>xml_node wrapping the new child.</returns>
	//<remarks>Pointer space may be grown. An xml_node_struct structure is allocated.</remarks>
	xml_node append_child(xml_node_type type)
	{
		if(type_document()||type_element()) //Don't do anything if not an node_element or root.
		{
			xml_node_struct* p = pug::append_node(_root,1,type); //Append the node.
			if(p)
			{
				p->name_insitu = p->value_insitu = false;
				return xml_node(p); //If we have it, return wrapped.
			}
		}
		return xml_node(); //Return dummy.
	}

	//<summary>Allocate & insert a child node of the given type at subscript.</summary>
	//<param name="i">Subscript at which to insert.</param>
	//<param name="type">New child node type.</param>
	//<returns>xml_node wrapping the new child.</returns>
	//<remarks>
	//	Pointer space may be grown. An xml_node_struct structure is allocated, 
	//	and existing children are shifted in their array position.
	//</remarks>
	xml_node insert_child(unsigned int i,xml_node_type type)
	{
		if(!type_element()) return xml_node(); //Don't do anything if not an node_element.
		unsigned int n = _root->children; //Get count of existing children.
		if(type_element() && i >= n) return append_child(type); //If subscript at end of array then just append.
		else if(type_element() && i < n)
		{
			xml_node_struct* p = pug::append_node(_root,1,type); //Append the new node (by default at last array position).
			if(p) //Ensure we have it.
			{
				register int m = (i-1); //Stop at i.
				for(register int j=(n-1); j>m; --j) //Starting at one less than end of array, reverse loop to i.
					_root->child[j+1] = _root->child[j]; //Shift node to right.
				_root->child[i] = p; //Set node at subscript to new node.
				return xml_node(p); //Return new node.
			}
		}
		return xml_node(); //Return dummy.
	}

	//<summary>Delete the child node at the given subscript.</summary>
	//<param name="i">Subscript.</param>
	//<returns>Success.</returns>
	//<remarks>Shifts child array element positions. Frees entire tree under child to be deleted.</remarks>
	bool remove_child(unsigned int i)
	{
		unsigned int n = _root->children;
		if(i < n) //Ensure subscript is in bounds.
		{
			xml_node_struct* p = _root->child[i]; //Keep a pointer to this node so we can free it.
			--n;
			unsigned int j=i;
			for(; j<n; ++j) //Shift everything left from this point on.
				_root->child[j] = _root->child[j+1];
			_root->child[j] = NULL; //Mark the last element null.
			--_root->children; //One less children.
			p->parent = p; //This ensures we only free this node when calling 'free_node'.
			pug::free_node(p); //Free the node tree.
			return true; //Success.
		}
		return false; //Failure.
	}

	//Stream/Output Helpers
public:

	//<summary>
	//	Stream output. Recursively writes the internal xml_node_struct structure 
	//	to the given stream.
	//</summary>
	//<param name="os">Reference to output stream.</param>
	//<param name="indent_char">Char to use for indent.</param>
	//<param name="breaks">Use linebreaks?</param>
	//<remarks>String data is written to stream.</remarks>
	void outer_xml(std::basic_ostream<TCHAR,std::char_traits<TCHAR> >& os,TCHAR indent_char = _T('\t'),bool breaks = true)
	{
		if(empty()) return; //Make sure there is something to output.
		indent_stack indent(indent_char); //Prepare the indent.
		if(type_document()) //If this is the root, we don't want to output the root itself.
		{
			register unsigned int n = _root->children; //Output each child of the root.
			for(register unsigned int i=0; i<n; ++i)
				pug::outer_xml(os,indent,_root->child[i],breaks);
		}
		else pug::outer_xml(os,indent,_root,breaks); //Output the node.
	}

	//<summary>
	//	Stream output operator. Wraps 'outer_xml'. Recursively writes 
	//	the given node to the given stream.
	//</summary>
	//<param name="os">Reference to output stream.</param>
	//<param name="xml_node">Reference to tree node.</param>
	//<returns>Reference to output stream.</returns>
	//<remarks>String data is written to stream.</remarks>
	friend std::basic_ostream<TCHAR,std::char_traits<TCHAR> >& operator<<(std::basic_ostream<TCHAR,std::char_traits<TCHAR> >& os,xml_node node)
	{
		if(!os.good()) return os;
		if((os.flags()|std::ostream::skipws) == std::ostream::skipws)
			node.outer_xml(os,0,false); //Skipping whitespace; suppress indents & linebreaks.
		else node.outer_xml(os); //Default options.
		return os;
	}
};


//<summary>Provides a high-level interface to the XML parser.</summary>
class xml_parser
{
//Internal Data Members
protected:

	xml_node_struct*	_xmldoc; //Pointer to current XML document tree root.
	long				_growby; //Attribute & child pointer space growth increment.
	bool				_autdel; //Delete the tree on destruct?
	TCHAR*				_buffer; //Pointer to in-memory buffer (for 'parse_file').
	TCHAR*				_strpos; //Where parsing left off (for 'parse_file').
	unsigned long		_optmsk; //Parser options.
#ifdef PUGOPT_MEMFIL
	HANDLE				_mmfile; //File handle.
	HANDLE				_mmfmap; //Handle which maps the file.
	void*				_mmaddr; //Base address of map.
	size_t				_mfsize; //Size of memory-mapped file.
	bool				_addeos; //True if we had to add a 0 to then end of the file.
#endif

//Construction/Destruction
public:

	//<summary>Constructor.</summary>
	//<param name="optmsk">Options mask.</param>
	//<param name="autdel">Delete tree on destruct?</param>
	//<param name="growby">Parser pointer space growth increment.</param>
	//<remarks>Root node structure is allocated.</remarks>
	xml_parser(unsigned long optmsk = parse_default,bool autdel = true,long growby = parse_grow):
		_xmldoc(0),
			_growby(growby),
			_autdel(autdel),
			_optmsk(optmsk),
			_buffer(0),
			_strpos(0)
#ifdef PUGOPT_MEMFIL
			,
			_mmfile(0),
			_mmfmap(0),
			_mmaddr(0),
			_mfsize(0),
			_addeos(false)
#endif
		{
		}

		//<summary>Direct parse constructor.</summary>
		//<param name="xmlstr">
		//	XML-formatted string to parse. Note: String must persist for the 
		//	life of the tree. String is zero-segmented, but not freed.
		//</param>
		//<param name="optmsk">Parser options.</param>
		//<param name="autdel">Delete tree on destruct?</param>
		//<param name="growby">Parser pointer space growth increment.</param>
		//<remarks>Root node structure is allocated, string is parsed & tree may be grown.</remarks>
		xml_parser(TCHAR* xmlstr,unsigned long optmsk = parse_default,bool autdel = true,long growby = parse_grow) :
		_xmldoc(0),
			_growby(growby),
			_autdel(autdel),
			_optmsk(optmsk),
			_buffer(0),
			_strpos(0)
#ifdef PUGOPT_MEMFIL
			,
			_mmfile(0),
			_mmfmap(0),
			_mmaddr(0),
			_mfsize(0),
			_addeos(false)
#endif
		{
			parse(xmlstr,_optmsk); //Parse it.
		}

		//<summary>Destructor.</summary>
		//<remarks>Tree memory and string memory may be freed.</remarks>
		virtual ~xml_parser()
		{
			if(_autdel && _xmldoc) free_node(_xmldoc);
			if(_buffer) free(_buffer);
#ifdef PUGOPT_MEMFIL
			close_memfile();
#endif
		}

//Accessors/Operators
public:

	operator xml_node_struct*() { return _xmldoc; } //Cast as xml_node_struct pointer to root.
	operator xml_node() { return xml_node(_xmldoc); } //Cast as xml_node (same as document).
	xml_node document(){ return xml_node(_xmldoc); } //Returns the root wrapped by an xml_node.

//Miscellaneous
public:

	//<summary>Allocate a new, empty root.</summary>
	//<remarks>Tree memory and string memory may be freed.</remarks>
	void create()
	{
		clear(); //Free any allocated memory.
		_xmldoc = new_node(node_document); //Allocate a new root.
		_xmldoc->parent = _xmldoc; //Point to self.
	}

	//<summary>Clear any existing tree or string.</summary>
	//<remarks>Tree memory and string memory may be freed.</remarks>
	void clear()
	{
		if(_xmldoc){ free_node(_xmldoc); _xmldoc = 0; }
		if(_buffer){ free(_buffer); _buffer = 0; }
#ifdef PUGOPT_MEMFIL
		close_memfile();
#endif
	}

#ifdef PUGOPT_MEMFIL

//Memory-Mapped File Support
protected:

	//<summary>Closes any existing memory-mapped file.</summary>
	void close_memfile()
	{
		if(_mmaddr != 0)
		{
			UnmapViewOfFile(_mmaddr);
			_mmaddr = 0;
		}
		if(_mmfmap != 0)
		{
			CloseHandle(_mmfmap);
			_mmfmap = 0;
		}
		if(_mmfile != 0)
		{
			if(_addeos) //Remove the 0 we added to the end of the file.
			{
				SetFilePointer(_mmfile,_mfsize,NULL,FILE_BEGIN);
				SetEndOfFile(_mmfile);
				_addeos = false;
			}
			CloseHandle(_mmfile);
			_mmfile = 0;
		}
		_mfsize = 0;
	}

public:

#endif

	//<summary>Attach an externally-generated root to the parser.</summary>
	//<param name="root">Pointer to node structure.</param>
	//<returns>Pointer to old root if any.</returns>
	//<remarks>New root may be deleted on dtor if autodelete set.</remarks>
	xml_node_struct* attach(xml_node_struct* root)
	{
		xml_node_struct* t = _xmldoc; //Save this root.
		_xmldoc = root; //Assign.
		_xmldoc->parent = _xmldoc; //Ensure we are the root.
		return t; //Return the old root if any.
	}

	//<summary>Detach the current root from the parser.</summary>
	//<returns>Pointer to old root, if any.</returns>
	xml_node_struct* detach()
	{
		xml_node_struct* t = _xmldoc; //Save this root.
		_xmldoc = 0; //So we don't delete later on if autodelete set.
		return t; //Return the old root if any.
	}

	//<summary>Get parser optsions mask.</summary>
	//<returns>Options mask.</returns>
	unsigned long options(){ return _optmsk; }

	//<summary>Set parser options mask.</summary>
	//<param name="optmsk">Options mask to set.</param>
	//<returns>Old options mask.</returns>
	unsigned long options(unsigned long optmsk)
	{
		unsigned long prev = _optmsk;
		_optmsk = optmsk;
		return prev;
	}

	//<summary>Get pointer space growth size increment.</summary>
	//<returns>Grow size.</returns>
	unsigned long growby(){ return _growby; }

	//<summary>Set pointer space growth size increment.</summary>
	//<param name="grow">Grow size to set.</param>
	//<returns>Old size.</returns>
	unsigned long growby(long grow)
	{
		long prev = _growby;
		_growby = grow;
		return prev;
	}

	//<summary>Get parse file buffer last string position.</summary>
	//<returns>Last string position.</returns>
	//<remarks>
	//	Use after parse_file, with parse_dtd_only set in order to recommence 
	//	parse of document body.
	//</remarks>
	TCHAR* strpos()
	{
		return _strpos;
	}

//Parsing Helpers
public:

	//<summary>Parse the given XML string in-situ.</summary>
	//<param name="s">Pointer to XML-formatted string.</param>
	//<param name="optmsk">Parser options mask.</param>
	//<returns>Last string position or null.</returns>
	//<remarks>Input string is zero-segmented.</remarks>
	TCHAR* parse(TCHAR* s,unsigned long optmsk = parse_noset)
	{
		if(!s) return s;
		clear(); //Free any allocated memory.
		_xmldoc = new_node(node_document); //Allocate a new root.
		_xmldoc->parent = _xmldoc; //Point to self.
		if(optmsk != parse_noset) _optmsk = optmsk;
		return pug::parse(s,_xmldoc,_growby,_optmsk); //Parse the input string.
	}

	//<summary>Load into memory and parse the contents of the file at the given path.</summary>
	//<param name="path">File path.</param>
	//<param name="optmsk">Parser options.</param>
	//<returns>Success if the file was loaded.</returns>
	//<remarks>
	//	The file contents is loaded and stored in the member '_buffer' until 
	//	freed by calling 'Parse', 'parse_file', 'clear' or '~xml_parser'.
	//</remarks>
	bool parse_file(const TCHAR* path,unsigned long optmsk = parse_noset)
	{
		if(!path) return false;
		clear(); //clear any existing data.
		unsigned long bytes;
		if(optmsk != parse_noset) _optmsk = optmsk;
		if(load_file(path,&_buffer,&bytes) && bytes > 0)
		{
			_xmldoc = pug::new_node(node_document);
			_xmldoc->parent = _xmldoc; //Point to self.
			TCHAR* s = pug::parse(_buffer,_xmldoc,_growby,_optmsk);
			_strpos = s;
			return true;
		}
		return false;
	}

#ifdef PUGOPT_MEMFIL

	//<summary>Parse the contents of the file at the given path, using a memory-mapped file.</summary>
	//<param name="path">File path.</param>
	//<param name="optmsk">Parser options.</param>
	//<returns>
	//	True (1) if the file was parsed successfully, false (0) if open failed, 
	//	and -1 if an exception occured.
	//</returns>
	//<remarks>
	//	The file contents are available until closed by calling 'parse', 
	//	'parse_file', 'clear' or '~xml_parser'.
	//</remarks>
	int parse_mmfile(const TCHAR* path,unsigned long optmsk = parse_noset)
	{
		int status = 0;
		if(path)
		{
			clear(); //Clear any existing data.
			if(optmsk != parse_noset) _optmsk = optmsk;
			assert((optmsk & parse_wnorm) == 0); //Normalization isn't implemented for memory-mapped files, as of 23 Jan 2003.
			const bool readonly = (optmsk & (parse_dtd|parse_dtd_only)) == 0;
			if(open_mmfile(path,readonly,false))
			{
				//If the file has a 0 at the end we are ok to proceed, otherwise add one.
				if
				(
					(
						*(((TCHAR*)_mmaddr) + _mfsize) == 0
						||
						(
							_mfsize > 0 &&
							*(((TCHAR*)_mmaddr) + _mfsize - 1) == 0
						)
					)
					||
					open_mmfile(path,false,true) //Re-open and add 0 at EOF.
				)
				{
					try
					{
						_xmldoc = new_node(node_document);
						_xmldoc->parent = _xmldoc; //Point to self.
						TCHAR* s = pug::parse((TCHAR*)_mmaddr,_xmldoc,_growby,_optmsk);
						_strpos = s;
						status = 1;
					}
					catch(...)
					{
						status = -1;
						assert(false);
					}
				}
			}
		}
		return status;
	}

protected:

	//<summary>Opens the specified memory-mapped file.</summary>
	//<param name="path">File path.</param>
	//<param name="readonly">True to open the file for read-only access.</param>
	//<param name="addeos">True to add a 0 to the end of the file.</param>
	//<returns>Success if the file was opened.</returns>
	bool open_mmfile(const TCHAR* path,const bool readonly,const bool addeos)
	{
		clear(); //Close any existing MMF and clear any existing data.
		assert(_mmfile == NULL && _mmfile == NULL && _mmaddr == NULL);
		_addeos = false;
		_mmfile = CreateFile(path,readonly?GENERIC_READ:GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL); //Open read-only, no share, no security attrs, ..., no template.
		if(_mmfile != INVALID_HANDLE_VALUE)
		{
			_mfsize = ::GetFileSize(_mmfile,NULL);
			_mmfmap = CreateFileMapping(_mmfile,NULL,readonly?PAGE_READONLY:PAGE_READWRITE,0,_mfsize+(addeos?sizeof(TCHAR):0),NULL); //Create map: handle, no security attr, read|read/write, larger if addeos, anonymous.
			if(_mmfmap != NULL)
			{
				assert(_mmaddr == NULL);
				_mmaddr = MapViewOfFile(_mmfmap,readonly?FILE_MAP_READ:FILE_MAP_WRITE,0,0,0); //Map the view: handle, read|read/write, start at beginning, map entire file.
				if(_mmaddr != NULL)
				{
					if(addeos) //Add a terminating 0 to the end of the file for 'parse()'.
					{
						assert(!readonly);
						*(((TCHAR*)_mmaddr) + _mfsize) = 0;
						_addeos = true;
					}
				}
				else
				{
					CloseHandle(_mmfmap);
					CloseHandle(_mmfile);
					_mmfile = _mmfmap = 0;
				}
			}
			else
			{
				CloseHandle(_mmfile);
				_mmfile = 0;
			}
		}
		return (_mmaddr != NULL);
	}

#endif

};


//<summary>An array of nodes, used by xml_node queries.</summary>
class xml_node_list: public pointer_array
{
public:
	xml_node_list(unsigned int grow = 4) : pointer_array(grow) { }
	virtual ~xml_node_list(){ }
public:
	xml_node at(long i){ return xml_node((xml_node_struct*)pointer_array::at((unsigned int)i)); } //Access xml_node at subscript.
	xml_node operator[](long i){ return xml_node((xml_node_struct*)pointer_array::at((unsigned int)i)); } //Access xml_node at subscript.
	friend std::ostream& operator<<(std::ostream& os,xml_node_list& list) //Output helper.
	{
		if(!os.good()) return os;
		unsigned int n = list.size();
		for(unsigned int i=0; i<n; ++i) os << list[i];
		return os;
	}
};


}; //namespace pug


//<summary>Check for Pug XML Library Variant/API Version campatibility.</summary>
#if !defined(PUGAPI_VARIANT) || (PUGAPI_VARIANT != PUGAPI_INTERNAL_VARIANT)
#	pragma message("Severe: The Pug XML library API variant does not match your implementation!")
#	pragma message("Severe: Your implementation may not run correctly with this variant.")
#	pragma message("Note: Read pugxml.xml for transition instructions.")
#	ifndef PUGAPI_VARIANT
#		pragma message("Note: Add #define PUGAPI_VARIANT X in your implementation, where X is:")
#	else //PUGAPI_VARIANT
#		pragma message("Note: Update #define PUGAPI_VARIANT X in your implementation, where X is:")
#	endif //!PUGAPI_VARIANT
#	pragma message("pugxml.h(39) : Value of PUGAPI_INTERNAL_VARIANT.")
#else //defined(PUGAPI_VARIANT)
#	if !defined(PUGAPI_VERSION_MAJOR) || (PUGAPI_VERSION_MAJOR != PUGAPI_INTERNAL_VERSION_MAJOR)
#		pragma message("Warning: The Pug XML library API major version does not match your implementation.")
#		pragma message("Warning: Your implementation may not run correctly with this major version.")
#		pragma message("Note: Read pugxml.xml for transition instructions.")
#		ifndef PUGAPI_VERSION_MAJOR
#			pragma message("Note: Add #define PUGAPI_VERSION_MAJOR X in your implementation, where X is:")
#		else //PUGAPI_VERSION_MAJOR
#			pragma message("Note: Update #define PUGAPI_VERSION_MAJOR X in your implementation, where X is:")
#		endif //!PUGAPI_VERSION_MAJOR
#		pragma message("pugxml.h(44) : Value of PUGAPI_INTERNAL_VERSION_MAJOR.")
#	else //defined(PUGAPI_VERSION_MAJOR)
#		if !defined(PUGAPI_VERSION_MINOR) || (PUGAPI_VERSION_MINOR != PUGAPI_INTERNAL_VERSION_MINOR)
#			pragma message("Note: The Pug XML library API minor version does not match your implementation.")
#			pragma message("Note: Your implementation may not run correctly with this minor version.")
#			pragma message("Note: Read pugxml.xml for transition instructions.")
#			ifndef PUGAPI_VERSION_MINOR
#				pragma message("Note: Add #define PUGAPI_VERSION_MINOR X in your implementation, where X is:")
#			else //PUGAPI_VERSION_MINOR
#				pragma message("Note: Update #define PUGAPI_VERSION_MINOR X in your implementation, where X is:")
#			endif //!PUGAPI_VERSION_MINOR
#			pragma message("pugxml.h(45) : Value of PUGAPI_INTERNAL_VERSION_MINOR.")
#		endif //!defined(PUGAPI_VERSION_MINOR)
#	endif //!defined(PUGAPI_VERSION_MAJOR)
#endif //!defined(PUGAPI_VARIANT)


#endif //!defined(_PUGXML_)

