Initial commit

.gitignore

···
+/*.out
+/*.bin
+/out.txt

bini.c

···
+#ifndef bini_impl
+#define bini_impl
+#endif
+#include <bini.h>

bini.h

···
+#ifndef __bini__
+#define __bini__
+
+
+/* Used to add functions for version-specific types. */
+#define bini_c 1989
+#ifdef __STDC_VERSION__
+# undef bini_c
+# if __STDC_VERSION__ == 199901
+#  define bini_c 1999
+# elif __STDC_VERSION__ == 201112
+#  define bini_c 2011
+# elif __STDC_VERSION__ == 201710
+#  define bini_c 2017
+# elif __STDC_VERSION__ == 202000 || __STDC_VERSION__ == 202311
+#  define bini_c 2023
+# else
+#  warning "bini.h: unknown C version. Falling back to C89."
+#  define bini_c 1989
+# endif
+#endif
+
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdarg.h>
+#include <stdio.h>
+#if bini_c >= 1999
+# include <stdbool.h>
+#endif
+
+
+#ifndef BINI_BUFSIZ
+/* Starting size for bini_stream buffers. */
+# define BINI_BUFSIZ 8192
+#endif
+
+#ifndef BINI_STRBUFSIZ
+/* Starting size for bini_*print buffers. */
+# define BINI_STRBUFSIZ 1024
+#endif
+
+
+/* Execute the `x` macro for each type that bini uses.
+   Excludes string types (char *). */
+#ifndef BINI_X
+# if bini_c >= 1999
+#  define BINI_X(x)                \
+	x(char, c)                 \
+	x(short, s)                \
+	x(int, i)                  \
+	x(long, l)                 \
+	x(long long, ll)           \
+	x(unsigned char, cu)       \
+	x(unsigned short, su)      \
+	x(unsigned int, iu)        \
+	x(unsigned long, lu)       \
+	x(unsigned long long, llu) \
+	x(float, f)                \
+	x(double, d)               \
+	x(bool, b)
+# else
+#  define BINI_X(x)           \
+	x(char, c)            \
+	x(short, s)           \
+	x(int, i)             \
+	x(long, l)            \
+	x(unsigned char, cu)  \
+	x(unsigned short, su) \
+	x(unsigned int, iu)   \
+	x(unsigned long, lu)  \
+	x(float, f)           \
+	x(double, d)
+# endif
+#endif
+
+
+enum { BINI_ERR, BINI_OK };
+enum { BINI_BIGENDIAN, BINI_LITTLEENDIAN };
+enum
+{
+	/* Read values from the end of the buffer. */
+	BINI_STACK,
+	/* Read values from the start of the buffer. */
+	BINI_STREAM
+};
+
+
+/* Represents a binary IO stream. */
+struct bini_stream
+{
+	/* Read mode for the stream. Should be either BINI_STACK or BINI_STREAM. */
+	int mode;
+	size_t cap;
+	size_t len;
+	uint8_t *buffer;
+};
+
+
+int bini_getendian(void);
+
+
+/* Initialize a bini_stream, allocating a buffer and
+   setting each field to its respective defaults. Also
+   see bini_new(). Free data using bini_end(). */
+int bini_init(struct bini_stream *);
+/* Create a new bini_stream, allocating a starting buffer
+   of BINI_BUFSIZ bytes. To use your own buffer, initialize
+   your own bini_stream and call bini_init() to fill in the
+   necessary fields. Free data using bini_close(). */
+struct bini_stream *bini_new(void);
+/* End a bini_stream, flushing it if need be and freeing
+   its buffer. */
+void bini_end(struct bini_stream *);
+/* End a bini_stream, flushing it if need be, freeing its
+   buffer, and frees the provided variable as well. */
+void bini_close(struct bini_stream *bs);
+
+/* Flush a binary stream, clearing its buffer. */
+int bini_flush(struct bini_stream *);
+/* Dump the binary stream's buffer to fp. */
+void bini_dump(FILE *fp, struct bini_stream *bs);
+
+/* Read data from a FILE into a binary stream. */
+size_t bini_fread(struct bini_stream *bs, size_t size, size_t n, FILE *fp);
+/* Write data to a FILE into a binary stream. This will
+   NOT consume data from the stream! Stack/stream mode does
+   not affect this function.
+   To consume data, use `bs->len -= bini_fwrite(bs, ...);` */
+size_t bini_fwrite(struct bini_stream *bs, size_t size, size_t n, FILE *fp);
+
+
+#define _bini_rwx(_type, _name) \
+	/* Write a `typeof(v)` to the stream. */ \
+	void bini_w##_name(struct bini_stream *bs, _type v); \
+	/* Read a `typeof(v)` from the stream. */ \
+	_type bini_r##_name(struct bini_stream *bs);
+BINI_X(_bini_rwx)
+#undef _bini_rwx
+
+void bini_wstrn(struct bini_stream *, const char *, size_t);
+void bini_wstr(struct bini_stream *, const char *);
+
+size_t bini_rstr(struct bini_stream *, char *);
+
+#if 0 /* unimplemented */
+/* Write to a binary stream. */
+int bini_vprint(struct bini_stream *bs, char *fmt, va_list va);
+/* Write to a binary stream. */
+int bini_print(struct bini_stream *bs, char *fmt, ...);
+
+/* Read from a binary stream. */
+int bini_vscan(struct bini_stream *bs, char *fmt, va_list va);
+/* Read from a binary stream. */
+int bini_scan(struct bini_stream *bs, char *fmt, ...);
+#endif
+
+
+/* Aliased names that are more akin to libc names. */
+#if defined(bini_libc_names)
+
+typedef struct bini_stream bstream;
+
+# define bnew bini_new
+# define binit bini_init
+# define bend bini_end
+# define bclose bini_close
+
+# define bflush bini_flush
+# define bdump bini_dump
+
+# define bputc bini_wc
+# define bputs bini_ws
+# define bputi bini_wi
+# define bputl bini_wl
+# define bputll bini_wll
+# define bputcu bini_wcu
+# define bputsu bini_wsu
+# define bputiu bini_wiu
+# define bputlu bini_wlu
+# define bputllu bini_wllu
+# define bputf bini_wf
+# define bputd bini_wd
+# define bputb bini_wb
+# define bputstr bini_wstr
+# define bputstrn bini_wstrn
+
+# define breadc bini_rc
+# define breads bini_rs
+# define breadi bini_ri
+# define breadl bini_rl
+# define breadll bini_rll
+# define breadcu bini_rcu
+# define breadsu bini_rsu
+# define breadiu bini_riu
+# define breadlu bini_rlu
+# define breadllu bini_rllu
+# define breadf bini_rf
+# define breadd bini_rd
+# define breadb bini_rb
+# define breadstr bini_rstr
+# define breadstrn bini_rstrn
+
+#if 0
+# define bfprint bini_vprint
+# define bprint bini_print
+# define bvscan bini_vscan
+# define bscan bini_scan
+#endif
+
+#endif
+
+
+#if defined(bini_impl)
+
+
+#include <stdlib.h>
+#include <string.h>
+
+
+static
+void _bini_dbg(char *fmt, ...)
+{
+#	if bini_dbg
+	va_list ap;
+	va_start(ap, fmt);
+	vfprintf(stderr, fmt, ap);
+	va_end(ap);
+#	else
+	(void)fmt;
+#	endif
+}
+
+
+int bini_getendian(void)
+{
+	const int n = 1;
+	if (*(char *)&n == 1)
+		return BINI_LITTLEENDIAN;
+	return BINI_BIGENDIAN;
+}
+
+
+int bini_init(struct bini_stream *bs)
+{
+	bs->buffer = calloc(BINI_BUFSIZ, 1);
+	if (!bs->buffer)
+		return BINI_ERR;
+	bs->len = 0;
+	bs->cap = BINI_BUFSIZ;
+	bs->mode = BINI_STREAM;
+	return BINI_OK;
+}
+
+struct bini_stream *bini_new(void)
+{
+	struct bini_stream *bs = malloc(sizeof(struct bini_stream));
+	bini_init(bs);
+	return bs;
+}
+
+void bini_end(struct bini_stream *bs)
+{
+	bini_flush(bs);
+	free(bs->buffer);
+}
+
+void bini_close(struct bini_stream *bs)
+{
+	bini_end(bs);
+	free(bs);
+}
+
+int bini_flush(struct bini_stream *bs)
+{
+	size_t i;
+	for (i = 0 ; i < bs->len ; i++)
+		bs->buffer[i] = 0;
+	bs->len = 0;
+	return BINI_OK;
+}
+
+void bini_dump(FILE *fp, struct bini_stream *bs)
+{
+	size_t i;
+	fprintf(fp, "bini buffer dump:\n");
+	fprintf(fp, "buffer: %lu/%lu bytes\n", bs->len, bs->cap);
+	fprintf(fp, "---\n");
+	for (i = 0 ; i < bs->len ; i++)
+		fprintf(fp, ". %02x '%c'\n", bs->buffer[i], bs->buffer[i]);
+	fprintf(fp, "---\n");
+}
+
+static
+#if bini_c >= 1999
+inline
+#endif
+int _bini_grow(struct bini_stream *bs, size_t n)
+{
+	uint8_t *newbuf;
+	if (bs->len + n < bs->cap)
+		return BINI_OK;
+	while (bs->len + n >= bs->cap)
+	{
+		newbuf = realloc(bs->buffer, bs->cap * 2);
+		if (!newbuf)
+			return BINI_ERR;
+		bs->buffer = newbuf;
+		bs->cap *= 2;
+	}
+	return BINI_OK;
+}
+
+size_t bini_fread(struct bini_stream *bs, size_t size, size_t n, FILE *fp)
+{
+	size_t nread;
+	_bini_grow(bs, size*n);
+	nread = fread(bs->buffer, size, n, fp);
+	bs->len += nread;
+	return nread;
+}
+
+size_t bini_fwrite(struct bini_stream *bs, size_t size, size_t n, FILE *fp)
+{
+	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) \
+	{ \
+		size_t i; \
+		uint8_t *bytes; \
+		int l = bini_getendian() == BINI_LITTLEENDIAN; \
+		_bini_dbg("%s: %d (%lu bytes)\n", __FUNCTION__, *(int *)&v, sizeof(v)); \
+		_bini_grow(bs, sizeof(v)); \
+		bytes = (uint8_t *)&v; \
+		for (i = 0 ; i < sizeof(v) ; i++) \
+		{ \
+			_bini_dbg("%s: byte index [%lu] (= %02x '%c') to buffer index %lu\n", \
+				__FUNCTION__, \
+				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->len += i; \
+		_bini_dbg("-> %s: %d (%lu bytes)\n", __FUNCTION__, *(int *)bytes, sizeof(v)); \
+	} \
+	_type bini_r##_name(struct bini_stream *bs) \
+	{ \
+		size_t i; \
+		_type v; \
+		uint8_t *bytes = (uint8_t *)&v; \
+		int l = bini_getendian() == BINI_LITTLEENDIAN; \
+		int m = bs->mode == BINI_STREAM; \
+		for (i = 0 ; i < 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)]; \
+		} \
+		if (m) \
+			_bini_shiftleft(bs, i); \
+		bs->len -= i; \
+		return v; \
+	}
+BINI_X(_bini_rwx)
+#undef _bini_rwx
+
+
+void bini_wstrn(struct bini_stream *bs, const char *str, size_t n)
+{
+	bini_wlu(bs, n);
+	_bini_grow(bs, n);
+	while (str)
+	{
+		bini_wc(bs, *str);
+		str++;
+	}
+}
+
+void bini_wstr(struct bini_stream *bs, const char *str)
+{
+	size_t i, n = strlen(str);
+	char *s = (char *)str;
+	bini_wlu(bs, n);
+	_bini_grow(bs, n);
+	for (i = 0 ; i < n ; i++)
+		bini_wc(bs, s[i]);
+}
+
+size_t bini_rstr(struct bini_stream *bs, char *str)
+{
+	size_t i, n = bini_rlu(bs);
+	for (i = 0 ; i < n ; i++)
+		str[i] = bini_rc(bs);
+	return n;
+}
+
+#endif /* bini_impl */
+#endif /* __bini__ */

