include+lib+common: Update v.h with new v_arr implementation

The code is overall nicer to look at, however, some sacrifices had to be
made. I didn't foresee how mmap() & friends play with this new header +
array scheme (not well), so all that stuff makes ugly expensive copies
now as a stopgap. Everything seems to work, tests pass, and array stuff
is now much less verbose and overbuilt, so that's nice. I'll copy the
commit message from the (for now) private v.h repo commit message here
verbatim:

v.h: Reimplement v_arr

Technically this is v3 or even higher, but I think I'm getting close to
my ideal for dynamic, reallocating arrays.

Usage for the previous approach looked like this:

// generate scaffolding for custom type, foo_t. This generated a rather
// large blob of code that had a type-safe, generic interface via
// dynamic dispatch.
v_arr_def(foo_t)

void dostuff(void) {
    v_arr(foo_t) my_arr = v_arr_new(foo_t);
    v_arr_add(my_arr, (foo_t){ ...});
    v_arr_free(my_arr);
}

Benefits of this previous approach were that the generated code was
type safe, and I liked having an explicit "array of T" type to make it
more obvious there's more going on here than just a plain pointer.
The drawbacks, however, were numerous:
- Passing a v_arr(foo_t) by value was really awkward and bugprone.
- It required the use of that v_arr_def(T) macro in a strategic place,
  once for each type one would want to put in an array. I was moderately
  okay with this, I'd usually put the codegen after structs and other
  types.
- v_arr_def(T) was a bit awkward in that it required the type to not
  have spaces, so structs had to be typedef'd in order to use it. I
  generally try to avoid superfluous typedefs, and I like to call
  structs what they are, so this was unfortunate.
- Accessing elements was a bit ugly, having to use the arbitrarily named
  'items' element, e.g. 'my_arr.items[i] = ...' never really felt very
  good.
- It violated the 'zero is initialization' principle that I quite like,
  meaning that one had to always initialize each array with
  v_arr_new(T), otherwise the macro wrappers around array ops would
  detect a NULL ops table and trigger an abort. I *really* don't like
  that, and it is exactly this misfeature that prompted this rewrite.

This new implementation takes cues from Sean Barrett's delightful
stb_ds.h[1], mainly it reminded me to take another look at the concept
of a header + plain C array. I had played around with flexible struct
array members before, but this approach is even nicer. I adapted the
rest from the old implementation.

This new approach is very nice. I'm sure there are bugs and subtleties
to work out, but no more dynamic dispatch, heaps of macro codegen and
awkward semantics. v_arr now appears as a plain C array. Check this out:

foo_t *my_arr = { 0 }; // Or NULL, your choice
v_arr_add(my_arr, (foo_t){ ...}); // Nice!
// Array size & cap are now macros:
printf("len: %zu, cap: %zu\n", v_arr_len(my_arr), v_arr_cap(my_arr));
// Accessing elements feels good again:
my_arr[0].member = ...;
v_arr_free(my_arr); // After this, my_arr == NULL

I'm really quite happy with this. Thanks to Feoramund on Twitter[2] for
reminding me to take a look at stb_ds.h.

TODO: Custom allocator support, more operations & tests.
[1]: http://nothings.org/stb_ds
[2]: https://x.com/Feoramund/status/1995117603522576692

Author: vkoskiv

include/v.h

