add criterion headers to ctags generation for linux

.snippets/c.snippets

@@ -1,23 +0,0 @@
-snippet testfile
-	#include <criterion/criterion.h>
-	#include "allocator.h"
-
-	Test($1, $2) {
-		$0
-	}
-
-snippet allocator
-	#include "allocator.h"
-
-	static void *${1}_alloc(void *this, size_t bytes, const char *file, int line) {
-	}
-	static void *${1}_resize(void *this, void *old_ptr, size_t bytes, const char *file, int line) {
-	}
-	static void ${1}_free(void *this, void *ptr, const char *file, int line) {
-	}
-
-	static const allocator_vtbl_t ${1}_vtbl = {
-		.alloc = ${1}_alloc,
-		.resize = ${1}_resize,
-		.free = ${1}_free,
-	};

README.md

@@ -101,7 +101,7 @@ int main(void) {
 #define CIG_IMPL
 #include "cig/cig.h"
 
-int main(int argc, const char **argv) {
+int main(int argc, char const **argv) {
     args_t args = cli_make_args(argc, argv);
 
     if (cli_command(&args, "say-foo")) {
@@ -112,7 +112,7 @@ int main(int argc, const char **argv) {
     } else
     if (cli_command(&args), "greet") {
         bool do_nothing = cli_bool(args, "--do-nothing");
-        const char *name = cli_req_str(args, "--name");
+        char const *name = cli_req_str(args, "--name");
         if (args.help) exit(0);
 
         if (do_nothing) {

cig.h

@@ -31,8 +31,8 @@ typedef struct allocator {
 	const allocator_vtbl_t *vtbl;
 } allocator_t;
 
-void *allocator_alloc_func(allocator_t this, size_t bytes, const char *file, int line);
-void *allocator_resize_func(allocator_t this, void *old_ptr, size_t bytes, const char *file, int line);
+void *allocator_alloc_func(allocator_t this, size_t bytes, char const *file, int line);
+void *allocator_resize_func(allocator_t this, void *old_ptr, size_t bytes, char const *file, int line);
 void allocator_reset(allocator_t this);
 #define allocator_alloc(this, bytes) allocator_alloc_func(this, bytes, __FILE__, __LINE__)
 #define allocator_resize(this, old_ptr, bytes) allocator_resize_func(this, old_ptr, bytes, __FILE__, __LINE__)
@@ -150,7 +150,7 @@ typedef struct dyn_array_create_func_args {
 	allocator_t allocator;
 	size_t itemsize;
 	size_t initial_capacity;
-	const char *file;
+	char const *file;
 	int line;
 } dyn_array_create_func_args_t;
 void *dyn_array_create_func(dyn_array_create_func_args_t args);
@@ -164,8 +164,8 @@ void *dyn_array_create_func(dyn_array_create_func_args_t args);
 
 // Always reassign the array. if multiple variables reference the same growing
 // array, then you should be using pointer pointers.
-void *dyn_array_grow_func(void *this, size_t n_new_items, const char *file, int line);
-void dyn_array_shrink_func(void *this, size_t n_items_to_remove, const char *file, int line);
+void *dyn_array_grow_func(void *this, size_t n_new_items, char const *file, int line);
+void dyn_array_shrink_func(void *this, size_t n_items_to_remove, char const *file, int line);
 
 #define arr_grow(THIS, N_NEW_ITEMS) \
   dyn_array_grow_func(THIS, N_NEW_ITEMS, __FILE__, __LINE__)
@@ -190,7 +190,7 @@ size_t arr_cap(void *this);
 
 #define arr_pop(THIS) (arr_shrink(THIS, 1), THIS[arr_len(THIS)])
 
-void dyn_array_bounds_check_func(void *this, size_t index, const char *file, int line, bool print_error);
+void dyn_array_bounds_check_func(void *this, size_t index, char const *file, int line, bool print_error);
 
 #define arr_get(THIS, INDEX) \
 	(dyn_array_bounds_check_func(THIS, INDEX, __FILE__, __LINE__, true), (THIS)[INDEX])
@@ -230,18 +230,18 @@ void arr_qsort(void *this, dyn_array_cmp_fn cmp_fn);
 
 typedef struct args {
 	int count;
-	const char **values;
+	char const **values;
 	bool help;
 	int indentation;
 } args_t;
 
-args_t cli_make_args(int argc, const char **argv);
-bool cli_command(args_t *args, const char *command_name);
-bool cli_bool(args_t args, const char *flag_name);
-bool cli_opt_str_func(args_t args, const char *flag_name, const char **output, const char *file, int line);
-const char *cli_req_str_func(args_t args, const char *flag_name, const char *file, int line);
-bool cli_opt_int_func(args_t args, const char *flag_name, int *output, const char *file, int line);
-int cli_req_int_func(args_t args, const char *flag_name, const char *file, int line);
+args_t cli_make_args(int argc, char const **argv);
+bool cli_command(args_t *args, char const *command_name);
+bool cli_bool(args_t args, char const *flag_name);
+bool cli_opt_str_func(args_t args, char const *flag_name, char const **output, char const *file, int line);
+char const *cli_req_str_func(args_t args, char const *flag_name, char const *file, int line);
+bool cli_opt_int_func(args_t args, char const *flag_name, int *output, char const *file, int line);
+int cli_req_int_func(args_t args, char const *flag_name, char const *file, int line);
 
 #define cli_opt_str(ARGS, FLAG_NAME, OUTPUT) cli_opt_str_func(ARGS, FLAG_NAME, OUTPUT, __FILE__, __LINE__)
 #define cli_req_str(ARGS, FLAG_NAME) cli_req_str_func(ARGS, FLAG_NAME, __FILE__, __LINE__)
@@ -249,12 +249,12 @@ int cli_req_int_func(args_t args, const char *flag_name, const char *file, int l
 #define cli_req_int(ARGS, FLAG_NAME) cli_req_int_func(ARGS, FLAG_NAME, __FILE__, __LINE__)
 
 #define with_opt_str(ARGS, FLAG_NAME, VAR) \
-	for (const char *VAR = NULL; VAR == NULL;) \
+	for (char const *VAR = NULL; VAR == NULL;) \
 	for (bool CLI_UNIQUE1 = true; CLI_UNIQUE1;) \
 	for ( \
 		bool CLI_UNIQUE2 = (CLI_UNIQUE1 = cli_opt_str(ARGS, FLAG_NAME, &VAR), true); \
 		CLI_UNIQUE2; \
-		CLI_UNIQUE2 = (VAR = ((const char *) 1), CLI_UNIQUE1 = false, false) \
+		CLI_UNIQUE2 = (VAR = ((char const *) 1), CLI_UNIQUE1 = false, false) \
 	) \
 	if (CLI_UNIQUE1)
 
@@ -270,10 +270,12 @@ int cli_req_int_func(args_t args, const char *flag_name, const char *file, int l
 
 // scanner /////////////////////////////////////////////////////////////////////
 
-typedef struct error_node {
-	char *msg;
-	struct error_node *next;
-} error_node_t;
+typedef struct scan_error {
+	char const * message;
+	char const * buffer_name;
+	int line;
+	int column;
+} scan_error_t;
 
 typedef union scan_value {
 	int digit;
@@ -291,47 +293,116 @@ typedef union scan_value {
 	char *string_literal;
 } scan_value_t;
 
+typedef struct scan_result {
+	bool ok;
+	union {
+		scan_value_t value;
+		scan_error_t error;
+	};
+} scan_result_t;
+
 typedef struct scanner {
-	const char *name; // name of the buffer
-	const char *start; // pointer to the full buffer
-	const char *cur; // current pointer
-	scan_value_t value;
-	error_node_t *errors; // singly linked list of error strings
+	char const *name; // name of the buffer
+	char const *start; // pointer to the full buffer
+	char const *cur; // current pointer
 	allocator_t allocator;
 } scanner_t;
 
-scanner_t make_scanner(const char *name, const char *buffer, allocator_t allocator);
+scanner_t make_scanner(char const *name, char const *buffer, allocator_t allocator);
 void scanner_recover(scanner_t *s);
-void scanner_error(scanner_t *s, const char *message);
-void scanner_error_and_recover(scanner_t *s, const char *message);
+scan_result_t scan_error(scanner_t *s, char const *message);
+
+scan_result_t scan_value_func(scan_value_t value);
+#define scan_value(arg) scan_value_func((scan_value_t){arg})
+
+scan_result_t scan_error_and_recover(scanner_t *s, char const *message);
 bool scan_eof(scanner_t *s);
-bool scan_literal(scanner_t *s, const char *lit);
-int scan_repeat_literal(scanner_t *s, const char *lit);
+bool scan_literal(scanner_t *s, char const *lit);
+int scan_repeat_literal(scanner_t *s, char const *lit);
 bool scan_whitespace(scanner_t *s);
-bool scan_digit(scanner_t *s);
-bool scan_i64(scanner_t *s);
-bool scan_i32(scanner_t *s);
-bool scan_i16(scanner_t *s);
-bool scan_i8(scanner_t *s);
-bool scan_u64(scanner_t *s);
-bool scan_u32(scanner_t *s);
-bool scan_u16(scanner_t *s);
-bool scan_u8(scanner_t *s);
-bool scan_f64(scanner_t *s);
-bool scan_f32(scanner_t *s);
+scan_result_t scan_digit(scanner_t *s);
+scan_result_t scan_i64(scanner_t *s);
+// TODO: make a lot of these references constant. they no longer write back to
+// the scanner struct.
+scan_result_t scan_i32(scanner_t *s);
+scan_result_t scan_i16(scanner_t *s);
+scan_result_t scan_i8(scanner_t *s);
+scan_result_t scan_u64(scanner_t *s);
+scan_result_t scan_u32(scanner_t *s);
+scan_result_t scan_u16(scanner_t *s);
+scan_result_t scan_u8(scanner_t *s);
+scan_result_t scan_f64(scanner_t *s);
+scan_result_t scan_f32(scanner_t *s);
 // Scan as much of an identifier as possible, you are responsible to scan for
 // valid characters after the identifier is scanned.
-bool scan_identifier(scanner_t *s);
-bool scan_string_literal(scanner_t *s);
-bool scanner_print_errors(scanner_t *s, FILE *fp);
+scan_result_t scan_identifier(scanner_t *s);
+scan_result_t scan_string_literal(scanner_t *s);
+bool scanner_print_errors_func(FILE *fp, scan_result_t const *results, int results_len);
+#define scanner_print_errors(FP, ...) scanner_print_errors_func(FP, (scan_result_t const []){__VA_ARGS__}, sizeof((scan_result_t[]){__VA_ARGS__}) / sizeof(((scan_result_t[]){__VA_ARGS__})[0]))
 bool looks_like_float(scanner_t *s);
 bool looks_like_int(scanner_t *s);
 
+// json parser /////////////////////////////////////////////////////////////////
+
+typedef enum json_type {
+	json_type_array,
+	json_type_boolean,
+	json_type_null,
+	json_type_number,
+	json_type_object,
+	json_type_string,
+	count_json_type_t
+} json_type_t;
+
+typedef struct json_string {
+	const char *buffer;
+	size_t length;
+} json_string_t;
+
+struct json_pair;
+
+typedef struct json_object {
+	struct json_pair *pairs;
+	size_t length;
+} json_object_t;
+
+struct json_value;
+
+typedef struct json_array {
+	struct json_value *values;
+	size_t length;
+} json_array_t;
+
+typedef struct json_value {
+	json_type_t type;
+	union {
+		bool boolean;
+		double number;
+		json_object_t object;
+		json_array_t array;
+		json_string_t string;
+	};
+} json_value_t;
+
+typedef struct json_pair {
+	json_string_t key;
+	json_value_t value;
+} json_pair_t;
+
+bool json_as_array(json_value_t *value, json_array_t *array);
+bool json_as_boolean(json_value_t *value, bool *out_bool);
+bool json_as_null(json_value_t *value);
+bool json_as_number(json_value_t *value, double *out_double);
+bool json_as_object(json_value_t *value, json_object_t *out_object);
+bool json_as_string(json_value_t *value, json_string_t *out_string);
+bool json_obj_get(json_object_t *obj, json_string_t key, json_value_t *out_value);
+json_value_t json_parse(scanner_t *scanner, allocator_t allocator);
+
 // string builder //////////////////////////////////////////////////////////////
 typedef struct string_builder_node {
 	struct string_builder_node *next;
 	size_t length;
-	const char *string;
+	char const *string;
 } string_builder_node_t;
 
 typedef struct string_builder {
@@ -342,7 +413,7 @@ typedef struct string_builder {
 
 string_builder_t sb_create(allocator_t builder_allocator);
 // assumes the provided string will live until sb_build_and_clear is called.
-void sb_add_string(string_builder_t *this, const char *string);
+void sb_add_string(string_builder_t *this, char const *string);
 void sb_add_i64(string_builder_t *this, int64_t i64);
 void sb_add_i32(string_builder_t *this, int32_t i32);
 void sb_add_i16(string_builder_t *this, int16_t i16);
@@ -351,17 +422,17 @@ void sb_add_u64(string_builder_t *this, uint64_t u64);
 void sb_add_u32(string_builder_t *this, uint32_t u32);
 void sb_add_u16(string_builder_t *this, uint16_t u16);
 void sb_add_u8(string_builder_t *this, uint8_t u8);
-void sb_add_substring(string_builder_t *this, const char *string, size_t substring_length);
-const char *sb_build_and_clear(string_builder_t *this, allocator_t output_allocator);
+void sb_add_substring(string_builder_t *this, char const *string, size_t substring_length);
+char const *sb_build_and_clear(string_builder_t *this, allocator_t output_allocator);
 void sb_fprint_and_clear(string_builder_t *this, FILE *dest);
 
 // file_io /////////////////////////////////////////////////////////////////////
-char *read_entire_file(const char *path, allocator_t allocator);
-char **read_all_file_lines(const char *path, allocator_t allocator);
+char *read_entire_file(char const *path, allocator_t allocator);
+char **read_all_file_lines(char const *path, allocator_t allocator);
 
 #ifdef CIG_IMPL
 
-void *allocator_alloc_func(allocator_t this, size_t bytes, const char *file, int line) {
+void *allocator_alloc_func(allocator_t this, size_t bytes, char const *file, int line) {
 	void *ptr = this.vtbl->alloc(this.this, bytes);
 	if (ptr == NULL) {
 		fprintf(stderr, "%s:%d: alloc returned NULL\n", file, line);
@@ -369,7 +440,7 @@ void *allocator_alloc_func(allocator_t this, size_t bytes, const char *file, int
 	}
 	return ptr;
 }
-void *allocator_resize_func(allocator_t this, void *old_ptr, size_t bytes, const char *file, int line) {
+void *allocator_resize_func(allocator_t this, void *old_ptr, size_t bytes, char const *file, int line) {
 	void *ptr = this.vtbl->resize(this.this, old_ptr, bytes);
 	if (ptr == NULL) {
 		fprintf(stderr, "%s:%d: alloc returned NULL\n", file, line);
@@ -388,6 +459,7 @@ void allocator_reset(allocator_t this) {
 #include "dyn_array.c"
 #include "cli.c"
 #include "scanner.c"
+#include "json.c"
 #include "string_builder.c"
 #include "file_io.c"
 

cli.c

@@ -9,7 +9,7 @@ static void cli_print_indentation(args_t args) {
 	}
 }
 
-bool cli_command(args_t *args, const char *command_name) {
+bool cli_command(args_t *args, char const *command_name) {
 	if (args->help) {
 		cli_print_indentation(*args);
 		printf("[ cmd ] %s\n", command_name);
@@ -25,7 +25,7 @@ bool cli_command(args_t *args, const char *command_name) {
 	return false;
 }
 
-bool cli_bool(args_t args, const char *flag_name) {
+bool cli_bool(args_t args, char const *flag_name) {
 	if (args.help) {
 		cli_print_indentation(args);
 		printf("[ flg ] %s\n", flag_name);
@@ -39,7 +39,7 @@ bool cli_bool(args_t args, const char *flag_name) {
 	return false;
 }
 
-bool cli_opt_str_func(args_t args, const char *flag_name, const char **output, const char *file, int line) {
+bool cli_opt_str_func(args_t args, char const *flag_name, char const **output, char const *file, int line) {
 	if (args.help) {
 		cli_print_indentation(args);
 		printf("[ opt ] %s\n", flag_name);
@@ -56,7 +56,7 @@ bool cli_opt_str_func(args_t args, const char *flag_name, const char **output, c
 			break;
 		}
 	}
-	static const char *dummy = "";
+	static char const *dummy = "";
 	if (!is_flag_name_found) {
 		*output = dummy;
 		return false;
@@ -70,14 +70,14 @@ bool cli_opt_str_func(args_t args, const char *flag_name, const char **output, c
 	return true;
 }
 
-const char *cli_req_str_func(args_t args, const char *flag_name, const char *file, int line) {
+char const *cli_req_str_func(args_t args, char const *flag_name, char const *file, int line) {
 	if (args.help) {
 		cli_print_indentation(args);
 		printf("[ req ] %s\n", flag_name);
 		return "";
 	}
 	
-	const char *value;
+	char const *value;
 	if (cli_opt_str_func(args, flag_name, &value, file, line)) {
 		return value;
 	} else {
@@ -87,7 +87,7 @@ const char *cli_req_str_func(args_t args, const char *flag_name, const char *fil
 	return "";
 }
 
-bool cli_opt_int_func(args_t args, const char *flag_name, int *output, const char *file, int line) {
+bool cli_opt_int_func(args_t args, char const *flag_name, int *output, char const *file, int line) {
 	if (args.help) {
 		cli_print_indentation(args);
 		printf("[ opt ] %s\n", flag_name);
@@ -95,7 +95,7 @@ bool cli_opt_int_func(args_t args, const char *flag_name, int *output, const cha
 		return false;
 	}
 	
-	const char *text = "";
+	char const *text = "";
 	if (cli_opt_str_func(args, flag_name, &text, file, line)) {
 		if (
 			text[0] != '-' &&
@@ -112,7 +112,7 @@ bool cli_opt_int_func(args_t args, const char *flag_name, int *output, const cha
 			fprintf(stderr, "%s:%d: Invalid integer %s!\n", file, line, text);
 			exit(1);
 		}
-		for ( const char *c = &text[1]; (*c) != '\0'; c++ ) {
+		for ( char const *c = &text[1]; (*c) != '\0'; c++ ) {
 			if ((*c) < '0' || '9' < (*c)) {
 				fprintf(stderr, "%s:%d: Invalid integer %s!\n", file, line, text);
 				exit(1);
@@ -125,7 +125,7 @@ bool cli_opt_int_func(args_t args, const char *flag_name, int *output, const cha
 	return false;
 }
 
-int cli_req_int_func(args_t args, const char *flag_name, const char *file, int line) {
+int cli_req_int_func(args_t args, char const *flag_name, char const *file, int line) {
 	if (args.help) {
 		cli_print_indentation(args);
 		printf("[ req ] %s\n", flag_name);
@@ -142,7 +142,7 @@ int cli_req_int_func(args_t args, const char *flag_name, const char *file, int l
 	return 0;
 }
 
-args_t cli_make_args(int argc, const char **argv) {
+args_t cli_make_args(int argc, char const **argv) {
 	args_t args = (args_t) {
 		.count = argc-1,
 		.values = argv+1,

dyn_array.c

@@ -16,7 +16,7 @@ void *dyn_array_create_func(dyn_array_create_func_args_t args) {
 	return &header->bytes;
 }
 
-void *dyn_array_grow_func(void *this, size_t n_new_items, const char *file, int line) {
+void *dyn_array_grow_func(void *this, size_t n_new_items, char const *file, int line) {
 	dyn_array_header_t *header = PTR_FROM_FIELD_PTR(dyn_array_header_t, bytes, this);
 	size_t new_size = header->n_items + n_new_items;
 
@@ -40,7 +40,7 @@ void *dyn_array_grow_func(void *this, size_t n_new_items, const char *file, int
 }
 
 
-void dyn_array_shrink_func(void *this, size_t n_items_to_remove, const char *file, int line) {
+void dyn_array_shrink_func(void *this, size_t n_items_to_remove, char const *file, int line) {
 	if (arr_len(this) < n_items_to_remove) {
 		fprintf(
 			stderr,
@@ -97,7 +97,7 @@ bool dyn_array_contains_eq_func(void *this, uint8_t *value, dyn_array_eq_fn eq)
 	return false;
 }
 
-void dyn_array_bounds_check_func(void *this, size_t index, const char *file, int line, bool print_error) {
+void dyn_array_bounds_check_func(void *this, size_t index, char const *file, int line, bool print_error) {
 	size_t len = arr_len(this);
 	if ((index >= len)) {
 		if (print_error) {

file_io.c

@@ -1,7 +1,7 @@
 #include "cig.h"
 #include <assert.h>
 
-char *read_entire_file(const char *path, allocator_t allocator) {
+char *read_entire_file(char const *path, allocator_t allocator) {
 	FILE *fp = fopen(path, "rb");
 	assert(fp != NULL);
 	fseek(fp, 0, SEEK_END);
@@ -17,7 +17,7 @@ char *read_entire_file(const char *path, allocator_t allocator) {
 }
 
 // Returns dynamic array, of fixed char strings.
-char **read_all_file_lines(const char *path, allocator_t allocator) {
+char **read_all_file_lines(char const *path, allocator_t allocator) {
 	char *contents = read_entire_file(path, allocator);
 	char **lines = make_arr(char*, allocator);
 	arr_append(lines, contents);

json.c

@@ -0,0 +1,66 @@
+#include "cig.h"
+#include <string.h>
+
+bool json_as_array(json_value_t *value, json_array_t *array) {
+}
+
+bool json_as_boolean(json_value_t *value, bool *out_bool) {
+}
+
+bool json_as_null(json_value_t *value) {
+}
+
+bool json_as_number(json_value_t *value, double *out_double) {
+}
+
+bool json_as_object(json_value_t *value, json_object_t *out_object) {
+}
+
+bool json_as_string(json_value_t *value, json_string_t *out_string) {
+}
+
+bool json_obj_get(json_object_t *obj, json_string_t key, json_value_t *out_value) {
+}
+
+json_value_t json_parse(scanner_t *scanner, allocator_t allocator) {
+	scan_whitespace(scanner);
+	if (scan_string_literal(scanner)) {
+		const char *buffer = scanner->value.string_literal;
+		size_t length = strlen(buffer);
+		char *buff_copy = allocator_alloc(allocator, length+1);
+		strncpy(buff_copy, buffer, length+1);
+		buff_copy[length] = '\0';
+		return (json_value_t) {
+			.type=json_type_string,
+			.string=(json_string_t) { .length=length, .buffer=buff_copy }
+		};
+	} else if (scan_f64(scanner)) {
+		return (json_value_t) {
+			.type=json_type_number,
+			.number=scanner->value.f64
+		};
+	} else if (scan_i64(scanner)) {
+		// TODO: is this needed?
+		return (json_value_t) {
+			.type=json_type_number,
+			.number=(double)scanner->value.i64
+		};
+	} else if (scan_literal(scanner, "true")) {
+		return (json_value_t) {
+			.type=json_type_boolean,
+			.boolean=true
+		};
+	} else if (scan_literal(scanner, "false")) {
+		return (json_value_t) {
+			.type=json_type_boolean,
+			.boolean=false
+		};
+	} else if (scan_literal(scanner, "null")) {
+		return (json_value_t) {
+			.type=json_type_null
+		};
+	} else if (scan_literal(scanner, "[")) {
+		json_parse(scanner, allocator);
+		// TODO
+	}
+}

justfile

@@ -1,40 +1,5 @@
-CC := "zig cc"
-CFLAGS := "-pedantic -Wall -Wextra -Wno-override-init -O0 -g -fno-omit-frame-pointer -fno-inline"
-LDFLAGS := if os() == "macos" {
-    "$(pkg-config --libs --cflags criterion)"
-} else {
-    "-lcriterion"
-}
-
-TMP := "/tmp"
-
-TESTBIN := TMP/"all_tests"
-
 set shell := ["bash", "-cu"]
 
-
-FOOBAR := "foobar"
-FOOBAR_SOURCE := FOOBAR+".c"
-FOOBAR_BIN := TMP/FOOBAR
-FOOBAR_EXPANDED := TMP/FOOBAR+"-expanded.c"
-
-build_foobar2:
-    {{CC}} {{FOOBAR_SOURCE}} {{CFLAGS}} -o foobar2
-
-run_foobar: build_foobar
-    {{FOOBAR_BIN}}
-
-build_foobar: foobar_expanded
-    {{CC}} {{FOOBAR_EXPANDED}} {{CFLAGS}} -o {{FOOBAR_BIN}}
-    echo "{{FOOBAR_BIN}}"
-
-foobar_expanded:
-    {{CC}} -P -E {{FOOBAR_SOURCE}} -o {{FOOBAR_EXPANDED}}
-    clang-format -i {{FOOBAR_EXPANDED}}
-
-clean_foobar:
-    rm {{FOOBAR_BIN}}
-
 [default]
 test: build
     {{TESTBIN}}
@@ -49,12 +14,26 @@ test_memcheck: build
 build:
     find . -type f -name 'test*.c' | xargs -r {{CC}} {{CFLAGS}} {{LDFLAGS}} _allocator_impl.c -o {{TESTBIN}}
 
+tag:
+    @echo "Making tags from project and headers in {{DEPENDENCY_HEADERS}}"
+    ctags --languages=c --langmap=c:.c.h -R {{DEPENDENCY_HEADERS}} .
+
+
+CC := "zig cc"
+CFLAGS := "-pedantic -Wall -Wextra -Wno-override-init -O0 -g -fno-omit-frame-pointer -fno-inline"
+TMP := "/tmp"
+TESTBIN := TMP/"all_tests"
+LDFLAGS := if os() == "macos" {
+    "$(pkg-config --libs --cflags criterion)"
+} else if os() == "linux" {
+    "-lcriterion"
+} else {
+    "TODO: windows"
+}
 DEPENDENCY_HEADERS := if os() == "macos" {
     "$(pkg-config --cflags-only-I criterion | sed 's/-I//g')"
+} else if os() == "linux" {
+    "/usr/include/criterion/"
 } else {
-    "TODO"
+    "TODO: windows"
 }
-
-tag:
-    echo "Making tags from project and headers in {{DEPENDENCY_HEADERS}}"
-    ctags --languages=c --langmap=c:.c.h -R {{DEPENDENCY_HEADERS}} .

scanner.c

@@ -4,13 +4,11 @@
 #include <string.h>
 #include <errno.h>
 
-scanner_t make_scanner(const char *name, const char *buffer, allocator_t allocator) {
+scanner_t make_scanner(char const *name, char const *buffer, allocator_t allocator) {
 	scanner_t s = {
 		.name = name,
 		.start = buffer,
 		.cur = buffer,
-		.value = {0},
-		.errors = NULL,
 		.allocator = allocator
 	};
 	return s;
@@ -24,47 +22,46 @@ void scanner_recover(scanner_t *s) {
 		s->cur++;  // move *past* the newline
 }
 
-void scanner_error(scanner_t *s, const char *message) {
-	const char *error_pos = s->cur; // use current scanner position
+scan_result_t scan_error(scanner_t *s, char const * message) {
+	char const *error_pos = s->cur; // use current scanner position
 	// Compute line + column (1-based)
-	int line = 1, col = 1;
-	for (const char *p = s->start; p < error_pos; p++) {
-		if (*p == '\n') { line++; col = 1; }
-		else col++;
-	}
-	// need 40 bytes for pair of largest possible 64 bit values, then some for
-	// ':' and ' ' characters. Just rounded up to 64 because reasons.
-	size_t length = strlen(s->name) + 1 + strlen(message) + 1 + 64;
-	char *buf = allocator_alloc(s->allocator, length);
-	snprintf(
-		buf,
-		length,
-		"%s:%d:%d: %s",
-		s->name, line, col, message
-	);
-	error_node_t *node = allocator_alloc(s->allocator, sizeof(error_node_t));
-	node->msg = buf;
-	node->next = NULL;
-	if (!s->errors) {
-		s->errors = node;
-	} else {
-		error_node_t *p = s->errors;
-		while (p->next) p = p->next;
-		p->next = node;
+	int line = 1, column = 1;
+	for (char const *p = s->start; p < error_pos; p++) {
+		if (*p == '\n') { line++; column = 1; }
+		else column++;
 	}
+
+	return (scan_result_t) {
+		.ok=false,
+		.error=(scan_error_t) {
+			.message=message,
+			.buffer_name=s->name,
+			.line=line,
+			.column=column
+		}
+	};
+
 }
 
-void scanner_error_and_recover(scanner_t *s, const char *message) {
-	scanner_error(s, message);
+scan_result_t scan_value_func(scan_value_t value) {
+	return (scan_result_t) {
+		.ok=true,
+		.value=value,
+	};
+}
+
+scan_result_t scan_error_and_recover(scanner_t *s, char const *message) {
+	scan_result_t result = scan_error(s, message);
 	scanner_recover(s);
+	return result;
 }
 
 bool scan_eof(scanner_t *s) {
 	return *s->cur == '\0';
 }
 
-bool scan_literal(scanner_t *s, const char *lit) {
-	const char *save = s->cur;
+bool scan_literal(scanner_t *s, char const *lit) {
+	char const *save = s->cur;
 	while (*lit && *lit == *s->cur) {
 		lit++;
 		s->cur++;
@@ -76,7 +73,7 @@ bool scan_literal(scanner_t *s, const char *lit) {
 	return false;
 }
 
-int scan_repeat_literal(scanner_t *s, const char *lit) {
+int scan_repeat_literal(scanner_t *s, char const *lit) {
 	int n_repeats = 0;
 	while (scan_literal(s, lit)) {
 		n_repeats++;
@@ -85,26 +82,26 @@ int scan_repeat_literal(scanner_t *s, const char *lit) {
 }
 
 bool scan_whitespace(scanner_t *s) {
-	const char *save = s->cur;
+	char const *save = s->cur;
 	while (isspace((unsigned char)*s->cur)) s->cur++;
 	return save != s->cur;
 }
 
-bool scan_digit(scanner_t *s) {
+scan_result_t scan_digit(scanner_t *s) {
 	if (!isdigit((unsigned char)*s->cur)) {
-		return false;
+		return scan_error(s, "not a digit");
 	}
-	s->value.digit = (*s->cur) - '0';
+	scan_result_t ret = scan_value(.digit=(*s->cur) - '0');
 	s->cur++;
-	return true;
+	return ret;
 }
 
-bool scan_i64(scanner_t *s) {
-	const char *save = s->cur;
+scan_result_t scan_i64(scanner_t *s) {
+	char const *save = s->cur;
 	if (*s->cur == '-' || *s->cur == '+') s->cur++;
 	if (!isdigit((unsigned char)*s->cur)) {
 		s->cur = save;
-		return false;
+		return scan_error(s, "not an i64");
 	}
 	s->cur = save;
 	char *end;
@@ -112,69 +109,63 @@ bool scan_i64(scanner_t *s) {
 	int64_t val = strtoll(s->cur, &end, 10);
 	if (end == s->cur) {
 		s->cur = save;
-		return false;
+		return scan_error(s, "not an i64");
 	}
 	if (errno == ERANGE) {
-		scanner_error(s, "integer does not fit in i64 value");
-		return false;
+		return scan_error(s, "integer does not fit in i64 value");
 	}
 	s->cur = end;
-	s->value.i64 = val;
-	return true;
+	return scan_value(.i64=val);
 }
 
-bool scan_i32(scanner_t *s) {
-	if (!scan_i64(s)) {
-		return false;
+scan_result_t scan_i32(scanner_t *s) {
+	scan_result_t result = scan_i64(s);
+	if (!result.ok) {
+		return result;
 	}
-	int32_t val = (int32_t)s->value.i64;
+	int32_t val = (int32_t)result.value.i64;
 	int64_t back = (int64_t)val;
-	if (back != s->value.i64) {
-		scanner_error(s, "int does not fit in i32 value");
-		return false;
+	if (back != result.value.i64) {
+		return scan_error(s, "int does not fit in i32 value");
 	}
-	s->value.i32 = val;
-	return true;
+	return scan_value(val);
 }
 
-bool scan_i16(scanner_t *s) {
-	if (!scan_i64(s)) {
-		return false;
+scan_result_t scan_i16(scanner_t *s) {
+	scan_result_t result = scan_i64(s);
+	if (!result.ok) {
+		return result;
 	}
-	int16_t val = (int16_t)s->value.i64;
+	int16_t val = (int16_t)result.value.i64;
 	int64_t back = (int64_t)val;
-	if (back != s->value.i64) {
-		scanner_error(s, "int does not fit in i16 value");
-		return false;
+	if (back != result.value.i64) {
+		return scan_error(s, "int does not fit in i16 value");
 	}
-	s->value.i16 = val;
-	return true;
+	return scan_value(val);
 }
 
-bool scan_i8(scanner_t *s) {
-	if (!scan_i64(s)) {
-		return false;
+scan_result_t scan_i8(scanner_t *s) {
+	scan_result_t result = scan_i64(s);
+	if (!result.ok) {
+		return result;
 	}
-	int8_t val = (int8_t)s->value.i64;
+	int8_t val = (int8_t)result.value.i64;
 	int64_t back = (int64_t)val;
-	if (back != s->value.i64) {
-		scanner_error(s, "int does not fit in i8 value");
-		return false;
+	if (back != result.value.i64) {
+		return scan_error(s, "int does not fit in i8 value");
 	}
-	s->value.i8 = val;
-	return true;
+	return scan_value(val);
 }
 
-bool scan_u64(scanner_t *s) {
-	const char *save = s->cur;
+scan_result_t scan_u64(scanner_t *s) {
+	char const *save = s->cur;
 	if (*s->cur == '-') {
-		scanner_error(s, "- is not allowed for unsigned integers");
-		return false;
+		return scan_error(s, "- is not allowed for unsigned integers");
 	}
 	if (*s->cur == '+') s->cur++;
 	if (!isdigit((unsigned char)*s->cur)) {
 		s->cur = save;
-		return false;
+		return scan_error(s, "is not number");
 	}
 	s->cur = save;
 	char *end;
@@ -182,96 +173,89 @@ bool scan_u64(scanner_t *s) {
 	uint64_t val = strtoull(s->cur, &end, 10);
 	if (end == s->cur) {
 		s->cur = save;
-		return false;
+		return scan_error(s, "is not number");
+		// TODO: standardize error messages
 	}
 	if (errno == ERANGE) {
-		scanner_error(s, "integer does not fit in u64 value");
-		return false;
+		return scan_error(s, "integer does not fit in u64 value");
 	}
 	s->cur = end;
-	s->value.u64 = val;
-	return true;
+	return scan_value(.u64=val);
 }
 
-bool scan_u32(scanner_t *s) {
-	if (!scan_u64(s)) {
-		return false;
+scan_result_t scan_u32(scanner_t *s) {
+	scan_result_t result = scan_u64(s);
+	if (!result.ok) {
+		return result;
 	}
-	uint32_t val = (uint32_t)s->value.u64;
+	uint32_t val = (uint32_t)result.value.u64;
 	uint64_t back = (uint64_t)val;
-	if (back != s->value.u64) {
-		scanner_error(s, "int does not fit in u32 value");
-		return false;
+	if (back != result.value.u64) {
+		return scan_error(s, "int does not fit in u32 value");
 	}
-	s->value.u32 = val;
-	return true;
+	return scan_value(val);
 }
 
-bool scan_u16(scanner_t *s) {
-	if (!scan_u64(s)) {
-		return false;
+scan_result_t scan_u16(scanner_t *s) {
+	scan_result_t result = scan_u64(s);
+	if (!result.ok) {
+		return result;
 	}
-	uint16_t val = (uint16_t)s->value.u64;
+	uint16_t val = (uint16_t)result.value.u64;
 	uint64_t back = (uint64_t)val;
-	if (back != s->value.u64) {
-		scanner_error(s, "int does not fit in u16 value");
-		return false;
+	if (back != result.value.u64) {
+		return scan_error(s, "int does not fit in u16 value");
 	}
-	s->value.u16 = val;
-	return true;
+	return scan_value(val);
 }
 
-bool scan_u8(scanner_t *s) {
-	if (!scan_u64(s)) {
-		return false;
+scan_result_t scan_u8(scanner_t *s) {
+	scan_result_t result = scan_u64(s);
+	if (!result.ok) {
+		return result;
 	}
-	uint8_t val = (uint8_t)s->value.u64;
+	uint8_t val = (uint8_t)result.value.u64;
 	uint64_t back = (uint64_t)val;
-	if (back != s->value.u64) {
-		scanner_error(s, "int does not fit in u8 value");
-		return false;
+	if (back != result.value.u64) {
+		return scan_error(s, "int does not fit in u8 value");
 	}
-	s->value.u8 = val;
-	return true;
+	return scan_value(val);
 }
 
-bool scan_f64(scanner_t *s) {
-	const char *save = s->cur;
+scan_result_t scan_f64(scanner_t *s) {
+	char const *save = s->cur;
 	char *end;
 	errno = 0;
 	double val = strtod(s->cur, &end);
 	if (end == s->cur) {
 		s->cur = save;
-		return false;
+		return scan_error(s, "not a f64");
 	}
 	if (errno == ERANGE) {
-		scanner_error(s, "float does not fit in f64 value");
-		return false;
+		return scan_error(s, "float does not fit in f64 value");
 	}
 	s->cur = end;
-	s->value.f64 = val;
-	return true;
+	return scan_value(.f64=val);
 }
 
-bool scan_f32(scanner_t *s) {
-	if (!scan_f64(s)) {
-		return false;
+scan_result_t scan_f32(scanner_t *s) {
+	scan_result_t result = scan_f64(s);
+	if (!result.ok) {
+		return result;
 	}
-	float val = (float)s->value.f64;
+	float val = (float)result.value.f64;
 	double back = (double)val;
-	if (back != s->value.f64) {
-		scanner_error(s, "float does not fit in f32 value");
-		return false;
+	if (back != result.value.f64) {
+		return scan_error(s, "float does not fit in f32 value");
 	}
-	s->value.f32 = val;
-	return true;
+	return scan_value(.f32=val);
 }
 
-bool scan_identifier(scanner_t *s) {
+scan_result_t scan_identifier(scanner_t *s) {
 	if (!isalpha((unsigned char)*s->cur) && *s->cur != '_') {
-		return false;
+		return scan_error(s, "not an identifier");
 	}
-	const char *start = s->cur++;
+	char const *start = s->cur++;
 	while (isalnum((unsigned char)*s->cur) || *s->cur == '_') {
 		s->cur++;
 	}
@@ -279,21 +263,21 @@ bool scan_identifier(scanner_t *s) {
 	char *buf = allocator_alloc(s->allocator, len + 1);
 	memcpy(buf, start, len);
 	buf[len] = '\0';
-	s->value.identifier = buf;
-	return true;
+	return scan_value(.identifier=buf);
 }
 
 
-bool scan_string_literal(scanner_t *s) {
-	const char *save = s->cur;
+scan_result_t scan_string_literal(scanner_t *s) {
+	char const *save = s->cur;
 	if (*s->cur != '"')
-		return false;
+		return scan_error(s, "not a string");
 	s->cur++; // skip opening quote
 	char *buf = allocator_alloc(s->allocator, 256);
 	size_t cap = 256;
 	size_t len = 0;
 	while (*s->cur && *s->cur != '"') {
 		char c = *s->cur++;
+		scan_result_t ret;
 		if (c == '\\') {
 			char esc = *s->cur++;
 			switch (esc) {
@@ -304,9 +288,9 @@ bool scan_string_literal(scanner_t *s) {
 				case '"': c = '"'; break;
 				case '0': c = '\0'; break;
 				default:
-					scanner_error(s, "invalid escape sequence");
+					ret = scan_error(s, "invalid escape sequence");
 					s->cur = save;
-					return false;
+					return ret;
 			}
 		}
 		if (len + 2 >= cap) {
@@ -316,25 +300,30 @@ bool scan_string_literal(scanner_t *s) {
 		buf[len++] = c;
 	}
 	if (*s->cur != '"') {
-		scanner_error(s, "unterminated string literal");
+		scan_result_t ret = scan_error(s, "unterminated string literal");
 		s->cur = save;
-		return false;
+		return ret;
 	}
 	s->cur++; // skip closing quote
 	buf[len] = '\0';
-	s->value.string_literal = buf;
-	return true;
+	return scan_value(.string_literal=buf);
 }
 
-bool scanner_print_errors(scanner_t *s, FILE *fp) {
-	for (error_node_t *node = s->errors; node != NULL; node = node->next) {
-		fprintf(fp, "%s\n", node->msg);
+bool scanner_print_errors_func(FILE *fp, scan_result_t const *results, int results_len) {
+	bool did_print_errors = false;
+	for (int i = 0; i < results_len; i++) {
+		scan_result_t res = results[i];
+		if (!res.ok) {
+			scan_error_t err = res.error;
+			fprintf(fp, "%s:%d:%d: %s", err.buffer_name, err.line, err.column, err.message);
+			did_print_errors = true;
+		}
 	}
-	return s->errors != NULL;
+	return did_print_errors;
 }
 
 bool looks_like_float(scanner_t *s) {
-	const char *cur = s->cur;
+	char const *cur = s->cur;
 	if (
 		((*cur) == '+') ||
 		((*cur) == '-')
@@ -358,7 +347,7 @@ bool looks_like_float(scanner_t *s) {
 }
 
 bool looks_like_int(scanner_t *s) {
-	const char *cur = s->cur;
+	char const *cur = s->cur;
 	if (*cur == '+' || *cur == '-') {
 		cur++;
 	}

string_builder.c

@@ -12,7 +12,7 @@ string_builder_t sb_create(allocator_t builder_allocator) {
 	};
 }
 
-void sb_add_string(string_builder_t *this, const char *string) {
+void sb_add_string(string_builder_t *this, char const *string) {
 	string_builder_node_t *node = allocator_alloc(this->allocator, sizeof(string_builder_node_t));
 	node->length = strlen(string);
 	node->string = string;
@@ -78,7 +78,7 @@ void sb_add_u8(string_builder_t *this, uint8_t u8) {
 	sb_add_string(this, buffer);
 }
 
-void sb_add_substring(string_builder_t *this, const char *string, size_t substring_length) {
+void sb_add_substring(string_builder_t *this, char const *string, size_t substring_length) {
 	size_t string_length = strlen(string);
 	size_t min_length = string_length < substring_length
 		? string_length
@@ -91,7 +91,7 @@ void sb_add_substring(string_builder_t *this, const char *string, size_t substri
 	sb_add_string(this, buffer);
 }
 
-const char *sb_build_and_clear(
+char const *sb_build_and_clear(
 	string_builder_t *this,
 	allocator_t output_allocator
 ) {
@@ -111,7 +111,7 @@ const char *sb_build_and_clear(
 		node != NULL;
 		node = node->next
 	) {
-		for (const char *c = node->string; (*c) != '\0'; c++) {
+		for (char const *c = node->string; (*c) != '\0'; c++) {
 			buffer[i] = *c;
 			i++;
 		}

test_dynamic_array.c

@@ -145,7 +145,7 @@ Test(dynamic_arrays, contains_cmp_empty) {
 // Test using arr_contains_cmp for a simple key-value map
 typedef struct {
 	int key;
-	const char *value;
+	char const *value;
 } kv_pair_t;
 
 static bool kv_eq_by_key(const void *a, const void *b) {

test_scanner.c

@@ -1,9 +1,10 @@
 #include <assert.h>
 #include <criterion/criterion.h>
+#include <stdio.h>
 #include "cig.h"
 
 Test(scanner, looks_like_float) {
-	const char *buffer =
+	char const *buffer =
 		"1.0 true\n"
 		"12.34 true\n"
 		"0.5 true\n"
@@ -22,7 +23,7 @@ Test(scanner, looks_like_float) {
 		scanner_t scanner = make_scanner("test", buffer, allocator);
 		while (!scan_eof(&scanner)) {
 			bool does_look_like_float = looks_like_float(&scanner);
-			bool does_look_like_int = looks_like_float(&scanner);
+			bool does_look_like_int = looks_like_int(&scanner);
 			while (*scanner.cur++ != ' ');
 			bool expect;
 			if (scan_literal(&scanner, "true")) {
@@ -41,3 +42,34 @@ Test(scanner, looks_like_float) {
 	}
 
 }
+
+Test(scanner, print_errors) {
+	char const *buffer =
+		"1.0 true\n"
+		"12.34 true\n"
+		"0.5 true\n"
+		"9.99 true\n"
+		"+1.2 true\n"
+		"-3.14 true\n"
+		"1 false\n"
+		"42 false\n"
+		"+7 false\n"
+		"1. false\n"
+		".5 false\n"
+		"+. false\n"
+		"abc false\n"
+		"+x false\n";
+	FILE *f = tmpfile();
+	with_borrow(allocator) {
+		scanner_t scanner = make_scanner(__FILE__, buffer, allocator);
+		scan_result_t res1 = scan_error(&scanner, "ignore this\n");
+		scan_result_t res2 = scan_error(&scanner, "and this\n");
+		scan_result_t res3 = scan_value(.i64=10);
+		scan_result_t res4 = scan_value(.string_literal="foobar");
+
+		cr_assert(scanner_print_errors(f, res1, res2));
+		cr_assert(scanner_print_errors(f, res1, res2, res3, res4));
+		cr_assert(!scanner_print_errors(f, res3, res4));
+	}
+
+}