1 files changed, 0 insertions, 899 deletions
diff --git a/source/NBT.cpp b/source/NBT.cpp
deleted file mode 100644
index ba2f3d0f6..000000000
--- a/source/NBT.cpp
+++ /dev/null
@@ -1,899 +0,0 @@
-
-// NBT.cpp
-
-// Implements the classes used for NBT representation, parsing and serializing
-
-/*
-This file has been retrofitted from a different project of mine (_Xoft(o)) and melded here, so it is not strictyl MCS-styled
-Also the project used error codes, which MCS doesn't need, so they were declared locally only.
-The code is not strictly safe, it could leak pointers when exceptions are thrown. It could use a RAII redesign.
-*/
-
-#include "Globals.h"
-#include "NBT.h"
-#include "Endianness.h"
-
-
-
-
-
-// Error codes
-// Unused by MCS
-enum
-{
-	ERROR_PRIVATE_BASE = 0x00040000,
-	
-	ERROR_PRIVATE_NBTPARSER_BADTYPE,         // The parsed type is not recognized
-	ERROR_PRIVATE_NBTPARSER_INVALIDLENGTH,   // The parsed name has an invalid length (negative-length string etc.)
-	ERROR_PRIVATE_NBTPARSER_UNEXPECTEDTAG,   // The parser has encountered a tag that should not be at such a point
-	ERROR_PRIVATE_NBTPARSER_TOOSHORT,        // The parser was invoked on data that is too short
-	
-	ERROR_PRIVATE_NBT_UNINITIALIZEDLIST,     // NBTList needs its ChildType set before adding items to it
-	ERROR_PRIVATE_NBT_TYPEMISMATCH,          // NBTList must have all of its children of the same type
-	ERROR_PRIVATE_NBT_UNEXPECTEDTAG,         // NBTList and NBTCompound cannot contain a TAG_End
-	ERROR_PRIVATE_NBT_BADTYPE,               // NBTList's children type cannot be set to such a value
-	ERROR_PRIVATE_NBT_LISTNOTEMPTY,          // NBTList must be empty to allow setting children type
-	ERROR_PRIVATE_NBT_INDEXOUTOFRANGE,       // Requesting an item with invalid index from a list or a compound
-
-	ERROR_PRIVATE_UNKNOWN,                   // Unknown error
-} ;
-
-#ifndef ERROR_SUCCESS
-	// This constant is actually #defined in the WinAPI; it cannot be put into the above enum, but needs to be #defined (for *nix)
-	#define ERROR_SUCCESS 0
-#endif  // ERROR_SUCCCESS
-
-#ifndef ERROR_NOT_ENOUGH_MEMORY
-	// This constant is actually #defined in the WinAPI; it cannot be put into the above enum, but needs to be #defined (for *nix)
-	#define ERROR_NOT_ENOUGH_MEMORY 8
-#endif  // ERROR_NOT_ENOUGH_MEMORY
-
-
-
-
-
-#define RETURN_INT_IF_FAILED(X) {int r = X; if (r != ERROR_SUCCESS) return r; }
-
-
-
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// cNBTTag:
-
-cNBTTag * cNBTTag::CreateTag(cNBTTag * a_Parent, eTagType a_Type, const AString & a_Name)
-{
-	// Creates a new instance of a tag specified by a_Type, uses the correct class
-	switch (a_Type)
-	{
-		case TAG_Byte:      return new cNBTByte     (a_Parent, a_Name);
-		case TAG_Short:     return new cNBTShort    (a_Parent, a_Name);
-		case TAG_Int:       return new cNBTInt      (a_Parent, a_Name);
-		case TAG_Long:      return new cNBTLong     (a_Parent, a_Name);
-		case TAG_Float:     return new cNBTFloat    (a_Parent, a_Name);
-		case TAG_Double:    return new cNBTDouble   (a_Parent, a_Name);
-		case TAG_ByteArray: return new cNBTByteArray(a_Parent, a_Name);
-		case TAG_String:    return new cNBTString   (a_Parent, a_Name);
-		case TAG_List:      return new cNBTList     (a_Parent, a_Name, TAG_End);
-		case TAG_Compound:  return new cNBTCompound (a_Parent, a_Name);
-		default:
-		{
-			ASSERT(!"Unknown TAG type requested");
-			return NULL;
-		}
-	}
-}
-
-
-
-
-
-const cNBTTag * cNBTTag::FindChildByPath(const AString & iPath) const
-{
-	size_t PrevIdx = 0;
-	size_t idx = iPath.find('\\');
-	const cNBTTag * res = this;
-	while ((res != NULL) && (idx != AString::npos))
-	{
-		res = res->FindChildByName(AString(iPath, PrevIdx, idx - PrevIdx));
-		PrevIdx = idx + 1;
-		idx = iPath.find('\\', PrevIdx);
-	}
-	if (res != NULL)
-	{
-		res = res->FindChildByName(AString(iPath, PrevIdx));
-	}
-	return res;
-}
-
-
-
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// cNBTList:
-
-void cNBTList::Clear(void)
-{
-	for (cNBTTags::iterator itr = m_Children.begin(); itr != m_Children.end(); ++itr)
-	{
-		delete *itr;
-	}
-	m_Children.clear();
-}
-
-
-
-
-int cNBTList::Add(cNBTTag * iTag)
-{
-	// Catch usage errors while debugging:
-	ASSERT(m_ChildrenType != TAG_End);  // Didn't call SetChildrenType()
-	ASSERT(iTag->GetType() == m_ChildrenType);  // Child of different type
-	
-	// Catch errors while running:
-	if (m_ChildrenType == TAG_End)
-	{
-		return ERROR_PRIVATE_NBT_UNINITIALIZEDLIST;
-	}
-	if (iTag->GetType() != m_ChildrenType)
-	{
-		return ERROR_PRIVATE_NBT_TYPEMISMATCH;
-	}
-	
-	m_Children.push_back(iTag);
-	return ERROR_SUCCESS;
-}
-
-
-
-
-
-int cNBTList::SetChildrenType(cNBTTag::eTagType a_Type)
-{
-	// Catch usage errors while debugging:
-	ASSERT(a_Type != TAG_End);  // Invalid, though not specifically in the NBT spec
-	ASSERT(m_Children.size() == 0);  // Can change only when empty
-	
-	// Catch runtime errors:
-	if (a_Type == TAG_End)
-	{
-		return ERROR_PRIVATE_NBT_BADTYPE;
-	}
-	if (m_Children.size() != 0)
-	{
-		return ERROR_PRIVATE_NBT_LISTNOTEMPTY;
-	}
-	
-	m_ChildrenType = a_Type;
-	return ERROR_SUCCESS;
-}
-
-
-
-
-
-cNBTTag * cNBTList::GetChildByIdx(size_t iIndex)
-{
-	// Catch usage errors while debugging:
-	ASSERT((iIndex >= 0) && (iIndex < m_Children.size()));
-	
-	// Catch runtime errors:
-	if ((iIndex < 0) || (iIndex >= m_Children.size()))
-	{
-		return NULL;
-	}
-	
-	return m_Children[iIndex];
-}
-
-
-
-
-
-cNBTTag * cNBTList::FindChildByName(const AString & a_Name) const
-{
-	for (cNBTTags::const_iterator itr = m_Children.begin(); itr != m_Children.end(); ++itr)
-	{
-		if ((*itr)->GetName() == a_Name)
-		{
-			return *itr;
-		}
-	}
-	return NULL;
-}
-
-
-
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// cNBTCompound:
-
-void cNBTCompound::Clear(void)
-{
-	for (cNBTTags::iterator itr = m_Children.begin(); itr != m_Children.end(); ++itr)
-	{
-		delete *itr;
-	}
-	m_Children.clear();
-}
-
-
-
-
-
-int cNBTCompound::Add(cNBTTag * iTag)
-{
-	// Catch usage errors while debugging:
-	ASSERT(iTag->GetType() != TAG_End);
-	
-	// Catch runtime errors:
-	if (iTag->GetType() == TAG_End)
-	{
-		return ERROR_PRIVATE_NBT_UNEXPECTEDTAG;
-	}
-	
-	m_Children.push_back(iTag);
-	return ERROR_SUCCESS;
-}
-
-
-
-
-
-cNBTTag * cNBTCompound::GetChildByIdx(size_t iIndex)
-{
-	// Catch usage errors while debugging:
-	ASSERT((iIndex >= 0) && (iIndex < m_Children.size()));
-	
-	// Catch runtime errors:
-	if ((iIndex < 0) || (iIndex >= m_Children.size()))
-	{
-		return NULL;
-	}
-	
-	return m_Children[iIndex];
-}
-
-
-
-
-
-cNBTTag * cNBTCompound::FindChildByName(const AString & a_Name) const
-{
-	for (cNBTTags::const_iterator itr = m_Children.begin(); itr != m_Children.end(); ++itr)
-	{
-		if ((*itr)->GetName() == a_Name)
-		{
-			return *itr;
-		}
-	}
-	return NULL;
-}
-
-
-
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// cNBTParser:
-
-int cNBTParser::ReadByte(const char ** a_Data, int * a_Length, char & a_Value)
-{
-	if (*a_Length < 1)
-	{
-		return ERROR_PRIVATE_NBTPARSER_TOOSHORT;
-	}
-	a_Value = **a_Data;
-	*a_Data += 1;
-	*a_Length -= 1;
-	return ERROR_SUCCESS;
-}
-
-
-
-
-
-int cNBTParser::ReadInt16(const char ** a_Data, int * a_Length, Int16 & a_Value)
-{
-	if (*a_Length < 2)
-	{
-		return ERROR_PRIVATE_NBTPARSER_TOOSHORT;
-	}
-	a_Value = ntohs(*((Int16 *)*a_Data));
-	*a_Data += 2;
-	*a_Length -= 2;
-	return ERROR_SUCCESS;
-}
-
-
-
-
-
-int cNBTParser::ReadInt32(const char ** a_Data, int * a_Length, Int32 & a_Value)
-{
-	if (*a_Length < 4)
-	{
-		return ERROR_PRIVATE_NBTPARSER_TOOSHORT;
-	}
-	a_Value = ntohl(*((Int32 *)*a_Data));
-	*a_Data += 4;
-	*a_Length -= 4;
-	return ERROR_SUCCESS;
-}
-
-
-
-
-
-int cNBTParser::ReadInt64(const char ** a_Data, int * a_Length, Int64 & a_Value)
-{
-	if (*a_Length < 8)
-	{
-		return ERROR_PRIVATE_NBTPARSER_TOOSHORT;
-	}
-	a_Value = NetworkToHostLong8(*a_Data);
-	*a_Data += 8;
-	*a_Length -= 8;
-	return ERROR_SUCCESS;
-}
-
-
-
-
-
-int cNBTParser::ReadFloat(const char ** a_Data, int * a_Length, float & a_Value)
-{
-	if (*a_Length < 4)
-	{
-		return ERROR_PRIVATE_NBTPARSER_TOOSHORT;
-	}
-	// Read as a 32-bit integer, converting endianness, then reinterpret as float:
-	Int32 tmp = ntohl(*((Int32 *)*a_Data));
-	a_Value = *((float *)&tmp);
-	*a_Data += 4;
-	*a_Length -= 4;
-	return ERROR_SUCCESS;
-}
-
-
-
-
-
-int cNBTParser::ReadDouble(const char ** a_Data, int * a_Length, double & a_Value)
-{
-	if (*a_Length < 8)
-	{
-		return ERROR_PRIVATE_NBTPARSER_TOOSHORT;
-	}
-	a_Value = NetworkToHostDouble8(*a_Data);
-	*a_Data += 8;
-	*a_Length -= 8;
-	return ERROR_SUCCESS;
-}
-
-
-
-
-
-int cNBTParser::ReadByteArray(const char ** a_Data, int * a_Length, AString & a_String)
-{
-	// Reads the short-counted string, adjusts a_Data and a_Length accordingly
-	Int32 Len;
-	RETURN_INT_IF_FAILED(ReadInt32(a_Data, a_Length, Len));
-	if (Len < 0)
-	{
-		return ERROR_PRIVATE_NBTPARSER_INVALIDLENGTH;
-	}
-	if (*a_Length < Len)
-	{
-		return ERROR_PRIVATE_NBTPARSER_TOOSHORT;
-	}
-	a_String.assign(*a_Data, Len);
-	*a_Data += Len;
-	*a_Length -= Len;
-	return ERROR_SUCCESS;
-}
-
-
-
-
-
-int cNBTParser::ReadString(const char ** a_Data, int * a_Length, AString & a_String)
-{
-	// Reads the short-counted string, adjusts a_Data and a_Length accordingly
-	if (*a_Length < 2)
-	{
-		return ERROR_PRIVATE_NBTPARSER_TOOSHORT;
-	}
-	Int16 val = *((Int16 *)*a_Data);
-	Int16 Len = ntohs(val);
-	if (Len < 0)
-	{
-		return ERROR_PRIVATE_NBTPARSER_INVALIDLENGTH;
-	}
-	*a_Data += 2;
-	*a_Length -= 2;
-	if (*a_Length < Len)
-	{
-		return ERROR_PRIVATE_NBTPARSER_TOOSHORT;
-	}
-	a_String.assign(*a_Data, Len);
-	*a_Data += Len;
-	*a_Length -= Len;
-	return ERROR_SUCCESS;
-}
-
-
-
-
-
-int cNBTParser::ReadList(const char ** a_Data, int * a_Length, cNBTList * a_List)
-{
-	// Reads a_List's     contents from a_Data; up to a_Length bytes may be used; adjusts a_Data and a_Length for after the list
-	Int32 ItemCount;
-	RETURN_INT_IF_FAILED(ReadInt32(a_Data, a_Length, ItemCount));
-	for (Int32 i = 0; i < ItemCount; i++)
-	{
-		cNBTTag * child = NULL;
-		RETURN_INT_IF_FAILED(ReadTag(a_Data, a_Length, a_List->GetChildrenType(), "", a_List, &child));
-		if (child == NULL)
-		{
-			return ERROR_PRIVATE_UNKNOWN;
-		}
-		RETURN_INT_IF_FAILED(a_List->Add(child));
-	}  // for i - Items[]
-	return ERROR_SUCCESS;
-}
-
-
-
-
-
-int cNBTParser::ReadCompound(const char ** a_Data, int * a_Length, cNBTCompound * a_Compound)
-{
-	// Reads a_Compound's contents from a_Data; up to a_Length bytes may be used; adjusts a_Data and a_Length for after the compound
-	while (true)
-	{
-		char TagType = **a_Data;
-		*a_Data += 1;
-		*a_Length -= 1;
-		if (TagType == cNBTTag::TAG_End)
-		{
-			return ERROR_SUCCESS;
-		}
-		AString Name;
-		RETURN_INT_IF_FAILED(ReadString(a_Data, a_Length, Name));
-		cNBTTag * child = NULL;
-		RETURN_INT_IF_FAILED(ReadTag(a_Data, a_Length, (cNBTTag::eTagType)TagType, Name, a_Compound, &child));
-		if (child == NULL)
-		{
-			return ERROR_PRIVATE_UNKNOWN;
-		}
-		RETURN_INT_IF_FAILED(a_Compound->Add(child));
-	}  // while (true)
-}
-
-
-
-
-int cNBTParser::ReadIntArray(const char ** a_Data, int * a_Length, cNBTIntArray * a_Array)
-{
-	if (*a_Length < 4)
-	{
-		return ERROR_PRIVATE_NBTPARSER_TOOSHORT;
-	}
-	int Count = ntohl(*((int *)*a_Data));
-	*a_Data += 4;
-	*a_Length -= 4;
-	if (*a_Length < 4 * Count)
-	{
-		return ERROR_PRIVATE_NBTPARSER_TOOSHORT;
-	}
-	for (int i = 0; i < Count; i++)
-	{
-		int Value = ntohl(*((int *)*a_Data));
-		a_Array->Add(Value);
-		*a_Data += 4;
-	}
-	*a_Length -= 4 * Count;
-	return ERROR_SUCCESS;
-}
-
-
-
-
-
-#define CASE_SIMPLE_TAG(TAGTYPE,CTYPE,FUNC) \
-	case cNBTTag::TAG_##TAGTYPE: \
-	{ \
-		CTYPE val; \
-		RETURN_INT_IF_FAILED(Read##FUNC(a_Data, a_Length, val)); \
-		*a_Tag = new cNBT##TAGTYPE(a_Parent, a_Name, val); \
-		if (*a_Tag == NULL) \
-		{ \
-			return ERROR_NOT_ENOUGH_MEMORY; \
-		} \
-		return ERROR_SUCCESS;\
-	}
-	
-int cNBTParser::ReadTag(const char ** a_Data, int * a_Length, cNBTTag::eTagType a_Type, const AString & a_Name, cNBTTag * a_Parent, cNBTTag ** a_Tag)
-{
-	switch (a_Type)
-	{
-		CASE_SIMPLE_TAG(Byte,      char,    Byte)
-		CASE_SIMPLE_TAG(Short,     Int16,   Int16)
-		CASE_SIMPLE_TAG(Int,       Int32,   Int32)
-		CASE_SIMPLE_TAG(Long,      Int64,   Int64)
-		CASE_SIMPLE_TAG(Float,     float,   Float)
-		CASE_SIMPLE_TAG(Double,    double,  Double)
-		CASE_SIMPLE_TAG(ByteArray, AString, ByteArray)
-		CASE_SIMPLE_TAG(String,    AString, String)
-		
-		case cNBTTag::TAG_List:
-		{
-			char ItemType;
-			RETURN_INT_IF_FAILED(ReadByte (a_Data, a_Length, ItemType));
-			cNBTList * List = new cNBTList(a_Parent, a_Name, (cNBTTag::eTagType)ItemType);
-			if (List == NULL)
-			{
-				return ERROR_NOT_ENOUGH_MEMORY;
-			}
-			RETURN_INT_IF_FAILED(ReadList(a_Data, a_Length, List));
-			*a_Tag = List;
-			return ERROR_SUCCESS;
-		}
-		
-		case cNBTTag::TAG_Compound:
-		{
-			cNBTCompound * Compound = new cNBTCompound(a_Parent, a_Name);
-			if (Compound == NULL)
-			{
-				return ERROR_NOT_ENOUGH_MEMORY;
-			}
-			RETURN_INT_IF_FAILED(ReadCompound(a_Data, a_Length, Compound));
-			*a_Tag = Compound;
-			return ERROR_SUCCESS;
-		}
-		
-		case cNBTTag::TAG_IntArray:
-		{
-			cNBTIntArray * Array = new cNBTIntArray(a_Parent, a_Name);
-			if (Array == NULL)
-			{
-				return ERROR_NOT_ENOUGH_MEMORY;
-			}
-			RETURN_INT_IF_FAILED(ReadIntArray(a_Data, a_Length, Array));
-			*a_Tag = Array;
-			return ERROR_SUCCESS;
-		}
-		
-		default:
-		{
-			#if (defined(_DEBUG) && defined(_WIN32))
-			OutputDebugString("Unhandled NBT tag type\n");
-			cNBTTag * Parent = a_Parent, * Cur = a_Parent;
-			while (Parent != NULL)
-			{
-				OutputDebugString("Parent:\n");
-				Cur = Parent;
-				Parent = Parent->GetParent();
-				DumpTree(Cur);
-			}
-			OutputDebugString("Done\n");
-			#endif  // _DEBUG
-			ASSERT(!"Unhandled NBT tag type");
-			break;
-		}
-	}  // switch (iType)
-
-	return ERROR_PRIVATE_NBTPARSER_BADTYPE;
-}
-
-#undef CASE_SIMPLE_TAG
-
-
-
-
-cNBTTree * cNBTParser::Parse(const char * a_Data, int a_Length)
-{
-	// Creates a NBT from a_Data
-	if (a_Length < 3)
-	{
-		return NULL;
-	}
-	if (a_Data[0] != cNBTTag::TAG_Compound)
-	{
-		return NULL;
-	}
-	a_Data++;
-	a_Length--;
-	AString Name;
-	if (ReadString(&a_Data, &a_Length, Name) != 0)
-	{
-		return NULL;
-	}
-	std::auto_ptr<cNBTCompound> Root(new cNBTCompound(NULL, Name));
-	if (Root.get() == NULL)
-	{
-		return NULL;
-	}
-	if (ReadCompound(&a_Data, &a_Length, Root.get()) == 0)
-	{
-		return Root.release();
-	}
-	return NULL;
-}
-
-
-
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// cNBTSerializer:
-
-void cNBTSerializer::WriteByte(AString & a_Out, const char a_Value)
-{
-	a_Out.push_back(a_Value);
-}
-
-
-
-
-
-void cNBTSerializer::WriteInt16(AString & a_Out, const Int16 a_Value)
-{
-	Int16 Val = htons(a_Value);
-	a_Out.append((char *)&Val, 2);
-}
-
-
-
-
-
-void cNBTSerializer::WriteInt32(AString & a_Out, const Int32 a_Value)
-{
-	Int32 Val = htonl(a_Value);
-	a_Out.append((char *)&Val, 4);
-}
-
-
-
-
-
-void cNBTSerializer::WriteInt64(AString & a_Out, const Int64 a_Value)
-{
-	Int64 Val = HostToNetwork8(&a_Value);
-	a_Out.append((char *)&Val, 8);
-}
-
-
-
-
-
-void cNBTSerializer::WriteFloat(AString & a_Out, const float a_Value)
-{
-	Int32 Val = htonl(*((u_long *)&a_Value));
-	a_Out.append((char *)&Val, 4);
-}
-
-
-
-
-
-void cNBTSerializer::WriteDouble(AString & a_Out, const double a_Value)
-{
-	Int64 Val = HostToNetwork8(&a_Value);
-	a_Out.append((char *)&Val, 8);
-}
-
-
-
-
-
-void cNBTSerializer::WriteByteArray(AString & a_Out, const AString & a_Value)
-{
-	WriteInt32(a_Out, a_Value.size());
-	a_Out.append(a_Value);
-}
-
-
-
-
-
-void cNBTSerializer::WriteString(AString & a_Out, const AString & a_String)
-{
-	WriteInt16(a_Out, a_String.length());
-	a_Out.append(a_String);
-}
-
-
-
-
-
-void cNBTSerializer::WriteList(AString & a_Out, const cNBTList * a_List)
-{
-	WriteInt32(a_Out, a_List->GetChildrenCount());
-	const cNBTTags & Children = a_List->GetChildren();
-	for (cNBTTags::const_iterator itr = Children.begin(); itr != Children.end(); ++itr)
-	{
-		WriteTag(a_Out, *itr);
-	}  // for itr - Children[]
-}
-
-
-
-
-
-void cNBTSerializer::WriteIntArray(AString & a_Out, const cNBTIntArray * a_Array)
-{
-	WriteInt32(a_Out, a_Array->GetValues().size());
-	const std::vector<int> & Values = a_Array->GetValues();
-	for (std::vector<int>::const_iterator itr = Values.begin(); itr != Values.end(); ++itr)
-	{
-		WriteInt32(a_Out, *itr);
-	}  // for itr - Values[]
-}
-
-
-
-
-
-void cNBTSerializer::WriteCompound(AString & a_Out, const cNBTCompound * a_Compound)
-{
-	const cNBTTags & Children = a_Compound->GetChildren();
-	for (cNBTTags::const_iterator itr = Children.begin(); itr != Children.end(); ++itr)
-	{
-		a_Out.push_back((*itr)->GetType());
-		WriteString(a_Out, (*itr)->GetName());
-		WriteTag(a_Out, *itr);
-	}  // for itr - Children[]
-	a_Out.push_back(cNBTTag::TAG_End);
-}
-
-
-
-
-
-#define CASE_SIMPLE_TAG(TAGTYPE,CTYPE,FUNC) \
-	case cNBTTag::TAG_##TAGTYPE: \
-	{ \
-		Write##FUNC(a_Out, ((const cNBT##TAGTYPE *)a_Tag)->m_Value ); \
-		return;\
-	}
-
-void cNBTSerializer::WriteTag(AString & a_Out, const cNBTTag * a_Tag)
-{
-	switch (a_Tag->GetType())
-	{
-		CASE_SIMPLE_TAG(Byte,      char,    Byte)
-		CASE_SIMPLE_TAG(Short,     Int16,   Int16)
-		CASE_SIMPLE_TAG(Int,       Int32,   Int32)
-		CASE_SIMPLE_TAG(Long,      Int64,   Int64)
-		CASE_SIMPLE_TAG(Float,     float,   Float)
-		CASE_SIMPLE_TAG(Double,    double,  Double)
-		CASE_SIMPLE_TAG(ByteArray, AString, ByteArray)
-		CASE_SIMPLE_TAG(String,    AString, String)
-		
-		case cNBTTag::TAG_List:
-		{
-			a_Out.push_back((char)((const cNBTList *)a_Tag)->GetChildrenType());
-			WriteList(a_Out, (const cNBTList *)a_Tag);
-			return;
-		}
-		
-		case cNBTTag::TAG_Compound:
-		{
-			WriteCompound(a_Out, (const cNBTCompound *)a_Tag);
-			return;
-		}
-		
-		case cNBTTag::TAG_IntArray:
-		{
-			WriteIntArray(a_Out, (const cNBTIntArray *)a_Tag);
-			return;
-		}
-	}  // switch (iType)
-	
-	ASSERT(!"Unhandled NBT tag type");
-}
-
-#undef CASE_SIMPLE_TAG
-
-
-
-
-void cNBTSerializer::Serialize(const cNBTTree * a_Tree, AString & a_Out)
-{
-	a_Out.clear();
-	a_Out.push_back(cNBTTag::TAG_Compound);
-	WriteString(a_Out, a_Tree->GetName());
-	WriteCompound(a_Out, (const cNBTCompound *)a_Tree);
-}
-
-
-
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Dumping the NBT tree (debug-only)
-
-#if (defined(_DEBUG) && defined(_WIN32))
-
-#define CASE_SIMPLE_TAG(TYPE,FMT) \
-	case cNBTTag::TAG_##TYPE: \
-	{ \
-		AString out; \
-		Printf(out, "%sTAG_" TEXT(#TYPE) TEXT("(\"%hs\"): %") TEXT(FMT) TEXT("\n"), Indent.c_str(), a_Tree->GetName().c_str(), ((cNBT##TYPE *)a_Tree)->m_Value); \
-		OutputDebugString(out.c_str()); \
-		break; \
-	}
-	
-void DumpTree(const cNBTTree * a_Tree, int a_Level)
-{
-	AString Indent(a_Level, TEXT(' '));
-	switch (a_Tree->GetType())
-	{
-		CASE_SIMPLE_TAG(Byte,  "d")
-		CASE_SIMPLE_TAG(Short, "d")
-		CASE_SIMPLE_TAG(Int,   "d")
-		CASE_SIMPLE_TAG(Long,   "I64d")
-		CASE_SIMPLE_TAG(Float,  "f")
-		CASE_SIMPLE_TAG(Double, "f")
-		
-		case cNBTTag::TAG_ByteArray:
-		{
-			AString out;
-			Printf(out, "%sTAG_ByteArray(\"%hs\"): %d bytes\n", Indent.c_str(), a_Tree->GetName().c_str(), ((cNBTByteArray *)a_Tree)->m_Value.size());
-			OutputDebugString(out.c_str());
-			break;
-		}
-		
-		case cNBTTag::TAG_String:
-		{
-			AString out;
-			Printf(out, "%sTAG_String(\"%hs\"): %d bytes: \"%hs\"\n", Indent.c_str(), a_Tree->GetName().c_str(), ((cNBTString *)a_Tree)->m_Value.size(), ((cNBTString *)a_Tree)->m_Value.c_str());
-			OutputDebugString(out.c_str());
-			break;
-		}
-		
-		case cNBTTag::TAG_List:
-		{
-			const cNBTTags & Children = ((cNBTList *)a_Tree)->GetChildren();
-			AString out;
-			Printf(out, "%sTAG_List(\"%hs\"): %d items of type %d\n%s{\n", Indent.c_str(), a_Tree->GetName().c_str(), Children.size(), ((cNBTList *)a_Tree)->GetChildrenType(), Indent.c_str());
-			OutputDebugString(out.c_str());
-			for (cNBTTags::const_iterator itr = Children.begin(); itr != Children.end(); ++itr)
-			{
-				DumpTree(*itr, a_Level + 1);
-			}  // for itr - Children[]
-			Printf(out, "%s}\n", Indent.c_str());
-			OutputDebugString(out.c_str());
-			break;
-		}
-
-		case cNBTTag::TAG_Compound:
-		{
-			const cNBTTags & Children = ((cNBTCompound *)a_Tree)->GetChildren();
-			AString out;
-			Printf(out, "%sTAG_Compound(\"%hs\"): %d items\n%s{\n", Indent.c_str(), a_Tree->GetName().c_str(), Children.size(), Indent.c_str());
-			OutputDebugString(out.c_str());
-			for (cNBTTags::const_iterator itr = Children.begin(); itr != Children.end(); ++itr)
-			{
-				DumpTree(*itr, a_Level + 1);
-			}  // for itr - Children[]
-			Printf(out, "%s}\n", Indent.c_str());
-			OutputDebugString(out.c_str());
-			break;
-		}
-	}
-}
-
-#undef CASE_SIMPLE_TAG
-
-#endif  // (_DEBUG && _WIN32)
-
-
-
-