compile_flags.txt

···
+-Wall
+-Werror
+-Wextra
+-pedantic
+-pedantic-errors
+-ansi
+-xc-header
+-Dbini_impl
+-Dbini_dbg
+-I.

examples/fileio.c

···
+#include <bini.c>
+
+typedef struct bini_stream bstream;
+
+struct data { int life, max, min, zero; };
+
+void write(struct data d)
+{
+	FILE *fp;
+	bstream *bs = bini_new();
+
+	bini_wi(bs, d.life);
+	bini_wi(bs, d.max);
+	bini_wi(bs, d.min);
+	bini_wi(bs, d.zero);
+
+	fp = fopen("fileio.bin", "wb");
+	if (!fp)
+	{
+		fprintf(stderr, "failed to open fileio.bin\n");
+		exit(1);
+	}
+	bini_fwrite(bs, 1, bs->len, fp);
+	fclose(fp);
+
+	bini_close(bs);
+}
+
+void read(struct data *d)
+{
+	FILE *fp;
+	bstream *bs = bini_new();
+
+	fp = fopen("fileio.bin", "rb");
+	if (!fp)
+	{
+		fprintf(stderr, "failed to open fileio.bin\n");
+		exit(1);
+	}
+	bini_fread(bs, 1, sizeof(*d), fp);
+	fclose(fp);
+
+	bini_dump(stderr, bs);
+
+	d->life = bini_ri(bs);
+	d->max = bini_ri(bs);
+	d->min = bini_ri(bs);
+	d->zero = bini_ri(bs);
+
+	printf("life=%d\n", d->life);
+	printf("max i32=%d\n", d->max);
+	printf("min i32=%d\n", d->min);
+	printf("zero=%d\n", d->zero);
+
+	bini_close(bs);
+}
+
+int main(void)
+{
+	struct data d = { 42, INT32_MAX, INT32_MIN, 0 };
+	write(d);
+	read(&d);
+}

