diff options
Diffstat (limited to '')
| -rw-r--r-- | source/FastNBT.cpp | 320 |
1 files changed, 320 insertions, 0 deletions
diff --git a/source/FastNBT.cpp b/source/FastNBT.cpp new file mode 100644 index 000000000..fa3edec52 --- /dev/null +++ b/source/FastNBT.cpp @@ -0,0 +1,320 @@ +
+// FastNBT.cpp
+
+// Implements the fast NBT parser and writer
+
+#include "Globals.h"
+#include "FastNBT.h"
+
+
+
+
+
+#define RETURN_FALSE_IF_FALSE(X) do { if (!X) return false; } while (0)
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cFastNBTParser:
+
+#define NEEDBYTES(N) \
+ if (m_Length - m_Pos < N) \
+ { \
+ return false; \
+ }
+
+
+
+
+
+cParsedNBT::cParsedNBT(const char * a_Data, int a_Length) :
+ m_Data(a_Data),
+ m_Length(a_Length),
+ m_Pos(0)
+{
+ m_IsValid = Parse();
+}
+
+
+
+
+
+bool cParsedNBT::Parse(void)
+{
+ if (m_Length < 3)
+ {
+ // Data too short
+ return false;
+ }
+ if (m_Data[0] != TAG_Compound)
+ {
+ // The top-level tag must be a Compound
+ return false;
+ }
+
+ m_Tags.reserve(200);
+
+ m_Tags.push_back(cFastNBTTag(TAG_Compound, -1));
+
+ m_Pos = 1;
+
+ RETURN_FALSE_IF_FALSE(ReadString(m_Tags.back().m_NameStart, m_Tags.back().m_NameLength));
+ RETURN_FALSE_IF_FALSE(ReadCompound());
+
+ return true;
+}
+
+
+
+
+
+bool cParsedNBT::ReadString(int & a_StringStart, int & a_StringLen)
+{
+ NEEDBYTES(2);
+ a_StringStart = m_Pos + 2;
+ a_StringLen = ntohs(*((short *)(m_Data + m_Pos)));
+ if (a_StringLen < 0)
+ {
+ // Invalid string length
+ return false;
+ }
+ m_Pos += 2 + a_StringLen;
+ return true;
+}
+
+
+
+
+
+bool cParsedNBT::ReadCompound(void)
+{
+ // Reads the latest tag as a compound
+ int ParentIdx = m_Tags.size() - 1;
+ int PrevSibling = -1;
+ while (true)
+ {
+ NEEDBYTES(1);
+ eTagType TagType = (eTagType)(m_Data[m_Pos]);
+ m_Pos++;
+ if (TagType == TAG_End)
+ {
+ break;
+ }
+ m_Tags.push_back(cFastNBTTag(TagType, ParentIdx, PrevSibling));
+ if (PrevSibling >= 0)
+ {
+ m_Tags[PrevSibling].m_NextSibling = m_Tags.size() - 1;
+ }
+ else
+ {
+ m_Tags[ParentIdx].m_FirstChild = m_Tags.size() - 1;
+ }
+ PrevSibling = m_Tags.size() - 1;
+ RETURN_FALSE_IF_FALSE(ReadString(m_Tags.back().m_NameStart, m_Tags.back().m_NameLength));
+ RETURN_FALSE_IF_FALSE(ReadTag());
+ } // while (true)
+ m_Tags[ParentIdx].m_LastChild = PrevSibling;
+ return true;
+}
+
+
+
+
+
+bool cParsedNBT::ReadList(eTagType a_ChildrenType)
+{
+ // Reads the latest tag as a list of items of type a_ChildrenType
+
+ // Read the count:
+ NEEDBYTES(4);
+ int Count = ntohl(*((int *)(m_Data + m_Pos)));
+ m_Pos += 4;
+ if (Count < 0)
+ {
+ return false;
+ }
+
+ // Read items:
+ int ParentIdx = m_Tags.size() - 1;
+ int PrevSibling = -1;
+ for (int i = 0; i < Count; i++)
+ {
+ m_Tags.push_back(cFastNBTTag(a_ChildrenType, ParentIdx, PrevSibling));
+ if (PrevSibling >= 0)
+ {
+ m_Tags[PrevSibling].m_NextSibling = m_Tags.size() - 1;
+ }
+ else
+ {
+ m_Tags[ParentIdx].m_FirstChild = m_Tags.size() - 1;
+ }
+ PrevSibling = m_Tags.size() - 1;
+ RETURN_FALSE_IF_FALSE(ReadTag());
+ } // for (i)
+ m_Tags[ParentIdx].m_LastChild = PrevSibling;
+ return true;
+}
+
+
+
+
+
+#define CASE_SIMPLE_TAG(TAGTYPE, LEN) \
+ case TAG_##TAGTYPE: \
+ { \
+ NEEDBYTES(LEN); \
+ Tag.m_DataStart = m_Pos; \
+ Tag.m_DataLength = LEN; \
+ m_Pos += LEN; \
+ return true; \
+ }
+
+bool cParsedNBT::ReadTag(void)
+{
+ cFastNBTTag & Tag = m_Tags.back();
+ switch (Tag.m_Type)
+ {
+ CASE_SIMPLE_TAG(Byte, 1)
+ CASE_SIMPLE_TAG(Short, 2)
+ CASE_SIMPLE_TAG(Int, 4)
+ CASE_SIMPLE_TAG(Long, 8)
+ CASE_SIMPLE_TAG(Float, 4)
+ CASE_SIMPLE_TAG(Double, 8)
+
+ case TAG_String:
+ {
+ return ReadString(Tag.m_DataStart, Tag.m_DataLength);
+ }
+
+ case TAG_ByteArray:
+ {
+ NEEDBYTES(4);
+ int len = ntohl(*((int *)(m_Data + m_Pos)));
+ m_Pos += 4;
+ if (len < 0)
+ {
+ // Invalid length
+ return false;
+ }
+ NEEDBYTES(len);
+ Tag.m_DataLength = len;
+ Tag.m_DataStart = m_Pos;
+ m_Pos += len;
+ return true;
+ }
+
+ case TAG_List:
+ {
+ NEEDBYTES(1);
+ eTagType ItemType = (eTagType)m_Data[m_Pos];
+ m_Pos++;
+ RETURN_FALSE_IF_FALSE(ReadList(ItemType));
+ return true;
+ }
+
+ case TAG_Compound:
+ {
+ RETURN_FALSE_IF_FALSE(ReadCompound());
+ return true;
+ }
+
+ case TAG_IntArray:
+ {
+ NEEDBYTES(4);
+ int len = ntohl(*((int *)(m_Data + m_Pos)));
+ m_Pos += 4;
+ if (len < 0)
+ {
+ // Invalid length
+ return false;
+ }
+ len *= 4;
+ NEEDBYTES(len);
+ Tag.m_DataLength = len;
+ Tag.m_DataStart = m_Pos;
+ m_Pos += len;
+ return true;
+ }
+
+ default:
+ {
+ ASSERT(!"Unhandled NBT tag type");
+ return false;
+ }
+ } // switch (iType)
+}
+
+#undef CASE_SIMPLE_TAG
+
+
+
+
+
+int cParsedNBT::FindChildByName(int a_Tag, const char * a_Name, size_t a_NameLength) const
+{
+ if (a_Tag < 0)
+ {
+ return -1;
+ }
+ if (m_Tags[a_Tag].m_Type != TAG_Compound)
+ {
+ return -1;
+ }
+
+ if (a_NameLength == 0)
+ {
+ a_NameLength = strlen(a_Name);
+ }
+ for (int Child = m_Tags[a_Tag].m_FirstChild; Child != -1; Child = m_Tags[Child].m_NextSibling)
+ {
+ if (
+ (m_Tags[Child].m_NameLength == a_NameLength) &&
+ (memcmp(m_Data + m_Tags[Child].m_NameStart, a_Name, a_NameLength) == 0)
+ )
+ {
+ return Child;
+ }
+ } // for Child - children of a_Tag
+ return -1;
+}
+
+
+
+
+
+int cParsedNBT::FindTagByPath(int a_Tag, const AString & a_Path) const
+{
+ if (a_Tag < 0)
+ {
+ return -1;
+ }
+ size_t Begin = 0;
+ size_t Length = a_Path.length();
+ int Tag = a_Tag;
+ for (size_t i = 0; i < Length; i++)
+ {
+ if (a_Path[i] != '\\')
+ {
+ continue;
+ }
+ Tag = FindChildByName(Tag, a_Path.c_str() + Begin, i - Begin - 1);
+ if (Tag < 0)
+ {
+ return -1;
+ }
+ Begin = i + 1;
+ } // for i - a_Path[]
+
+ if (Begin < Length)
+ {
+ Tag = FindChildByName(Tag, a_Path.c_str() + Begin, Length - Begin);
+ }
+ return Tag;
+}
+
+
+
+
+
|