write a function for skipping to the next NBT tag

including a function for acquireing the array size, and bytesize of a
tag.

src/dat/nbt.c

@@ -1,9 +1,9 @@
 #include "nbt.h"
 
-#include <endian.h>
 #include <stddef.h>
 #include <string.h>
 
+#include "../util/compat/endian.h"
 #include "../util/types.h"
 
 /* returns the string length from a specific location in the buffer */
@@ -11,6 +11,11 @@ static inline u16 nbt_strlen(u8 const *restrict buf) {
 	return be16toh(*(u16 *)(buf));
 }
 
+/* returns the length of an array from a specific location in the buffer */
+static inline i32 nbt_arrlen(u8 const *restrict buf) {
+	return be32toh(*(i32 *)(buf));
+}
+
 /* compares the string in `buf` to `matstr`.
  * returns `=0` if equal, `>0` if buf is greater, `<0` if matstr is greater. */
 static int nbt_cmpstr(char const *restrict matstr, u8 const *restrict buf) {
@@ -24,6 +29,62 @@ static int nbt_cmpstr(char const *restrict matstr, u8 const *restrict buf) {
 	return strncmp(str, matstr, len);
 }
 
+/* gets the tag size of primitive types, returns `>0` on success, `<0` on failure */
+int nbt_prim_tagsize(u8 tag) {
+	switch (tag) {
+	case NBT_I8:  return 1;
+	case NBT_I16: return 2;
+	case NBT_I32: return 4;
+	case NBT_I64: return 8;
+	case NBT_F32: return 4;
+	case NBT_F64: return 8;
+	default:      return -1;
+	}
+}
+
+/* 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;
+
+	uint mems = 0;
+	switch (*buf) {
+	case NBT_I8:
+	case NBT_I16:
+	case NBT_I32:
+	case NBT_I64:
+	case NBT_F32:
+	case NBT_F64:
+		nxt += nbt_prim_tagsize(*buf);
+		return nxt;
+
+	case NBT_ARR_I64:
+		mems += sizeof(i64) - sizeof(i32);
+	case NBT_ARR_I32:
+		mems += sizeof(i32) - sizeof(i8);
+	case NBT_ARR_I8:
+		mems += 1;
+		nxt += mems * nbt_arrlen(nxt);
+		return nxt;
+	case NBT_STR:
+		nxt += nbt_strlen(nxt);
+		return nxt;
+
+	case NBT_LIST:
+		mems = nbt_prim_tagsize(*nxt);
+		if (mems > 0) {
+			nxt += 1;
+			nxt += mems * nbt_arrlen(nxt);
+			return nxt;
+		}
+		// let case escape to `default` when `mems` `≤0`
+
+	default: return NULL; // failure on compound/end tags; these require more nuanced logic
+	}
+}
+
 int nbt_proc(void **restrict datout, u8 const *restrict buf, size_t len) {
 
 	// first byte should be a compound tag

src/util/compat/endian.h

@@ -2,53 +2,36 @@
 // Licensed under the MIT Licence. See LICENSE for details
 #pragma once
 
-#include <stdint.h>
+#if __has_include(<endian.h>)
-
+#include <endian.h>
-#include "../atrb.h"
+#else
-#include "../types.h"
-
-/* little endian */
-atrb_const static inline u16 le16ton(u16); // converts little-endian (LE) encoding to native for a 16 bit integer. (NOOP if native is LE)
-atrb_const static inline u32 le32ton(u32); // converts little-endian (LE) encoding to native for a 32 bit integer. (NOOP if native is LE)
-atrb_const static inline u64 le64ton(u64); // converts little-endian (LE) encoding to native for a 64 bit integer. (NOOP if native is LE)
-atrb_const static inline u16 ntole16(u16); // converts native encoding to little-endian (LE) for a 16 bit integer. (NOOP if native is LE)
-atrb_const static inline u32 ntole32(u32); // converts native encoding to little-endian (LE) for a 32 bit integer. (NOOP if native is LE)
-atrb_const static inline u64 ntole64(u64); // converts native encoding to little-endian (LE) for a 64 bit integer. (NOOP if native is LE)
-
-/* big endian */
-atrb_const static inline u16 be16ton(u16); // converts big-endian (BE) encoding to native for a 16 bit integer. (NOOP if native is BE)
-atrb_const static inline u32 be32ton(u32); // converts big-endian (BE) encoding to native for a 32 bit integer. (NOOP if native is BE)
-atrb_const static inline u64 be64ton(u64); // converts big-endian (BE) encoding to native for a 64 bit integer. (NOOP if native is BE)
-atrb_const static inline u16 ntobe16(u16); // converts native encoding to big-endian (BE) for a 16 bit integer. (NOOP if native is BE)
-atrb_const static inline u32 ntobe32(u32); // converts native encoding to big-endian (BE) for a 32 bit integer. (NOOP if native is BE)
-atrb_const static inline u64 ntobe64(u64); // converts native encoding to big-endian (BE) for a 64 bit integer. (NOOP if native is BE)
-
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-u16 le16ton(u16 x) { return x; }
+#define le16toh(x) __uint16_identity(x)
-u32 le32ton(u32 x) { return x; }
+#define le32toh(x) __uint32_identity(x)
-u64 le64ton(u64 x) { return x; }
+#define le64toh(x) __uint64_identity(x)
-u16 ntole16(u16 x) { return x; }
+#define htole16(x) __uint16_identity(x)
-u32 ntole32(u32 x) { return x; }
+#define htole32(x) __uint32_identity(x)
-u64 ntole64(u64 x) { return x; }
+#define htole64(x) __uint64_identity(x)
-u16 be16ton(u16 x) { return __builtin_bswap16(x); }
+#define be16toh(x) __builtin_bswap16(x)
-u32 be32ton(u32 x) { return __builtin_bswap32(x); }
+#define be32toh(x) __builtin_bswap32(x)
-u64 be64ton(u64 x) { return __builtin_bswap64(x); }
+#define be64toh(x) __builtin_bswap64(x)
-u16 ntobe16(u16 x) { return __builtin_bswap16(x); }
+#define htobe16(x) __builtin_bswap16(x)
-u32 ntobe32(u32 x) { return __builtin_bswap32(x); }
+#define htobe32(x) __builtin_bswap32(x)
-u64 ntobe64(u64 x) { return __builtin_bswap64(x); }
+#define htobe64(x) __builtin_bswap64(x)
 #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-u16 le16ton(u16 x) { __builtin_bswap16(x); }
+#define le16toh(x) __builtin_bswap16(x)
-u32 le32ton(u32 x) { __builtin_bswap32(x); }
+#define le32toh(x) __builtin_bswap32(x)
-u64 le64ton(u64 x) { __builtin_bswap64(x); }
+#define le64toh(x) __builtin_bswap64(x)
-u16 ntole16(u16 x) { __builtin_bswap16(x); }
+#define htole16(x) __builtin_bswap16(x)
-u32 ntole32(u32 x) { __builtin_bswap32(x); }
+#define htole32(x) __builtin_bswap32(x)
-u64 ntole64(u64 x) { __builtin_bswap64(x); }
+#define htole64(x) __builtin_bswap64(x)
-u16 be16ton(u16 x) { return x; }
+#define be16toh(x) __uint16_identity(x)
-u32 be32ton(u32 x) { return x; }
+#define be32toh(x) __uint32_identity(x)
-u64 be64ton(u64 x) { return x; }
+#define be64toh(x) __uint64_identity(x)
-u16 ntobe16(u16 x) { return x; }
+#define htobe16(x) __uint16_identity(x)
-u32 ntobe32(u32 x) { return x; }
+#define htobe32(x) __uint32_identity(x)
-u64 ntobe64(u64 x) { return x; }
+#define htobe64(x) __uint64_identity(x)
 #else
 #error machine architecture unsupported! Expected either big-endian or little-endian, make sure to use a compiler which defines __BYTE_ORDER__ (like clang or gcc)
 #endif
+#endif