examples/integers.c

···
+#define bini_libc_names
+#include <bini.c>
+
+void write(bstream *bs)
+{
+	bputi(bs, 42);
+	bputi(bs, INT32_MAX);
+	bputi(bs, INT32_MIN);
+	bputi(bs, 0);
+}
+
+void read(bstream *bs)
+{
+	printf("life=%d\n", breadi(bs));
+	printf("max i32=%d\n", breadi(bs));
+	printf("min i32=%d\n", breadi(bs));
+	printf("zero=%d\n", breadi(bs));
+}
+
+int main(void)
+{
+	bstream *bs = bnew();
+	write(bs);
+#	ifdef x_writebin
+	{
+	FILE *fp = fopen("out.bin", "wb");
+	fwrite(bs->buffer, 1, bs->len, fp);
+	fclose(fp);
+	}
+#	endif
+	bdump(stderr, bs);
+	read(bs);
+	bclose(bs);
+}

examples/strings.c

···
+#define bini_libc_names
+#include <bini.c>
+
+const char *msg1 = "Hello, World!";
+const char *msg2 = "Ping pong!";
+
+void write(bstream *bs)
+{
+	bputstr(bs, msg1);
+	bputstr(bs, msg2);
+}
+
+void read(bstream *bs)
+{
+	char msg[BUFSIZ];
+	size_t n = breadstr(bs, msg);
+	printf("msg1=%.*s\n", (int)n, msg);
+	n = breadstr(bs, msg);
+	printf("msg2=%.*s\n", (int)n, msg);
+}
+
+int main(void)
+{
+	bstream *bs = bnew();
+	write(bs);
+#	ifdef x_writebin
+	{
+	FILE *fp = fopen("out.bin", "wb");
+	fwrite(bs->buffer, 1, bs->len, fp);
+	fclose(fp);
+	}
+#	endif
+	bdump(stderr, bs);
+	read(bs);
+	bclose(bs);
+}

