update nbt_proc function, still inoperable

src/dat/nbt.c

@@ -1,5 +1,6 @@
 #include "nbt.h"
 
+#include <assert.h>
 #include <stddef.h>
 #include <string.h>
 
@@ -29,75 +30,95 @@ static int nbt_cmpstr(char const *restrict matstr, u8 const *restrict buf) {
 	return strncmp(str, matstr, len);
 }
 
-/* acquires the array's byte size (excluding name + size spec)
- * returns `0` upon failure */
-static size_t nbt_arrbsize(u8 const *restrict buf) {
-	i32 mems = 0;
-
-	switch (*buf) {
-	case NBT_ARR_I64: mems += sizeof(i64) - sizeof(i32); __attribute__((fallthrough));
-	case NBT_ARR_I32: mems += sizeof(i32) - sizeof(i8); __attribute__((fallthrough));
-	case NBT_ARR_I8:  return +mems * nbt_arrlen(buf); // mems+1 multiplied by the array length
-
-	case NBT_STR: return nbt_strlen(buf);
-
-	case NBT_LIST:
-		mems = nbt_primsize(*buf);
-		if (mems > 0) return mems * nbt_arrlen(buf + 1);
-		return 0;
-	default: return 0;
-	}
-}
-
 /* returns the (expected) pointer of the tag following this one.
- * `NBT_COMPOUND` and `NBT_END` tags are not valid for this function and should be handled separately.
  * `NULL` is returned if anything went wrong. */
