G

meta: Remove unnecessary string casting

Diffstat

15 files changed, 148 insertions, 100 deletions

diff --git a/src/compile.c b/src/compile.c
index 3bf7f33..9321549 100644
--- a/src/compile.c
+++ b/src/compile.c
@@ -19,7 +19,7 @@
 
 bool lflag = false, pflag = false;
 
-void compile(u8 *src, UINT len) {
+void compile(char *src, UINT len) {
 	lex l = lex_init(src, len);
 	if (lflag) { lex_debug(&l); goto ret; }
 
@@ -33,7 +33,7 @@ ret:;
 }
 
 void compile_file(const char *file) {
-	FILE *fi; u8 *fb; size_t fl;
+	FILE *fi; char *fb; size_t fl;
 
 	if (!(fi = fopen(file, "r"))) { error(1, "%s: %s", file, serr()); }
 	fseek(fi, 0, SEEK_END); fl = ftell(fi); rewind(fi);
diff --git a/src/compile.h b/src/compile.h
index 0186009..c5d5361 100644
--- a/src/compile.h
+++ b/src/compile.h
@@ -12,7 +12,7 @@
 
 extern bool lflag, pflag;
 
-extern void compile(u8 *src, UINT len);
+extern void compile(char *src, UINT len);
 extern void compile_file(const char *file);
 
 #endif // G_COMPILE_H_DSDZQ0ZM
diff --git a/src/lex.c b/src/lex.c
index 1b0db6c..0f6a644 100644
--- a/src/lex.c
+++ b/src/lex.c
@@ -37,20 +37,20 @@ char *tok_ks[] = {
 };
 
 /* Initialise a lexer. */
-lex lex_init(u8 *src, UINT len) {
+lex lex_init(char *src, UINT len) {
 	lex l = { src, src, src + len, 0, 0, 0 }; lex_next(&l); return l;
 }
 
-#define P  (l->p)    // Pointer to the Current Character
-#define Q  (l->q)    // Pointer to EOF
-#define C  (l->p[0]) // Current Character
-#define D  (l->p[1]) // Next Character
-#define LN (l->ln)   // Line Index
-#define CL (l->cl)   // Column Index
-#define T  (l->t)    // Current Token
+#define P  (l->p)    /* Pointer to the Current Character */
+#define Q  (l->q)    /* Pointer to EOF */
+#define C  (l->p[0]) /* Current Character */
+#define D  (l->p[1]) /* Next Character */
+#define LN (l->ln)   /* Line Index */
+#define CL (l->cl)   /* Column Index */
+#define T  (l->t)    /* Current Token */
 
-#define ISIDCHA(c) (isalpha(c) || c == '_')
-#define ISIDCHB(c) (isalpha(c) || isdigit(c) || c == '_')
+/* Return the current token. */
+tok lex_peek(lex *l) { return T; }
 
 /* Lex the next token, and return the current one. */
 tok lex_next(lex *l) {
@@ -88,25 +88,25 @@ skip:;
 	T.ln = LN; T.cl = CL;
 
 	/* Handle identifiers and keywords */
-	if (ISIDCHA(C)) {
-		u8 *s = P; UINT sl;
+	if (isalpha(C) || C == '_') {
+		char *s = P; UINT sl;
 
-		for (P += 1; ISIDCHB(C); P += 1);
+		for (P += 1; isalpha(C) || isdigit(C) || C == '_'; P += 1);
 		sl = P - s; CL += sl;
 
-		T.v_str = (u8 *)strndup((char *)s, sl);
+		T.v_str = strndup(s, sl);
 		T.h = fnv1a64(s, sl); kwd *k = kwd_find(T.h);
 		if (k) { T.k = k->k; } else { T.k = LK_ID; }
 	}
 
 	/* Handle number literals */
 	else if (isdigit(C)) {
-		u8 *s = P; UINT sl;
+		char *s = P; UINT sl;
 
 		for (P += 1; isalnum(C); P += 1);
 		sl = P - s; CL += sl;
 
-		T.v_str = (u8 *)strndup((char *)s, sl);
+		T.v_str = strndup(s, sl);
 		T.k = LK_INT;
 	}
 
@@ -192,11 +192,6 @@ skip:;
 	return t;
 }
 
-/* Return the next token. */
-tok lex_peek(lex *l) {
-	return T;
-}
-
 /* Lex the next token if the current is of a specific type. */
 tok lex_kind(lex *l, tok_k k) {
 	if (T.k != k) { error(
diff --git a/src/lex.h b/src/lex.h
index b6f0fc8..7e050a9 100644
--- a/src/lex.h
+++ b/src/lex.h
@@ -29,18 +29,18 @@ typedef enum {
 
 typedef struct {
 	tok_k k; UINT ln, cl; u64 h;
-	union { u64 v_u64; s64 v_s64; f64 v_f64; u8 *v_str; };
+	union { u64 v_u64; s64 v_s64; f64 v_f64; char *v_str; };
 } tok;
 
 typedef struct {
-	u8 *s, *p, *q; UINT ln, cl; tok t;
+	char *s, *p, *q; UINT ln, cl; tok t;
 } lex;
 
 extern char *tok_ks[];
 
-extern lex lex_init(u8 *src, UINT len);
-extern tok lex_next(lex *l);
+extern lex lex_init(char *src, UINT len);
 extern tok lex_peek(lex *l);
+extern tok lex_next(lex *l);
 extern tok lex_kind(lex *l, tok_k k);
 
 extern void lex_debug(lex *l);
diff --git a/src/llvm/gen.c b/src/llvm/gen.c
index 735a5da..6cecb9d 100644
--- a/src/llvm/gen.c
+++ b/src/llvm/gen.c
@@ -105,7 +105,7 @@ static LLVMValueRef gen_compound(ast a) {
 /* Generate IR for a procedure. */
 static LLVMValueRef gen_proc(ast a) {
 	LLVMTypeRef ft = LLVMFunctionType(llvm_type(a->t), NULL, 0, 0);
-	LLVMValueRef f = LLVMAddFunction(llvm_module, (char *)a->s, ft);
+	LLVMValueRef f = LLVMAddFunction(llvm_module, a->s, ft);
 
 	LLVMBasicBlockRef bb = LLVMAppendBasicBlock(f, "entry");
 	LLVMPositionBuilderAtEnd(llvm_builder, bb);
diff --git a/src/main.c b/src/main.c
index d9e8507..f93599b 100644
--- a/src/main.c
+++ b/src/main.c
@@ -17,8 +17,10 @@
 #include <stdlib.h>
 
 static struct lop lops[] = {
-	{ "help",    ARG_NUL, 256 },
-	{ "version", ARG_NUL, 257 },
+	{ "help",        ARG_NUL, 256 },
+	{ "version",     ARG_NUL, 257 },
+	{ "debug-lex",   ARG_NUL, 258 },
+	{ "debug-parse", ARG_NUL, 259 },
 	{ NULL, 0, 0 }
 };
 
@@ -26,12 +28,12 @@ static void hlp(void);
 static void ver(void);
 
 int main(int ac, char *av[]) { (void)(ac); A0 = av[0];
-	struct opt opt = OPTGET_INIT; opt.str = "LP"; opt.lops = lops;
+	struct opt opt = OPTGET_INIT; opt.str = ""; opt.lops = lops;
 	for (int o; (o = optget(&opt, av, 1)) != -1;) switch (o) {
-	case 'L': { lflag = true; } break;
-	case 'P': { pflag = true; } break;
-	case 256: { hlp(); return 0; }
-	case 257: { ver(); return 0; }
+	case 256: { hlp(); } return 0;
+	case 257: { ver(); } return 0;
+	case 258: { lflag = true; } break;
+	case 259: { pflag = true; } break;
 	default:  { return 1; }
 	}
 
@@ -42,18 +44,18 @@ int main(int ac, char *av[]) { (void)(ac); A0 = av[0];
 }
 
 static void hlp(void) {
-	puts("GC - G Compiler\n");
-	puts("Usage: gc [-LP]\n");
+	puts("G - G Compiler\n");
+	puts("Usage: g\n");
 	puts("Options:");
-	puts("  -L         Print lexer debug output and exit");
-	puts("  -P         Print parser debug output and exit");
-	puts("  --help     Display help information");
-	puts("  --version  Display version information");
+	puts("  --help        Display help information");
+	puts("  --version     Display version information");
+	puts("  --debug-lex   Print lexer debug output and exit");
+	puts("  --debug-parse Print parser debug output and exit");
 	return;
 }
 
 static void ver(void) {
-	puts("GC, version " PROJECT_VERSION);
+	puts("G, version " PROJECT_VERSION);
 	puts("Copyright (C) 2021, Jakob Wakeling");
 	puts("All rights reserved.");
 	puts("All rights reserved.");
diff --git a/src/map.c b/src/map.c
index a3c64dc..fa2e39e 100644
--- a/src/map.c
+++ b/src/map.c
@@ -35,28 +35,28 @@ void map_free(map *m) {
 }
 
 /* Insert an element into a map. */
-void map_insert(map *m, u8 *k, sym v) {
+void map_insert(map *m, char *k, sym v) {
 	if ((f64)m->al / m->ac >= 0.75) { /* TODO */ warn("map_insert growth"); }
 
-	u64 i = fnv1a64(k, strlen((char *)k)) % m->ac;
+	u64 i = fnv1a64(k, strlen(k)) % m->ac;
 
 	register ent *e = calloc(1, sizeof (*e)); /* TODO check memory allocation */
-	e->k = (u8 *)strdup((char *)k); e->v = v; e->n = m->a[i]; m->a[i] = e;
+	e->k = strdup(k); e->v = v; e->n = m->a[i]; m->a[i] = e;
 }
 
 /* Lookup an element in a map. */
-sym *map_lookup(map *m, u8 *k) {
-	u64 i = fnv1a64(k, strlen((char *)k)) % m->ac;
+sym *map_lookup(map *m, char *k) {
+	u64 i = fnv1a64(k, strlen(k)) % m->ac;
 
 	for (register ent *e = m->a[i]; e; e = e->n) {
-		if (!strcmp((char *)k, (char *)e->k)) { return &e->v; }
+		if (!strcmp(k, e->k)) { return &e->v; }
 	}
 
 	return NULL;
 }
 
 /* Pop an element from a map. */
-void map_pop(map *m, u8 *k) {
-	u64 i = fnv1a64(k, strlen((char *)k)) % m->ac;
+void map_pop(map *m, char *k) {
+	u64 i = fnv1a64(k, strlen(k)) % m->ac;
 	m->a[i] = m->a[i]->n; /* TODO deallocate memory */
 }
diff --git a/src/map.h b/src/map.h
index 99f5c23..1cdbe77 100644
--- a/src/map.h
+++ b/src/map.h
@@ -15,14 +15,14 @@ typedef enum { SK_VOID, } sym_k; /* Symbol Kind */
 typedef enum { SF_VOID = BIT(0), } sym_f; /* Symbol Flag */
 
 typedef struct sym { sym_k k; sym_f f; type t; } sym;
-typedef struct ent { u8 *k; sym v; struct ent *n, *c; } ent;
+typedef struct ent { char *k; sym v; struct ent *n, *c; } ent;
 typedef struct { ent **a, *c; UINT al, ac; } map;
 
 extern void map_init(map *m);
 extern void map_free(map *m);
 
-extern void map_insert(map *m, u8 *k, sym s);
-extern sym *map_lookup(map *m, u8 *k);
-extern void map_pop(map *m, u8 *k);
+extern void map_insert(map *m, char *k, sym s);
+extern sym *map_lookup(map *m, char *k);
+extern void map_pop(map *m, char *k);
 
 #endif // G_MAP_H_ISL5XLWM
diff --git a/src/parse.h b/src/parse.h
index be4ea23..dd182b4 100644
--- a/src/parse.h
+++ b/src/parse.h
@@ -24,7 +24,7 @@ typedef struct ast_s *ast;
 
 struct ast_s {
 	ast_k k; UINT ln, cl;
-	type *t; val v; u8 *s;
+	type *t; val v; char *s;
 	ast c, lc, rc; stack *cs;
 
 	union {};
diff --git a/src/type.c b/src/type.c
index 18c6225..c15934b 100644
--- a/src/type.c
+++ b/src/type.c
@@ -10,71 +10,71 @@
 #include <stdlib.h>
 
 static type types[] = {
-	{ TK_VOID, 0,       0, (u8 *)"void" },
-	{ TK_PTR,  TF_PTR, -1, (u8 *)"ptr"  },
-	{ TK_TYPE, 0,      -1, (u8 *)"type" },
-	{ TK_ANY,  0,      -1, (u8 *)"any"  },
+	{ TK_VOID, 0,       0, "void" },
+	{ TK_PTR,  TF_PTR, -1, "ptr"  },
+	{ TK_TYPE, 0,      -1, "type" },
+	{ TK_ANY,  0,      -1, "any"  },
 
-	{ TK_BOOL, TF_BOOL, 1, (u8 *)"bool" },
-	{ TK_B8,   TF_BOOL, 1, (u8 *)"b8"   },
-	{ TK_B16,  TF_BOOL, 2, (u8 *)"b16"  },
-	{ TK_B32,  TF_BOOL, 4, (u8 *)"b32"  },
-	{ TK_B64,  TF_BOOL, 8, (u8 *)"b64"  },
+	{ TK_BOOL, TF_BOOL, 1, "bool" },
+	{ TK_B8,   TF_BOOL, 1, "b8"   },
+	{ TK_B16,  TF_BOOL, 2, "b16"  },
+	{ TK_B32,  TF_BOOL, 4, "b32"  },
+	{ TK_B64,  TF_BOOL, 8, "b64"  },
 
-	{ TK_UINT, TF_INT, -1, (u8 *)"unt"  },
-	{ TK_U8,   TF_INT,  1, (u8 *)"u8"   },
-	{ TK_U16,  TF_INT,  2, (u8 *)"u16"  },
-	{ TK_U32,  TF_INT,  4, (u8 *)"u32"  },
-	{ TK_U64,  TF_INT,  8, (u8 *)"u64"  },
-	{ TK_U128, TF_INT, 16, (u8 *)"u128" },
+	{ TK_UINT, TF_INT, -1, "unt"  },
+	{ TK_U8,   TF_INT,  1, "u8"   },
+	{ TK_U16,  TF_INT,  2, "u16"  },
+	{ TK_U32,  TF_INT,  4, "u32"  },
+	{ TK_U64,  TF_INT,  8, "u64"  },
+	{ TK_U128, TF_INT, 16, "u128" },
 
-	{ TK_SINT, TF_INT | TF_SIGN, -1, (u8 *)"int"  },
-	{ TK_S8,   TF_INT | TF_SIGN,  1, (u8 *)"i8"   },
-	{ TK_S16,  TF_INT | TF_SIGN,  2, (u8 *)"i16"  },
-	{ TK_S32,  TF_INT | TF_SIGN,  4, (u8 *)"i32"  },
-	{ TK_S64,  TF_INT | TF_SIGN,  8, (u8 *)"i64"  },
-	{ TK_S128, TF_INT | TF_SIGN, 16, (u8 *)"i128" },
+	{ TK_SINT, TF_INT | TF_SIGN, -1, "int"  },
+	{ TK_S8,   TF_INT | TF_SIGN,  1, "i8"   },
+	{ TK_S16,  TF_INT | TF_SIGN,  2, "i16"  },
+	{ TK_S32,  TF_INT | TF_SIGN,  4, "i32"  },
+	{ TK_S64,  TF_INT | TF_SIGN,  8, "i64"  },
+	{ TK_S128, TF_INT | TF_SIGN, 16, "i128" },
 
-	{ TK_F16,  TF_FLT | TF_SIGN,  2, (u8 *)"f16"  },
-	{ TK_F32,  TF_FLT | TF_SIGN,  4, (u8 *)"f32"  },
-	{ TK_F64,  TF_FLT | TF_SIGN,  8, (u8 *)"f64"  },
-	{ TK_F128, TF_FLT | TF_SIGN, 16, (u8 *)"f128" },
+	{ TK_F16,  TF_FLT | TF_SIGN,  2, "f16"  },
+	{ TK_F32,  TF_FLT | TF_SIGN,  4, "f32"  },
+	{ TK_F64,  TF_FLT | TF_SIGN,  8, "f64"  },
+	{ TK_F128, TF_FLT | TF_SIGN, 16, "f128" },
 
-	{ TK_C32,  TF_FLT | TF_SIGN,  4, (u8 *)"c32"  },
-	{ TK_C64,  TF_FLT | TF_SIGN,  8, (u8 *)"c64"  },
-	{ TK_C128, TF_FLT | TF_SIGN, 16, (u8 *)"c128" },
-	{ TK_C256, TF_FLT | TF_SIGN, 32, (u8 *)"c256" },
+	{ TK_C32,  TF_FLT | TF_SIGN,  4, "c32"  },
+	{ TK_C64,  TF_FLT | TF_SIGN,  8, "c64"  },
+	{ TK_C128, TF_FLT | TF_SIGN, 16, "c128" },
+	{ TK_C256, TF_FLT | TF_SIGN, 32, "c256" },
 
-	{ TK_I16LE,  TF_INT | TF_SIGN | TF_LE,  2, (u8 *)"i16le"  },
-	{ TK_I32LE,  TF_INT | TF_SIGN | TF_LE,  4, (u8 *)"i32le"  },
-	{ TK_I64LE,  TF_INT | TF_SIGN | TF_LE,  8, (u8 *)"i64le"  },
-	{ TK_I128LE, TF_INT | TF_SIGN | TF_LE, 16, (u8 *)"i128le" },
-	{ TK_I16BE,  TF_INT | TF_SIGN | TF_BE,  2, (u8 *)"i16be"  },
-	{ TK_I32BE,  TF_INT | TF_SIGN | TF_BE,  4, (u8 *)"i32be"  },
-	{ TK_I64BE,  TF_INT | TF_SIGN | TF_BE,  8, (u8 *)"i64be"  },
-	{ TK_I128BE, TF_INT | TF_SIGN | TF_BE, 16, (u8 *)"i128be" },
+	{ TK_I16LE,  TF_INT | TF_SIGN | TF_LE,  2, "i16le"  },
+	{ TK_I32LE,  TF_INT | TF_SIGN | TF_LE,  4, "i32le"  },
+	{ TK_I64LE,  TF_INT | TF_SIGN | TF_LE,  8, "i64le"  },
+	{ TK_I128LE, TF_INT | TF_SIGN | TF_LE, 16, "i128le" },
+	{ TK_I16BE,  TF_INT | TF_SIGN | TF_BE,  2, "i16be"  },
+	{ TK_I32BE,  TF_INT | TF_SIGN | TF_BE,  4, "i32be"  },
+	{ TK_I64BE,  TF_INT | TF_SIGN | TF_BE,  8, "i64be"  },
+	{ TK_I128BE, TF_INT | TF_SIGN | TF_BE, 16, "i128be" },
 
-	{ TK_U16LE,  TF_INT | TF_LE,  2, (u8 *)"u16le"  },
-	{ TK_U32LE,  TF_INT | TF_LE,  4, (u8 *)"u32le"  },
-	{ TK_U64LE,  TF_INT | TF_LE,  8, (u8 *)"u64le"  },
-	{ TK_U128LE, TF_INT | TF_LE, 16, (u8 *)"u128le" },
-	{ TK_U16BE,  TF_INT | TF_BE,  2, (u8 *)"u16be"  },
-	{ TK_U32BE,  TF_INT | TF_BE,  4, (u8 *)"u32be"  },
-	{ TK_U64BE,  TF_INT | TF_BE,  8, (u8 *)"u64be"  },
-	{ TK_U128BE, TF_INT | TF_BE, 16, (u8 *)"u128be" },
+	{ TK_U16LE,  TF_INT | TF_LE,  2, "u16le"  },
+	{ TK_U32LE,  TF_INT | TF_LE,  4, "u32le"  },
+	{ TK_U64LE,  TF_INT | TF_LE,  8, "u64le"  },
+	{ TK_U128LE, TF_INT | TF_LE, 16, "u128le" },
+	{ TK_U16BE,  TF_INT | TF_BE,  2, "u16be"  },
+	{ TK_U32BE,  TF_INT | TF_BE,  4, "u32be"  },
+	{ TK_U64BE,  TF_INT | TF_BE,  8, "u64be"  },
+	{ TK_U128BE, TF_INT | TF_BE, 16, "u128be" },
 
-	{ TK_F16LE,  TF_FLT | TF_SIGN | TF_LE,  2, (u8 *)"f16le"  },
-	{ TK_F32LE,  TF_FLT | TF_SIGN | TF_LE,  4, (u8 *)"f32le"  },
-	{ TK_F64LE,  TF_FLT | TF_SIGN | TF_LE,  8, (u8 *)"f64le"  },
-	{ TK_F128LE, TF_FLT | TF_SIGN | TF_LE, 16, (u8 *)"f128le" },
-	{ TK_F16BE,  TF_FLT | TF_SIGN | TF_BE,  2, (u8 *)"f16be"  },
-	{ TK_F32BE,  TF_FLT | TF_SIGN | TF_BE,  4, (u8 *)"f32be"  },
-	{ TK_F64BE,  TF_FLT | TF_SIGN | TF_BE,  8, (u8 *)"f64be"  },
-	{ TK_F128BE, TF_FLT | TF_SIGN | TF_BE, 16, (u8 *)"f128be" },
+	{ TK_F16LE,  TF_FLT | TF_SIGN | TF_LE,  2, "f16le"  },
+	{ TK_F32LE,  TF_FLT | TF_SIGN | TF_LE,  4, "f32le"  },
+	{ TK_F64LE,  TF_FLT | TF_SIGN | TF_LE,  8, "f64le"  },
+	{ TK_F128LE, TF_FLT | TF_SIGN | TF_LE, 16, "f128le" },
+	{ TK_F16BE,  TF_FLT | TF_SIGN | TF_BE,  2, "f16be"  },
+	{ TK_F32BE,  TF_FLT | TF_SIGN | TF_BE,  4, "f32be"  },
+	{ TK_F64BE,  TF_FLT | TF_SIGN | TF_BE,  8, "f64be"  },
+	{ TK_F128BE, TF_FLT | TF_SIGN | TF_BE, 16, "f128be" },
 
-	{ TK_CHAR, TF_INT | TF_CHAR,  1, (u8 *)"char" },
-	{ TK_RUNE, TF_INT | TF_CHAR,  4, (u8 *)"rune" },
-	{ TK_STR,  TF_STR,           -1, (u8 *)"str"  },
+	{ TK_CHAR, TF_INT | TF_CHAR,  1, "char" },
+	{ TK_RUNE, TF_INT | TF_CHAR,  4, "rune" },
+	{ TK_STR,  TF_STR,           -1, "str"  },
 };
 
 type *t_void = &types[TK_VOID]; type *t_ptr  = &types[TK_PTR];
diff --git a/src/type.h b/src/type.h
index 729075f..a15f8dd 100644
--- a/src/type.h
+++ b/src/type.h
@@ -47,7 +47,7 @@ typedef enum {
 
 typedef struct type {
 	type_k k; type_f f; sint l;
-	u8 *name; struct type *base;
+	char *name; struct type *base;
 } type;
 
 extern type *t_void, *t_ptr, *t_type, *t_any;
diff --git a/src/util/fnv.c b/src/util/fnv.c
index 3221870..0a4cb73 100644
--- a/src/util/fnv.c
+++ b/src/util/fnv.c
@@ -1,4 +1,4 @@
-// util/fnv.c, version 1.0.0
+// util/fnv.c, version 1.0.1
 // FNV hash source file from libutil
 // Copyright (C) 2021, Jakob Wakeling
 // All rights reserved.
@@ -6,33 +6,33 @@
 

 #include "fnv.h"
+#include "util.h"
 
-#include <stddef.h>
-#include <stdint.h>
-
-static const uint32_t FNV_PRIME_32 = 0x01000193;
-static const uint32_t FNV_BASIS_32 = 0x811C9DC5;
-static const uint64_t FNV_PRIME_64 = 0x00000100000001B3;
-static const uint64_t FNV_BASIS_64 = 0xCBF29CE484222325;
+static const u32 FNV_PRIME_32 = 0x01000193;
+static const u32 FNV_BASIS_32 = 0x811C9DC5;
+static const u64 FNV_PRIME_64 = 0x00000100000001B3;
+static const u64 FNV_BASIS_64 = 0xCBF29CE484222325;
 
 /* Compute the FNV1a-32 hash of some data. */
-uint32_t fnv1a32(uint8_t *dat, size_t len) {
-	register uint32_t fnv = FNV_BASIS_32;
-	for (; len; --len, ++dat) { fnv ^= *dat; fnv *= FNV_PRIME_32; } return fnv;
+u32 fnv1a32(char *dat, UINT len) {
+	register u32 fnv = FNV_BASIS_32;
+	for (; len; len -= 1, dat += 1) { fnv ^= *dat; fnv *= FNV_PRIME_32; }
+	return fnv;
 }
 
 /* Compute the FNV1a-64 hash of some data. */
-uint64_t fnv1a64(uint8_t *dat, size_t len) {
-	register uint64_t fnv = FNV_BASIS_64;
-	for (; len; --len, ++dat) { fnv ^= *dat; fnv *= FNV_PRIME_64; } return fnv;
+u64 fnv1a64(char *dat, UINT len) {
+	register u64 fnv = FNV_BASIS_64;
+	for (; len; len -= 1, dat += 1) { fnv ^= *dat; fnv *= FNV_PRIME_64; }
+	return fnv;
 }
 
-void fnv1a32_init(uint32_t *ctx) { *ctx = FNV_BASIS_32; }
-void fnv1a32_hash(uint32_t *ctx, uint8_t *dat, size_t len) {
-	for (; len; --len, ++dat) { *ctx ^= *dat; *ctx *= FNV_PRIME_32; }
+void fnv1a32_init(u32 *ctx) { *ctx = FNV_BASIS_32; }
+void fnv1a32_hash(u32 *ctx, char *dat, UINT len) {
+	for (; len; len -= 1, dat += 1) { *ctx ^= *dat; *ctx *= FNV_PRIME_32; }
 }
 
-void fnv1a64_init(uint64_t *ctx) { *ctx = FNV_BASIS_64; }
-void fnv1a64_hash(uint64_t *ctx, uint8_t *dat, size_t len) {
-	for (; len; --len, ++dat) { *ctx ^= *dat; *ctx *= FNV_PRIME_64; }
+void fnv1a64_init(u64 *ctx) { *ctx = FNV_BASIS_64; }
+void fnv1a64_hash(u64 *ctx, char *dat, UINT len) {
+	for (; len; len -= 1, dat += 1) { *ctx ^= *dat; *ctx *= FNV_PRIME_64; }
 }
diff --git a/src/util/fnv.h b/src/util/fnv.h
index fec7e00..eef4ffc 100644
--- a/src/util/fnv.h
+++ b/src/util/fnv.h
@@ -1,4 +1,4 @@
-// util/fnv.h, version 1.0.0
+// util/fnv.h, version 1.0.1
 // FNV hash header file from libutil
 // Copyright (C) 2021, Jakob Wakeling
 // All rights reserved.
@@ -7,16 +7,15 @@
 #ifndef UTIL_FNV_H_O4TYU6Q1
 #define UTIL_FNV_H_O4TYU6Q1
 
-#include <stddef.h>
-#include <stdint.h>
+#include "util.h"
 
-extern uint32_t fnv1a32(uint8_t *dat, size_t len);
-extern uint64_t fnv1a64(uint8_t *dat, size_t len);
+extern u32 fnv1a32(char *dat, UINT len);
+extern u64 fnv1a64(char *dat, UINT len);
 
-extern void fnv1a32_init(uint32_t *ctx);
-extern void fnv1a32_hash(uint32_t *ctx, uint8_t *dat, size_t len);
+extern void fnv1a32_init(u32 *ctx);
+extern void fnv1a32_hash(u32 *ctx, char *dat, UINT len);
 
-extern void fnv1a64_init(uint64_t *ctx);
-extern void fnv1a64_hash(uint64_t *ctx, uint8_t *dat, size_t len);
+extern void fnv1a64_init(u64 *ctx);
+extern void fnv1a64_hash(u64 *ctx, char *dat, UINT len);
 
 #endif // UTIL_FNV_H_O4TYU6Q1
diff --git a/src/value.c b/src/value.c
index 93336fb..89ebfc4 100644
--- a/src/value.c
+++ b/src/value.c
@@ -17,7 +17,7 @@ val val_u64(u64 i)   { return (val){ VK_INT,  .v_int  = i }; }
 val val_f128(f128 f) { return (val){ VK_FLT,  .v_flt  = f }; }
 
 /* Convert an integer string to a val. */
-val val_strint(u8 *s) {
+val val_strint(char *s) {
 	val v = { VK_INT, .v_int = 0 }; u64 c; UINT b = 10;
 
 	if (s[0] == '0') switch (s[1]) {
@@ -40,6 +40,6 @@ val val_strint(u8 *s) {
 }
 
 /* Convert a float string to a val. */
-val val_strflt(u8 *s) {
+val val_strflt(char *s) {
 	return val_null; /* TODO */
 }
diff --git a/src/value.h b/src/value.h
index 580fcd4..97de8b9 100644
--- a/src/value.h
+++ b/src/value.h
@@ -23,7 +23,7 @@ extern val val_bool(bool v);
 extern val val_u64(u64 v);
 extern val val_f128(f128 v);
 
-extern val val_strint(u8 *s);
-extern val val_strflt(u8 *s);
+extern val val_strint(char *s);
+extern val val_strflt(char *s);
 
 #endif // G_VALUE_H_X2RKXBBA