readme

···
+Bini
+====
+
+Endian-independent* binary IO utilities for C.
+
+*I only have access to little-endian machines, so it's
+currently untested on big endian, however it *should*
+work. If you have a big endian machine and are willing to
+test that Bini runs as expected, I'd be very grateful.
+
+Bini is written in plain ANSI C. If you're compiling in C99
+or later, functions for reading/writing long long and bool
+will be added automatically. You can override the C version
+Bini sees by passing -Dbini_c=<some year, i.e, 1989, 1999,
+2011, etc>.
+
+Usage
+-----
+
+Examples can be found in the </examples/> folder.
+
+I usually run examples with one of these commands:
+  cc examples/<example>.c -I. -g -Dbini_dbg -Dx_writebin && gdb -q -ex=r --args a.out
+  cc examples/<example>.c -I. -g -Dbini_dbg -Dx_writebin && ./a.out &> out.txt
+
+Sample:
+
+  /* Only define this once! You can use the bini.c file to
+     ensure you don't accidentally define bini_impl twice. */
+  #define bini_impl
+  #include <bini.h>
+
+  int main(void)
+  {
+    /* Allocate a new binary stream. */
+    struct bini_stream *bs = bini_new();
+    /* Write the meaning of life, the universe, and everything to our binary stream. */
+    bini_wi(bs, 42);
+    /* Read the meaning of life, the universe, and everything from our binary stream. */
+    int life = bini_ri(bs);
+    ASSERT(life == 42);
+    /* Close our stream, flushing+freeing the buffer and the stream itself. */
+    bini_close(bs);
+  }