-static u8 const *nbt_nexttag(u8 const *restrict buf) {
-	u8 const *nxt = buf + 1;
-	nxt += nbt_strlen(nxt) + 2;
+static u8 const *nbt_nexttag(u8 const *restrict buf, u16 naml) {
+	size_t len = nbt_tagdatlen(buf);
+	if (!len) return NULL; // TODO: compound tags should be handled here
+	return buf + naml + len + 3;
+}
+
+// TODO: not actually doing anything
+/* readies the output data for export, returns the new buffer position, or `NULL` upon an error (may be out of bounds) */
+static u8 const *nbt_proctag(u8 const *restrict buf, u16 slen) {
+	u8 const *ptr = buf + 3 + slen;
+	u8 dat[8];
+	size_t arrlen = 0;
 
-	i32 tmp;
 	switch (*buf) {
-	case NBT_I8:  __attribute__((fallthrough));
-	case NBT_I16: __attribute__((fallthrough));
+	// integral types
+	case NBT_I8:  *dat = *ptr; return ptr;
+	case NBT_I16: *(u16 *)dat = be16toh(*(u16 *)ptr); return ptr + 2;
 	case NBT_I32: __attribute__((fallthrough));
+	case NBT_F32: *(u32 *)dat = be16toh(*(u32 *)ptr); return ptr + 4;
 	case NBT_I64: __attribute__((fallthrough));
-	case NBT_F32: __attribute__((fallthrough));
-	case NBT_F64:
-		tmp = nbt_primsize(*buf);
-		return (tmp >= 0) ? (nxt + tmp) : 0;
+	case NBT_F64: *(u64 *)dat = be16toh(*(u64 *)ptr); return ptr + 8;
 
-	case NBT_LIST:    nxt += 5; break;
-	case NBT_STR:     nxt += 2; break;
+	// arrays, handled differently
+	case NBT_LIST:    __attribute__((fallthrough));
 	case NBT_ARR_I8:  __attribute__((fallthrough));
+	case NBT_STR:     __attribute__((fallthrough));
 	case NBT_ARR_I32: __attribute__((fallthrough));
-	case NBT_ARR_I64: nxt += 4; break;
+	case NBT_ARR_I64:
+		// arrlen = nbt_arrbsize(ptr);
+		break;
 
-	default: return NULL; // failure on compound/end tags; these require more nuanced logic
+	default: return NULL;
 	}
-
-	tmp = nbt_arrbsize(buf);
-	return (tmp >= 0) ? (nxt + tmp) : NULL;
+	if (!arrlen) return NULL;
+	return ptr + nbt_primsize(*buf);
 }
 
-
-	default: return NULL; // failure on compound/end tags; these require more nuanced logic
+/* finds which of `pats` is equivalent to `cmp`, assumes `cmp` is `≥len` bytes long */
+static char const *getpat(struct nbt_path const *restrict pats, uint npats, i16 dpt, char const *restrict cmp, u16 len) {
+	for (uint i = 0; i < npats; i++) {
+		if (strncmp(pats[i].pat[dpt], cmp, len) == 0)
+			return pats[i].pat[dpt];
 	}
+	return NULL;
 }
 
-int nbt_proc(void **restrict datout, u8 const *restrict buf, size_t len) {
+// TODO: make the user do the looping
+int nbt_proc(struct nbt_path const *restrict pats, uint npats, u8 const *restrict buf, size_t len) {
+	// ensure first and last tag(s) are valid
+	if (buf[0] != NBT_COMPOUND || buf[len - 1] != NBT_END)
+		return 1;
 
-	// first byte should be a compound tag
-	if (*buf != NBT_COMPOUND) return 1;
-	uint ncomp = 1;
+	i16 dpt = 0;
+	i16 mdpt = 0;
 
-	// ignore the first tag + its name, so we start with the juicy data
-	uint tmp = nbt_strlen(buf + 1) + 3;
-	buf += tmp;
-	len -= tmp;
+	// acquire the maximum depth that we'll need to go (exclusive)
+	for (uint i = 0; i < npats; i++) {
+		int tmp = pats[i].len - mdpt;
+		mdpt += -(tmp > 0) & tmp;
+	}
+	assert(mdpt > 0);
+
+	// storing the segments of the current path
+	char const *cpat[mdpt - 1];
+	memset((void *)cpat, 0, mdpt - 1);
+
+	// looping through the different tags
+	u8 const *ptr = buf + nbt_strlen(buf + 1) + 3;
+	while (ptr < (buf + len) && dpt >= 0) {
+		u16 naml = nbt_strlen(ptr + 1);
+		char const *mat = getpat(pats, npats, dpt, (char *)(ptr + 3), naml);
+		cpat[dpt] = mat;
+
+		if (mat) {
+			switch (*ptr) {
+			case NBT_END:      dpt--; break;
+			case NBT_COMPOUND: dpt++; break;
+			default:           ptr = nbt_proctag(ptr, naml); break;
+			}
+		} else {
+			ptr = nbt_nexttag(ptr, naml);
+			if (!ptr) return 1;
+		}
+	}
 
 	// TODO: finish function
-	return 0;
+	return !dpt;
 }
 
 int nbt_primsize(u8 tag) {
@@ -112,6 +133,31 @@ int nbt_primsize(u8 tag) {
 	}
 }
 
+size_t nbt_tagdatlen(u8 const *restrict buf) {
+	i32 mems = 0;
+
+	switch (*buf) {
+	case NBT_I8:  __attribute__((fallthrough));
+	case NBT_I16: __attribute__((fallthrough));
+	case NBT_I32: __attribute__((fallthrough));
+	case NBT_F32: __attribute__((fallthrough));
+	case NBT_I64: __attribute__((fallthrough));
+	case NBT_F64: __attribute__((fallthrough));
+
+	case NBT_ARR_I64: mems += sizeof(i64) - sizeof(i32); __attribute__((fallthrough));
+	case NBT_ARR_I32: mems += sizeof(i32) - sizeof(i8); __attribute__((fallthrough));
+	case NBT_ARR_I8:  return +mems * nbt_arrlen(buf) + 4;
+
+	case NBT_STR: return nbt_strlen(buf) + 2;
+
+	case NBT_LIST:
+		mems = nbt_primsize(*buf);
+		if (mems > 0) return mems * nbt_arrlen(buf + 1) + 5;
+		return 0;
+	default: return 0;
+	}
+}
+
 int nbt_isprim(u8 tag) {
 	switch (tag) {
 	case NBT_I8:  __attribute__((fallthrough));

src/dat/nbt.h

@@ -34,12 +34,20 @@ enum nbt_tagid {
 	NBT_ARR_I64 = 0x0C,  // starts with a i32, denoting size, followed by the u32 data
 };
 
-int nbt_proc(void **restrict datout, u8 const *restrict buf, size_t len);
+struct nbt_path {
+	char const **restrict pat; // specifies the NBT path components as separate elements
+	i16 len;                   // specifies the length of the NBT elements
+};
 
 /* checks whether the tag is a primitive data tag. (not recommended for filtering tags, use a `switch`)
  * returns a boolean value. */
 atrb_const int nbt_isprim(u8 tag);
 
+/* gets the byte size of an NBT tag's data (excluding id and name), returns `0` upon error. */
+atrb_const size_t nbt_tagdatlen(u8 const *buf);
 
 /* gets the tag size of primitive types, returns `>0` on success, `<0` on failure */
 atrb_const int nbt_primsize(u8 tag);
+
+/* processes the uncompressed `NBT` data in `buf`, with a size of `len`. */
+atrb_nonnull(1, 3) int nbt_proc(struct nbt_path const *restrict paths, uint npaths, u8 const *restrict buf, size_t len);