From c3fc688c35d41b74271b918ed8b6e56f1b473867 Mon Sep 17 00:00:00 2001
From: Quinn <quinnthepigeon@proton.me>
Date: Thu, 7 Aug 2025 13:12:52 +0200
Subject: [PATCH] remove `nbt_proc` and replace it with `nbt_initproc`

we're moving towards that the user will handle most of the looping and
data feed.
So the use of these functions is no longer intended, becides, they
weren't being maintained whilst the parameters changed, causing the
portion of code to lag behind.
I'd rather rewrite code than have to prune old, unused code.
---
 src/dat/nbt.c | 49 ++++++++++---------------------------------------
 src/dat/nbt.h | 14 ++++++++++----
 2 files changed, 20 insertions(+), 43 deletions(-)

diff --git a/src/dat/nbt.c b/src/dat/nbt.c
index e7f5436..c0a2074 100644
--- a/src/dat/nbt.c
+++ b/src/dat/nbt.c
@@ -110,22 +110,7 @@ static const u8 *nbt_proctag(const u8 *restrict buf, u16 slen) {
 	return ptr + nbt_primsize(*buf);
 }
 
-/* finds which of `pats` is equivalent to `cmp`, assumes `cmp` is `≥len` bytes long */
-static const char *getpat(struct nbt_path const *restrict pats, uint npats, i16 dpt, const char *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;
-}
-
-// TODO: make the user do the looping
-int nbt_proc(struct nbt_path const *restrict pats, uint npats, const u8 *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;
-
-	i16 dpt = 0;
+struct nbt_procdat nbt_initproc(struct nbt_path const *restrict pats, uint npats) {
 	i16 mdpt = 0;
 
 	// acquire the maximum depth that we'll need to go (exclusive)
@@ -136,28 +121,14 @@ int nbt_proc(struct nbt_path const *restrict pats, uint npats, const u8 *restric
 	assert(mdpt > 0);
 
 	// storing the segments of the current path
-	const char *cpat[mdpt - 1];
-	memset((void *)cpat, 0, mdpt - 1);
+	const char **cpat = (const char **)calloc(sizeof(void *), mdpt - 1);
 
-	// looping through the different tags
-	const u8 *ptr = buf + nbt_namelen(buf) + 3;
-	while (ptr < (buf + len) && dpt >= 0) {
-		u16 naml = nbt_namelen(ptr);
-		const char *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 !dpt;
+	// return the initialised structure.
+	return (struct nbt_procdat){
+		pats,
+		cpat,
+		npats,
+		0,
+		mdpt,
+	};
 }
diff --git a/src/dat/nbt.h b/src/dat/nbt.h
index 9c9ebf8..449b33e 100644
--- a/src/dat/nbt.h
+++ b/src/dat/nbt.h
@@ -36,13 +36,19 @@ enum nbt_tagid {
 	NBT_ARR_I64 = 0x0C,  // starts with a i32, denoting size, followed by the u32 data
 };
 
+/* TODO: write doc */
 struct nbt_path {
 	const char **restrict pat; // specifies the NBT path components as separate elements
 	i16 len;                   // specifies the length of the NBT elements
 };
 
-/* gets the tag size of primitive types, returns `>0` on success, `<0` on failure */
-CONST int nbt_primsize(u8 tag);
+/* TODO: write doc */
+struct nbt_procdat {
+	const struct nbt_path *pats;
+	const char *restrict *cpat;
+	u32 npats;
+	i16 dpt, mdpt;
+};
 
 /* searches for the end of a compound tag without processing data, the final pointer is returned.
  * `NULL` is returned upon failure, the otherwise returned pointer is not guaranteed to be valid.
@@ -64,5 +70,5 @@ atrb_pure atrb_nonnull(1) static inline u16 nbt_namelen(const u8 *restrict buf)
 	return be16toh(*(u16 *)(buf + 1));
 }
 
-/* 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, const u8 *restrict buf, size_t len);
+/* initialises a data structure used whilst processing the tags */
+PURE NONNULL((1)) struct nbt_procdat nbt_initproc(struct nbt_path const *restrict pats, uint npats);