@@ -75,7 +75,7 @@ static const int B64index[256] = {
 };
 
 void *b64decode(const char *data, const size_t inputLength, size_t *outLength) {
-	if (!inputLength) return "";
+	if (!inputLength) return ""; // FIXME: NULL
 	unsigned char *p = (unsigned char *)data;
 	const size_t pad1 = inputLength % 4 || p[inputLength - 1] == '=';
 	const size_t pad2 = pad1 && (inputLength % 4 > 2 || p[inputLength - 2] != '=');

src/common/base64.c

@@ -44,6 +44,14 @@ char *stringCopy(const char *source) {
 	return copy;
 }
 
+char *stringCopyN(const char *source, size_t len) {
+	if (!source || !len)
+		return NULL;
+	char *copy = malloc(len + 1);
+	strncpy(copy, source, len);
+	return copy;
+}
+
 char *stringConcat(const char *str1, const char *str2) {
 	ASSERT(str1); ASSERT(str2);
 	char *new = malloc(strlen(str1) + strlen(str2) + 1);

src/common/cr_string.c

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <stdbool.h>
+#include <stddef.h>
 
 /// Check if two strings are equal
 /// @param s1 Left string
@@ -28,6 +29,7 @@ bool stringEndsWith(const char *postfix, const char *string);
 /// @param source String to be copied
 /// @return New heap-allocated string
 char *stringCopy(const char *source);
+char *stringCopyN(const char *source, size_t len);
 
 /// Concatenate given strings
 /// @param str1 Original string

src/common/cr_string.h

@@ -105,14 +105,20 @@ file_data file_load(const char *file_path) {
 	if (size == 0) {
 		return (file_data){ 0 };
 	}
-#ifndef WINDOWS
+#if !defined(WINDOWS)
 	int f = open(file_path, 0);
-	void *data = mmap(NULL, size, PROT_READ, MAP_SHARED, f, 0);
+	if (f < 0)
+		return (file_data){ 0 };
+	unsigned char *data = mmap(NULL, size, PROT_READ, MAP_SHARED, f, 0);
 	if (data == MAP_FAILED) {
 		logr(warning, "Couldn't mmap '%.*s': %s\n", (int)strlen(file_path), file_path, strerror(errno));
 		return (file_data){ 0 };
 	}
-	file_data file = (file_data){ .items = data, .count = size, .capacity = size };
+	// FIXME: static v_arr?
+	file_data file = { 0 };
+	v_arr_add_n(file, data, size);
+	munmap(data, size);
+	// file_data file = (file_data){ .items = data, .count = size, .capacity = size };
 	return file;
 #else
 	FILE *file = fopen(file_path, "rb");
@@ -125,21 +131,14 @@ file_data file_load(const char *file_path) {
 		buf[size] = '\0';
 	}
 	fclose(file);
-	file_data filedata = (file_data){ .items = buf, .count = readBytes, .capacity = readBytes };
-	return filedata;
-#endif
-}
-
-void file_free(file_data *file) {
-	if (!file || !file->items) return;
-#ifndef WINDOWS
-	munmap(file->items, file->count);
-#else
-	free(file->items);
+	// FIXME: static v_arr?
+	file_data file = { 0 };
+	v_arr_add_n(file, buf, readBytes);
+	free(buf);
+	return file;
+	// file_data filedata = (file_data){ .items = buf, .count = readBytes, .capacity = readBytes };
+	// return filedata;
 #endif
-	file->items = NULL;
-	file->capacity = 0;
-	file->count = 0;
 }
 
 void write_file(file_data data, const char *filePath) {
@@ -160,7 +159,7 @@ void write_file(file_data data, const char *filePath) {
 		}
 	}
 	logr(info, "Saving result in %s\'%s\'%s\n", KGRN, backupPath ? backupPath : filePath, KNRM);
-	fwrite(data.items, 1, data.count, file);
+	fwrite(data, 1, v_arr_len(data), file);
 	fclose(file);
 
 	//We determine the file size after saving, because the lodePNG library doesn't have a way to tell the compressed file size
@@ -252,37 +251,28 @@ char *get_file_path(const char *input) {
 #endif
 }
 
-#define chunksize 65536
+#define chunksize 4096
 //Get scene data from stdin and return a pointer to it
 file_data read_stdin(void) {
 	wait_for_stdin(2);
 
 	char chunk[chunksize];
 
-	size_t buf_size = 0;
-	unsigned char *buf = NULL;
 	int stdin_fd = fileno(stdin);
 	int read_bytes = 0;
+	file_data file = { 0 };
 	while ((read_bytes = read(stdin_fd, &chunk, chunksize)) > 0) {
-		unsigned char *old = buf;
-		buf = realloc(buf, buf_size + read_bytes + 1);
-		if (!buf) {
-			logr(error, "Failed to realloc stdin buffer\n");
-			free(old);
-			return (file_data){ 0 };
-		}
-		memcpy(buf + buf_size, chunk, read_bytes);
-		buf_size += read_bytes;
+		v_arr_add_n(file, chunk, read_bytes);
 	}
 
 	if (ferror(stdin)) {
 		logr(error, "Failed to read from stdin\n");
-		free(buf);
-		return (file_data){ 0 };
+		v_arr_free(file);
+		return NULL;
 	}
 
-	buf[buf_size ] = 0;
-	return (file_data){ .items = buf, .count = buf_size, .capacity = buf_size };
+	file[v_arr_len(file)] = 0;
+	return file;
 }
 
 char *human_file_size(unsigned long bytes, char *stat_buf) {

src/common/fileio.c

@@ -29,15 +29,12 @@ enum fileType {
 	glb,
 };
 
-typedef byte file_bytes;
-v_arr_def(file_bytes)
-typedef struct file_bytes_arr file_data;
+typedef byte * file_data;
 
 enum fileType match_file_type(const char *ext);
 enum fileType guess_file_type(const char *path);
 char *human_file_size(unsigned long bytes, char *stat_buf);
 file_data file_load(const char *filePath);
-void file_free(file_data *file);
 // This is a more robust file writing function, that will seek alternate directories
 // if the specified one wasn't writeable.
 void write_file(file_data file, const char *path);

src/common/fileio.h

@@ -29,7 +29,7 @@ uint32_t hashInit(void) {
 	return FNV_OFFSET;
 }
 
-uint32_t hashCombine(uint32_t h, uint8_t u) {
+static uint32_t hashCombine(uint32_t h, uint8_t u) {
 	return (h ^ u) * FNV_PRIME;
 }
 

src/common/hashtable.c

@@ -33,8 +33,8 @@ struct hashtable {
 
 // Hash functions (using FNV)
 uint32_t hashInit(void);
-uint32_t hashCombine(uint32_t, uint8_t);
 uint32_t hashBytes(uint32_t, const void *, size_t);
+#define hash_item(hash, item) hashBytes(hash, &(item), sizeof((uintptr_t)(item)))
 uint32_t hashString(uint32_t, const char *);
 
 struct hashtable *newHashtable(bool (*compare)(const void *, const void *), struct block **pool);

src/common/hashtable.h

@@ -259,13 +259,13 @@ struct transform parse_composite_transform(const cJSON *transforms) {
 	return composite;
 }
 
-struct cr_shader_node *check_overrides(struct mesh_material_arr file_mats, size_t mat_idx, const cJSON *overrides) {
-	if (mat_idx >= file_mats.count) return NULL;
+struct cr_shader_node *check_overrides(struct mesh_material *file_mats, size_t mat_idx, const cJSON *overrides) {
+	if (mat_idx >= v_arr_len(file_mats)) return NULL;
 	const cJSON *override = NULL;
 	if (!cJSON_IsArray(overrides)) return NULL;
 	cJSON_ArrayForEach(override, overrides) {
 		const cJSON *name = cJSON_GetObjectItem(override, "replace");
-		if (cJSON_IsString(name) && stringEquals(name->valuestring, file_mats.items[mat_idx].name)) {
+		if (cJSON_IsString(name) && stringEquals(name->valuestring, file_mats[mat_idx].name)) {
 			return cr_shader_node_build(override);
 		}
 	}
@@ -297,24 +297,24 @@ static void parse_mesh(struct cr_renderer *r, const cJSON *data, int idx, int me
 	long ms = us / 1000;
 	logr(debug, "Parsing file %-35s took %li %s\n", file_name, ms > 0 ? ms : us, ms > 0 ? "ms" : "μs");
 
-	if (!result.meshes.count) return;
+	if (!v_arr_len(result.meshes)) return;
 
 	struct cr_vertex_buf_param vbuf = {
-		.vertices = (struct cr_vector *)result.geometry.vertices.items,
-		.vertex_count = result.geometry.vertices.count,
-		.normals = (struct cr_vector *)result.geometry.normals.items,
-		.normal_count = result.geometry.normals.count,
-		.tex_coords = (struct cr_coord *)result.geometry.texture_coords.items,
-		.tex_coord_count = result.geometry.texture_coords.count,
+		.vertices = (struct cr_vector *)result.geometry.vertices,
+		.vertex_count = v_arr_len(result.geometry.vertices),
+		.normals = (struct cr_vector *)result.geometry.normals,
+		.normal_count = v_arr_len(result.geometry.normals),
+		.tex_coords = (struct cr_coord *)result.geometry.texture_coords,
+		.tex_coord_count = v_arr_len(result.geometry.texture_coords),
 	};
 	// Per JSON 'meshes' array element, these apply to materials before we assign them to instances
 	const struct cJSON *global_overrides = cJSON_GetObjectItem(data, "materials");
 
 	// Copy mesh materials to set
 	cr_material_set file_set = cr_scene_new_material_set(scene);
-	for (size_t i = 0; i < result.materials.count; ++i) {
+	for (size_t i = 0; i < v_arr_len(result.materials); ++i) {
 		struct cr_shader_node *maybe_override = check_overrides(result.materials, i, global_overrides);
-		cr_material_set_add(scene, file_set, maybe_override ? maybe_override : result.materials.items[i].mat);
+		cr_material_set_add(scene, file_set, maybe_override ? maybe_override : result.materials[i].mat);
 		if (maybe_override) cr_shader_node_free(maybe_override);
 	}
 
@@ -336,11 +336,11 @@ static void parse_mesh(struct cr_renderer *r, const cJSON *data, int idx, int me
 	const cJSON *instances = pick_instances ? pick_instances : add_instances;
 	if (!cJSON_IsArray(pick_instances)) {
 		// Generate one instance for every mesh, identity transform.
-		for (size_t i = 0; i < result.meshes.count; ++i) {
-			cr_mesh mesh = cr_scene_mesh_new(scene, result.meshes.items[i].name);
+		for (size_t i = 0; i < v_arr_len(result.meshes); ++i) {
+			cr_mesh mesh = cr_scene_mesh_new(scene, result.meshes[i].name);
 			cr_mesh_bind_vertex_buf(scene, mesh, vbuf);
 
-			cr_mesh_bind_faces(scene, mesh, result.meshes.items[i].faces.items, result.meshes.items[i].faces.count);
+			cr_mesh_bind_faces(scene, mesh, result.meshes[i].faces, v_arr_len(result.meshes[i].faces));
 			cr_instance m_instance = cr_instance_new(scene, mesh, cr_object_mesh);
 			cr_instance_bind_material_set(scene, m_instance, file_set);
 			cr_instance_set_transform(scene, m_instance, parse_composite_transform(cJSON_GetObjectItem(data, "transforms")).A.mtx);
@@ -355,13 +355,13 @@ static void parse_mesh(struct cr_renderer *r, const cJSON *data, int idx, int me
 		if (!mesh_name) continue;
 		// Find this mesh in parse result, and add it to the scene if it isn't there yet.
 		cr_mesh mesh = -1;
-		for (size_t i = 0; i < result.meshes.count; ++i) {
-			if (stringEquals(result.meshes.items[i].name, mesh_name)) {
-				mesh = cr_scene_get_mesh(scene, result.meshes.items[i].name);
+		for (size_t i = 0; i < v_arr_len(result.meshes); ++i) {
+			if (stringEquals(result.meshes[i].name, mesh_name)) {
+				mesh = cr_scene_get_mesh(scene, result.meshes[i].name);
 				if (mesh < 0) {
-					mesh = cr_scene_mesh_new(scene, result.meshes.items[i].name);
+					mesh = cr_scene_mesh_new(scene, result.meshes[i].name);
 					cr_mesh_bind_vertex_buf(scene, mesh, vbuf);
-					cr_mesh_bind_faces(scene, mesh, result.meshes.items[i].faces.items, result.meshes.items[i].faces.count);
+					cr_mesh_bind_faces(scene, mesh, result.meshes[i].faces, v_arr_len(result.meshes[i].faces));
 					cr_mesh_finalize(scene, mesh);
 				}
 			}
@@ -373,12 +373,12 @@ static void parse_mesh(struct cr_renderer *r, const cJSON *data, int idx, int me
 		// For the instance materials, we iterate the mesh materials, check if a "replace" exists with that name,
 		// if one does, use that, otherwise grab the mesh material.
 		const cJSON *instance_overrides = cJSON_GetObjectItem(instance, "materials");
-		for (size_t i = 0; i < result.materials.count; ++i) {
+		for (size_t i = 0; i < v_arr_len(result.materials); ++i) {
 			struct cr_shader_node *material = NULL;
 			// Find the material we want to use. Check if instance overrides it, otherwise use mesh global one
 			material = check_overrides(result.materials, i, instance_overrides);
 			// If material is NULL here, it gets set to an obnoxious material internally.
-			cr_material_set_add(scene, instance_set, material ? material : result.materials.items[i].mat);
+			cr_material_set_add(scene, instance_set, material ? material : result.materials[i].mat);
 			cr_shader_node_free(material);
 		}
 		cr_instance_set_transform(scene, new, parse_composite_transform(cJSON_GetObjectItem(instance, "transforms")).A.mtx);
@@ -387,13 +387,18 @@ static void parse_mesh(struct cr_renderer *r, const cJSON *data, int idx, int me
 
 done:
 
-	result.meshes.elem_free = ext_mesh_free;
-	ext_mesh_arr_free(&result.meshes);
-	result.materials.elem_free = mesh_material_free;
-	mesh_material_arr_free(&result.materials);
-	vector_arr_free(&result.geometry.vertices);
-	vector_arr_free(&result.geometry.normals);
-	coord_arr_free(&result.geometry.texture_coords);
+	// FIXME: impl elem_free
+	for (size_t i = 0; i < v_arr_len(result.meshes); ++i)
+		ext_mesh_free(&result.meshes[i]);
+	// result.meshes.elem_free = ext_mesh_free;
+	v_arr_free(result.meshes);
+	for (size_t i = 0; i < v_arr_len(result.materials); ++i)
+		mesh_material_free(&result.materials[i]);
+	// result.materials.elem_free = mesh_material_free;
+	v_arr_free(result.materials);
+	v_arr_free(result.geometry.vertices);
+	v_arr_free(result.geometry.normals);
+	v_arr_free(result.geometry.texture_coords);
 }
 
 static void parse_meshes(struct cr_renderer *r, const cJSON *data) {

src/common/json_loader.c

@@ -75,10 +75,10 @@ unsigned char *parse_buffer(const cJSON *data) {
 			return NULL;
 		}
 		file_data data = file_load(uri_string);
-		if (data.count != expected_bytes) {
-			logr(warning, "Invalid buffer while parsing glTF. Loaded file %s length %zu, expected %zu", uri_string, data.count, expected_bytes);
+		if (v_arr_len(data) != expected_bytes) {
+			logr(warning, "Invalid buffer while parsing glTF. Loaded file %s length %zu, expected %zu", uri_string, v_arr_len(data), expected_bytes);
 		}
-		return data.items;
+		return data;
 	}
 
 	return NULL;
@@ -192,8 +192,8 @@ struct mesh *parse_glb_meshes(const char *data, size_t *meshCount) {
 
 struct mesh *parse_glTF_meshes(const char *filePath, size_t *meshCount) {
 	file_data contents = file_load(filePath);
-	if (stringStartsWith("glTF", (char *)contents.items)) return parse_glb_meshes((char *)contents.items, meshCount);
-	const cJSON *data = cJSON_Parse((char *)contents.items);
+	if (stringStartsWith("glTF", (char *)contents)) return parse_glb_meshes((char *)contents, meshCount);
+	const cJSON *data = cJSON_Parse((char *)contents);
 
 	const cJSON *asset = cJSON_GetObjectItem(data, "asset");
 	if (asset) {