Shift array much less often to reduce CPU load

bini.h

···
-#ifndef __bini__
-#define __bini__
+#ifndef __kf_bini__
+#define __kf_bini__
 
 /*
 bini.h: endian-independent binary IO.
 License: BSD 3-Clause. See EOF for license text.
 
-Version: 1.0
+Version: 1.1
 
 Changelog:
   1.0 (Dec 28, 2025): Initial version.
+  1.1 (Dec 30, 2025): Use an offset instead of shifting the
+    byte buffer so carelessly. _bini_grow will shift the
+    buffer on-demand instead so as to conserve CPU time.
 */
 
 /* Used to add functions for version-specific types. */
···
 {
 	/* Read mode for the stream. Should be either BINI_STACK or BINI_STREAM. */
 	int mode;
+	/* Offset from the start of the buffer in bytes. Only used for BINI_STREAM. */
+	size_t off;
 	size_t cap;
 	size_t len;
 	uint8_t *buffer;
···
    buffer, and frees the provided variable as well. */
 void bini_close(struct bini_stream *bs);
 
+/* Shift a binary stream, resetting the offset and shifting the array. */
+void bini_shift(struct bini_stream *);
 /* Flush a binary stream, clearing its buffer. */
 int bini_flush(struct bini_stream *);
 /* Dump the binary stream's buffer to fp. */
···
 	bs->buffer = calloc(BINI_BUFSIZ, 1);
 	if (!bs->buffer)
 		return BINI_ERR;
+	bs->off = 0;
 	bs->len = 0;
 	bs->cap = BINI_BUFSIZ;
 	bs->mode = BINI_STREAM;
···
 	free(bs);
 }
 
+static
+#if bini_c >= 1999
+inline
+#endif
+void _bini_shiftleft(struct bini_stream *bs, size_t n)
+{
+	size_t i;
+	_bini_dbg("shift %d: (len=%lu)\n", n, bs->len);
+	for (i = 0 ; i < bs->len ; i++)
+	{
+		if (i+n >= bs->len)
+		{
+			_bini_dbg("      %d: [%d] (out of bounds) to [%d]\n", n, i+n, i);
+			bs->buffer[i] = 0;
+			continue;
+		}
+		_bini_dbg("      %d: [%d] (%02x '%c') to [%d]\n",
+			n,
+			i+n,
+			bs->buffer[i+n],
+			bs->buffer[i+n],
+			i);
+		bs->buffer[i] = bs->buffer[i+n];
+	}
+}
+
+void bini_shift(struct bini_stream *bs)
+{
+	_bini_shiftleft(bs, bs->off);
+	bs->off = 0;
+}
+
 int bini_flush(struct bini_stream *bs)
 {
 	size_t i;
···
 int _bini_grow(struct bini_stream *bs, size_t n)
 {
 	uint8_t *newbuf;
+
+	if (bs->off + bs->len + n < bs->cap)
+		return BINI_OK;
+
+	/* Shifting the array could give enough space to
+	   fit `n`, avoiding the need to realloc. */
+	bini_shift(bs);
+
 	if (bs->len + n < bs->cap)
 		return BINI_OK;
+
 	while (bs->len + n >= bs->cap)
 	{
 		newbuf = realloc(bs->buffer, bs->cap * 2);
···
 		bs->buffer = newbuf;
 		bs->cap *= 2;
 	}
+
 	return BINI_OK;
 }
 
···
 	return fwrite(bs->buffer, size, n, fp);
 }
 
-static
-#if bini_c >= 1999
-inline
-#endif
-void _bini_shiftleft(struct bini_stream *bs, size_t n)
-{
-	size_t i;
-	_bini_dbg("shift %d: (len=%lu)\n", n, bs->len);
-	for (i = 0 ; i < bs->len ; i++)
-	{
-		if (i+n >= bs->len)
-		{
-			_bini_dbg("      %d: [%d] (out of bounds) to [%d]\n", n, i+n, i);
-			bs->buffer[i] = 0;
-			continue;
-		}
-		_bini_dbg("      %d: [%d] (%02x '%c') to [%d]\n",
-			n,
-			i+n,
-			bs->buffer[i+n],
-			bs->buffer[i+n],
-			i);
-		bs->buffer[i] = bs->buffer[i+n];
-	}
-}
-
 #define _bini_rwx(_type, _name) \
 	void bini_w##_name(struct bini_stream *bs, _type v) \
 	{ \
···
 				l ? sizeof(v)-i-1 : i, \
 				bytes[l ? sizeof(v)-i-1 : i], \
 				bytes[l ? sizeof(v)-i-1 : i], \
-				bs->len+i); \
-			bs->buffer[bs->len+i] = bytes[l ? sizeof(v)-i-1 : i]; \
+				bs->off+bs->len+i); \
+			bs->buffer[bs->off+bs->len+i] = bytes[l ? sizeof(v)-i-1 : i]; \
 		} \
 		bs->len += i; \
 		_bini_dbg("-> %s: %d (%lu bytes)\n", __FUNCTION__, *(int *)bytes, sizeof(v)); \
···
 		int m = bs->mode == BINI_STREAM; \
 		for (i = 0 ; i < sizeof(v) ; i++) \
 		{ \
+			const size_t p = bs->off + (m ? i : (bs->len-sizeof(v)+i)); \
 			_bini_dbg("%s: byte index [%lu] from buffer index %lu (= %02x '%c')\n", \
 				__FUNCTION__, \
 				l ? sizeof(v)-i-1 : i, \
-				m ? i : (bs->len-sizeof(v)+i), \
-				bs->buffer[m ? i : (bs->len-sizeof(v)+i)], \
-				bs->buffer[m ? i : (bs->len-sizeof(v)+i)]); \
-			bytes[l ? sizeof(v)-i-1 : i] = bs->buffer[m ? i : (bs->len-sizeof(v)+i)]; \
+				p, \
+				bs->buffer[p], \
+				bs->buffer[p]); \
+			bytes[l ? sizeof(v)-i-1 : i] = bs->buffer[p]; \
 		} \
 		if (m) \
-			_bini_shiftleft(bs, i); \
+		{ \
+			bs->off += i; \
+			/* _bini_shiftleft(bs, i); */ \
+		} \
 		bs->len -= i; \
 		return v; \
 	}