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

@@ -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 */
+struct nbt_procdat nbt_initproc(struct nbt_path const *restrict pats, uint npats) {
-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;
 	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];
+	const char **cpat = (const char **)calloc(sizeof(void *), mdpt - 1);
-	memset((void *)cpat, 0, mdpt - 1);
 
-	// looping through the different tags
+	// return the initialised structure.
-	const u8 *ptr = buf + nbt_namelen(buf) + 3;
+	return (struct nbt_procdat){
-	while (ptr < (buf + len) && dpt >= 0) {
+		pats,
-		u16 naml = nbt_namelen(ptr);
+		cpat,
-		const char *mat = getpat(pats, npats, dpt, (char *)(ptr + 3), naml);
+		npats,
-		cpat[dpt] = mat;
+		0,
-
+		mdpt,
-		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;
 }

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 */
+/* TODO: write doc */
-CONST int nbt_primsize(u8 tag);
+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`. */
+/* initialises a data structure used whilst processing the tags */
-atrb_nonnull(1, 3) int nbt_proc(struct nbt_path const *restrict paths, uint npaths, const u8 *restrict buf, size_t len);
+PURE NONNULL((1)) struct nbt_procdat nbt_initproc(struct nbt_path const *restrict pats, uint npats);