diff options
Diffstat (limited to 'source/NBT.cpp')
| -rw-r--r-- | source/NBT.cpp | 899 |
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)
-
-
-
-
|