G

lex: Generalise keyword lexing

Diffstat

12 files changed, 172 insertions, 129 deletions

diff --git a/src/cll/cll.h b/src/cll/cll.h
index 83a288f..86642ab 100644
--- a/src/cll/cll.h
+++ b/src/cll/cll.h
@@ -33,8 +33,6 @@ typedef float       f32;
 typedef double      f64;
 typedef long double f128;
 
-typedef char *str;
-
 #define U8_MIN   UINT8_MIN
 #define U8_MAX   UINT8_MAX
 #define U16_MIN  UINT16_MIN
diff --git a/src/g.h b/src/g.h
index f6db769..5f39dde 100644
--- a/src/g.h
+++ b/src/g.h
@@ -15,30 +15,20 @@
 #include "cll/cll.h"
 
 typedef enum {
-	LK_VOID, LK_EOF,
+	LK_NIL, LK_EOF, LK_IDN,
+	LK_INT, LK_FLT, LK_CHR, LK_STR,
 
-	LK_IDN, LK_INT, LK_FLT,
-	LK_CHR, LK_STR,
-	
-	LK_LBRACK, LK_RBRACK,
-	LK_LPAREN, LK_RPAREN,
-	LK_LBRACE, LK_RBRACE,
-	LK_COLON,  LK_SCOLON,
+	LK_LPAREN, LK_RPAREN, LK_LBRACK, LK_RBRACK,
+	LK_LBRACE, LK_RBRACE, LK_COLON,  LK_SCOLON,
 	LK_PERIOD, LK_COMMA,
 
 	LK_RARROW,
 
-	LK_ADD, LK_SUB, LK_MUL, LK_DIV, LK_MOD,
-	LK_LNOT, LK_BNOT, LK_BAND, LK_BOR, LK_BXOR,
-	LK_SHL, LK_SHR, LK_EQ, LK_NEQ, LK_LT, LK_LTE,
-	LK_GT, LK_GTE, LK_LAND, LK_LOR, LK_TERN, LK_ASSN,
-	LK_ADDEQ, LK_SDDEQ, LK_MULEQ, LK_DIVEQ, LK_MODEQ,
-	LK_ANDEQ, LK_OREQ, LK_XOREQ, LK_SHLEQ, LK_SHREQ,
-	LK_PROC, LK_RETURN, LK_IF, LK_ELSE, LK_FOR,
+	LK_PROC, LK_RETURN,
 } tok_k;
 
 typedef enum {
-	AK_VOID,
+	AK_NIL,
 
 	AK_DECL, AK_ASSN, AK_COMP,
 
@@ -51,20 +41,20 @@ typedef enum {
 	AK_RETURN,
 } ast_k;
 
-typedef struct { UINT fi, fp, ln, cl; } pos;
+typedef struct { UINT ln, cl; } pos;
+typedef struct { tok_k k; pos p; u8 *s; u64 h; } tok;
 
-typedef struct { tok_k k; pos p; char *s; } tok;
-typedef struct { char *s; UINT sp, sl, ln, cl; tok t; } lex;
+typedef struct { u8 *s; UINT sp, sl, ln, cl; tok t; } lex;
 
 typedef struct ast {
-	ast_k k; pos p; type *t; val v; str s;
+	ast_k k; pos p; type *t; val v; u8 *s;
 	struct ast *c, *cl, *cr; stack *cs;
 } ast;
 
 extern char *tok_ks[];
 extern char *ast_ks[];
 
-extern lex lex_init(char *src, UINT len);
+extern lex lex_init(u8 *src, UINT len);
 extern tok lex_next(lex *l);
 extern tok lex_kind(lex *l, tok_k k);
 extern tok lex_peek(lex *l);
diff --git a/src/keyword.c b/src/keyword.c
new file mode 100644
index 0000000..e42526c
--- /dev/null
+++ b/src/keyword.c
@@ -0,0 +1,29 @@
+// keyword.c
+// Keyword source file for G
+// Copyright (C) 2021, Jakob Wakeling
+// All rights reserved.
+
+
+
+#include "keyword.h"
+
+#include "cll/cll.h"
+#include "cll/fnv.h"
+
+#include <string.h>
+
+typedef enum { KK_PROC, KK_RETURN, } kwd_k;
+
+static kwd kwds[] = {
+	{ LK_PROC,   0x85729B0E3537BC61, "proc"   },
+	{ LK_RETURN, 0xC5C7B983377CAD5F, "return" },
+};
+
+kwd *k_proc = &kwds[KK_PROC]; kwd *k_return = &kwds[KK_RETURN];
+
+/* Return pointer to keyword or null if invalid. */
+kwd *kwd_find(u64 hash) {
+	for (UINT i = 0; i < sizeof (kwds) / sizeof (*kwds); ++i) {
+		if (hash == kwds[i].h) { return &kwds[i]; }
+	} return NULL;
+}
diff --git a/src/keyword.h b/src/keyword.h
new file mode 100644
index 0000000..851848f
--- /dev/null
+++ b/src/keyword.h
@@ -0,0 +1,21 @@
+// keyword.h
+// Keyword header file for G
+// Copyright (C) 2021, Jakob Wakeling
+// All rights reserved.
+
+
+
+#ifndef G_KEYWORD_H_UEY4FULO
+#define G_KEYWORD_H_UEY4FULO
+
+#include "g.h"
+
+#include "cll/cll.h"
+
+typedef struct { tok_k k; u64 h; char *name; } kwd;
+
+extern kwd *k_proc, *k_return;
+
+extern kwd *kwd_find(u64 hash);
+
+#endif // G_KEYWORD_H_UEY4FULO
diff --git a/src/lex.c b/src/lex.c
index 9cc9018..b7ad3b4 100644
--- a/src/lex.c
+++ b/src/lex.c
@@ -6,6 +6,7 @@
 

 #include "g.h"
+#include "keyword.h"
 #include "type.h"
 
 #include "cll/error.h"
@@ -25,30 +26,20 @@
 #define ISIDNCB(c) (isalpha(c) || isdigit(c) || c == '_')
 
 char *tok_ks[] = {
-	"LK_VOID", "LK_EOF",
+	"LK_NIL", "LK_EOF", "LK_IDN",
+	"LK_INT", "LK_FLT", "LK_CHR", "LK_STR",
 
-	"LK_IDN", "LK_INT", "LK_FLT",
-	"LK_CHR", "LK_STR",
-	
-	"LK_LBRACK", "LK_RBRACK",
-	"LK_LPAREN", "LK_RPAREN",
-	"LK_LBRACE", "LK_RBRACE",
-	"LK_COLON",  "LK_SCOLON",
+	"LK_LPAREN", "LK_RPAREN", "LK_LBRACK", "LK_RBRACK",
+	"LK_LBRACE", "LK_RBRACE", "LK_COLON",  "LK_SCOLON",
 	"LK_PERIOD", "LK_COMMA",
 
-	"LK_RARROW",
 
-	"LK_ADD", "LK_SUB", "LK_MUL", "LK_DIV", "LK_MOD",
-	"LK_LNOT", "LK_BNOT", "LK_BAND", "LK_BOR", "LK_BXOR",
-	"LK_SHL", "LK_SHR", "LK_EQ", "LK_NEQ", "LK_LT", "LK_LTE",
-	"LK_GT", "LK_GTE", "LK_LAND", "LK_LOR", "LK_TERN", "LK_ASSN",
-	"LK_ADDEQ", "LK_SDDEQ", "LK_MULEQ", "LK_DIVEQ", "LK_MODEQ",
-	"LK_ANDEQ", "LK_OREQ", "LK_XOREQ", "LK_SHLEQ", "LK_SHREQ",
-	"LK_PROC", "LK_RETURN", "LK_IF", "LK_ELSE", "LK_FOR",
+	"LK_RARROW",
+	"LK_PROC", "LK_RETURN",
 };
 
 /* Initialise a lexer. */
-lex lex_init(str src, UINT len) {
+lex lex_init(u8 *src, UINT len) {
 	lex l = { src, 0, len, 0, 0 }; lex_next(&l); return l;
 }
 
@@ -57,7 +48,7 @@ tok lex_next(lex *l) {
 	/* Short circuit if the current token is EOF */
 	if (l->t.k == LK_EOF) { return l->t; }
 
-	tok t = l->t, n; str ss = NULL; UINT sl = 0;
+	tok t = l->t, n; u8 *ss = NULL; UINT sl = 0;
 
 skip:;
 	/* Skip null characters and whitespace */
@@ -76,16 +67,12 @@ skip:;
 	}
 
 	n.p.ln = l->ln; n.p.cl = l->cl; if (l->sp + 1 != l->sl) {
-		if (ISIDNCA(C)) { /* Identifiers */
+		if (ISIDNCA(C)) { /* Identifiers and Keywords */
 			for (ss = &C, ++sl, ++l->sp; ISIDNCB(C); ++sl, ++l->sp);
 
-			// printf("%s[%zu]: %lx\n", ss, sl, hashl(ss, sl));
-			
-			switch (fnv1a64((u8 *)ss, sl)) {
-			case 0x85729B0E3537BC61: { n.k = LK_PROC;   } goto end;
-			case 0xC5C7B983377CAD5F: { n.k = LK_RETURN; } goto end;
-			default: { n.k = LK_IDN; goto end; }
-			}
+			/* Check for a keyword, and store its hash */
+			u64 h = fnv1a64(ss, sl); kwd *k = kwd_find(h); n.h = h;
+			if (k) { n.k = k->k; } else { n.k = LK_IDN; } goto end;
 		}
 		else if (isdigit(C)) { /* Numbers */
 			for (ss = &C, ++sl, ++l->sp; isalnum(C); ++sl, ++l->sp);
@@ -94,30 +81,19 @@ skip:;
 		}
 
 		else switch (C) {
-		case '[': { n.k = LK_LBRACK; } goto esc_1;
-		case ']': { n.k = LK_RBRACK; } goto esc_1;
 		case '(': { n.k = LK_LPAREN; } goto esc_1;
 		case ')': { n.k = LK_RPAREN; } goto esc_1;
+		case '[': { n.k = LK_LBRACK; } goto esc_1;
+		case ']': { n.k = LK_RBRACK; } goto esc_1;
 		case '{': { n.k = LK_LBRACE; } goto esc_1;
 		case '}': { n.k = LK_RBRACE; } goto esc_1;
 		case ':': { n.k = LK_COLON;  } goto esc_1;
 		case ';': { n.k = LK_SCOLON; } goto esc_1;
 		case '.': { n.k = LK_PERIOD; } goto esc_1;
 		case ',': { n.k = LK_COMMA;  } goto esc_1;
-		case '=': { n.k = LK_ASSN;   } goto esc_1;
-		case '+': { n.k = LK_ADD;    } goto esc_1;
 		case '-': switch (D) {
 			case '>': { n.k = LK_RARROW; } goto esc_2;
-			default:  { n.k = LK_SUB;    } goto esc_1;
 		}
-		case '*': { n.k = LK_MUL;    } goto esc_1;
-		case '/': { n.k = LK_DIV;    } goto esc_1;
-		case '%': { n.k = LK_MOD;    } goto esc_1;
-		case '!': { n.k = LK_LNOT;   } goto esc_1;
-		case '~': { n.k = LK_BNOT;   } goto esc_1;
-		case '&': { n.k = LK_BAND;   } goto esc_1;
-		case '|': { n.k = LK_BOR;    } goto esc_1;
-		case '^': { n.k = LK_BXOR;   } goto esc_1;
 		esc_1: { ss = &C; sl += 1; l->sp += 1; } goto end;
 		esc_2: { ss = &C; sl += 2; l->sp += 2; } goto end;
 		esc_3: { ss = &C; sl += 3; l->sp += 3; } goto end;
@@ -126,7 +102,7 @@ skip:;
 	}
 
 end:;
-	n.s = strndup(ss, sl); l->cl += sl;
+	n.s = (u8 *)strndup((char *)ss, sl); l->cl += sl;
 
 ret:;
 	l->t = n; return t;
diff --git a/src/map.c b/src/map.c
index 0130bae..a6b83f6 100644
--- a/src/map.c
+++ b/src/map.c
@@ -14,9 +14,9 @@
 #include <string.h>
 
 /* Initialise a new map entry. */
-static inline ent *ent_init(str k, sym v) {
+static inline ent *ent_init(u8 *k, sym v) {
 	ent *e = calloc(1, sizeof (*e)); if (!e) { return NULL; }
-	e->k = strdup(k); e->v = v; return e;
+	e->k = (u8 *)strdup((char *)k); e->v = v; return e;
 }
 
 /* Grow a map. */
@@ -44,18 +44,23 @@ extern void map_free(map *m) {
 }
 
 /* Get the element associated with a key. */
-extern sym *map_get(map *m, str k) {
-	register ent *e = m->a[fnv1a64((u8 *)k, strlen(k)) % m->ac];
+extern sym *map_get(map *m, u8 *k) {
+	register ent *e = m->a[fnv1a64((u8 *)k, strlen((char *)k)) % m->ac];
 
 	/* Check if the key is present in the bucket */
-	for (; e; e = e->n) { if (!strcmp(k, e->k)) { return &e->v; }} return NULL;
+	for (; e; e = e->n) {
+		if (!strcmp((char *)k, (char *)e->k)) { return &e->v; }
+	}
+	
+	return NULL;
 }
 
 /* Set the element associated with a key. */
-extern void map_set(map *m, str k, sym v) {
+extern void map_set(map *m, u8 *k, sym v) {
 	if ((f64)m->al / m->ac >= 0.75) { map_grow(m); }
 
-	u64 i = fnv1a64((u8 *)k, strlen(k)) % m->ac; register ent *e = m->a[i];
+	u64 i = fnv1a64((u8 *)k, strlen((char *)k)) % m->ac;
+	register ent *e = m->a[i];
 
 	/* Check if the bucket is completely empty */
 	if (!e) {
@@ -64,10 +69,12 @@ extern void map_set(map *m, str k, sym v) {
 	}
 
 	/* Check if the key matches the first entry in the bucket */
-	if (!strcmp(k, e->k)) { e->v = v; return; }
+	if (!strcmp((char *)k, (char *)e->k)) { e->v = v; return; }
 
 	/* Check if the key is already present in the rest of the bucket */
-	for (; e->n; e = e->n) { if (!strcmp(k, e->n->k)) { e->n->v = v; return; }}
+	for (; e->n; e = e->n) {
+		if (!strcmp((char *)k, (char *)e->n->k)) { e->n->v = v; return; }
+	}
 
 	/* Add a new entry at the end of the bucket */
 	e->n = ent_init(k, v); /* TODO check memory allocation */
@@ -75,6 +82,6 @@ extern void map_set(map *m, str k, sym v) {
 }
 
 /* Delete the element associated with a key. */
-extern void map_del(map *m, str k) {
+extern void map_del(map *m, u8 *k) {
 	/* TODO */
 }
diff --git a/src/map.h b/src/map.h
index 477c85f..585ac67 100644
--- a/src/map.h
+++ b/src/map.h
@@ -15,14 +15,14 @@ typedef enum { SK_VOID, } ent_k; /* Entry Kind */
 typedef enum { SF_VOID = BIT(0), } ent_f; /* Entry Flag */
 
 typedef struct sym { ent_k k; ent_f f; type t; } sym;
-typedef struct ent { str k; sym v; struct ent *n, *c; } ent;
+typedef struct ent { u8 *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 sym *map_get(map *m, str k);
-extern void map_put(map *m, str k, sym s);
-extern void map_del(map *m, str k);
+extern sym *map_get(map *m, u8 *k);
+extern void map_put(map *m, u8 *k, sym s);
+extern void map_del(map *m, u8 *k);
 
 #endif // OMKOV_G_MAP_H_ISL5XLWM
diff --git a/src/parse.c b/src/parse.c
index 8bd85c3..ca9bc96 100644
--- a/src/parse.c
+++ b/src/parse.c
@@ -17,10 +17,8 @@
 #include <stdlib.h>
 #include <string.h>
 
-// #define L (p)
-
 char *ast_ks[] = {
-	"AK_VOID",
+	"AK_NIL",
 
 	"AK_DECL", "AK_ASSN", "AK_COMP",
 
@@ -69,7 +67,7 @@ static ast *parser_parse_decl(lex *l) {
 
 	switch (lex_peek(l).k) {
 	case LK_COLON:  { lex_kind(l, LK_COLON);  a->k = AK_DECL; } goto decl_expr;
-	case LK_ASSN: { lex_kind(l, LK_ASSN); a->k = AK_ASSN; } goto decl_expr;
+	// case LK_ASSN: { lex_kind(l, LK_ASSN); a->k = AK_ASSN; } goto decl_expr;
 	decl_expr: { a->cl = parser_parse_expr(l); } break;
 	default: { error(
 		1, "%zu:%zu: Unexpected: \"%s\" (parser_parse_decl)",
diff --git a/src/type.c b/src/type.c
index e06408a..c15934b 100644
--- a/src/type.c
+++ b/src/type.c
@@ -10,71 +10,71 @@
 #include <stdlib.h>
 
 static type types[] = {
-	{ TK_VOID, 0,        0, "void" },
-	{ TK_PTR,  TF_PTR,  -1, "ptr" },
-	{ TK_TYPE, 0,       -1, "type" },
-	{ TK_ANY,  0,       -1, "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, "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_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, "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_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, "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_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, "f16" },
-	{ TK_F32,  TF_FLT | TF_SIGN,  4, "f32" },
-	{ TK_F64,  TF_FLT | TF_SIGN,  8, "f64" },
+	{ 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, "c32" },
-	{ TK_C64,  TF_FLT | TF_SIGN,  8, "c64" },
+	{ 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, "i16le" },
-	{ TK_I32LE,  TF_INT | TF_SIGN | TF_LE,  4, "i32le" },
-	{ TK_I64LE,  TF_INT | TF_SIGN | TF_LE,  8, "i64le" },
+	{ 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_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, "u16le" },
-	{ TK_U32LE,  TF_INT | TF_LE,  4, "u32le" },
-	{ TK_U64LE,  TF_INT | TF_LE,  8, "u64le" },
+	{ 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_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, "f16le" },
-	{ TK_F32LE,  TF_FLT | TF_SIGN | TF_LE,  4, "f32le" },
-	{ TK_F64LE,  TF_FLT | TF_SIGN | TF_LE,  8, "f64le" },
+	{ 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_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, "char" },
 	{ TK_RUNE, TF_INT | TF_CHAR,  4, "rune" },
-	{ TK_STR,  TF_STR,           -1, "str" },
+	{ TK_STR,  TF_STR,           -1, "str"  },
 };
 
 type *t_void = &types[TK_VOID]; type *t_ptr  = &types[TK_PTR];
@@ -112,13 +112,13 @@ type *t_char = &types[TK_CHAR]; type *t_rune = &types[TK_RUNE];
 type *t_str  = &types[TK_STR];
 
 /* Initialise a new type. */
-type *type_new(type *base) {
+type *type_init(type *base) {
 	type *t = calloc(1, sizeof (type)); if (!t) { return NULL; }
 	*t = *base; t->base = base; return t;
 }
 
 /* Initialise a new pointer type. */
-type *ptrt_new(type *base) {
+type *ptrt_init(type *base) {
 	type *t = calloc(1, sizeof (type)); if (!t) { return NULL; }
 	t->k = TK_PTR; t->l = -1; t->base = base; return t;
 }
diff --git a/src/type.h b/src/type.h
index 9503743..2348014 100644
--- a/src/type.h
+++ b/src/type.h
@@ -5,8 +5,8 @@
 

 
-#ifndef OMKOV_G_TYPE_H_QHH0TJJQ
-#define OMKOV_G_TYPE_H_QHH0TJJQ
+#ifndef G_TYPE_H_QHH0TJJQ
+#define G_TYPE_H_QHH0TJJQ
 
 #include "cll/cll.h"
 
@@ -31,7 +31,7 @@ typedef enum {
 	TK_F16BE, TK_F32BE, TK_F64BE, TK_F128BE,
 
 	TK_CHAR, TK_RUNE, TK_STR,
-} type_k; /* Type Kind */
+} type_k;
 
 typedef enum {
 	TF_VOID = BIT(0),  TF_PTR  = BIT(1),
@@ -43,11 +43,11 @@ typedef enum {
 	TF_CHAR = BIT(16), TF_STR  = BIT(17),
 
 	TF_NUM  = TF_INT | TF_FLT | TF_CLX,
-} type_f; /* Type Flag */
+} type_f;
 
 typedef struct type {
 	type_k k; type_f f; sint l;
-	str name; struct type *base;
+	u8 *name; struct type *base;
 } type;
 
 extern type *t_void, *t_ptr, *t_type, *t_any;
@@ -68,8 +68,8 @@ extern type *t_f16be, *t_f32be, *t_f64be, *t_f128be;
 
 extern type *t_char, *t_rune, *t_str;
 
-extern type *type_new(type *base);
-extern type *ptrt_new(type *base);
+extern type *type_init(type *base);
+extern type *ptrt_init(type *base);
 
 extern bool is_num(type *t);
 extern bool is_int(type *t);
@@ -77,4 +77,4 @@ extern bool is_flt(type *t);
 
 extern bool is_com(type *t1, type *t2);
 
-#endif // OMKOV_G_TYPE_H_QHH0TJJQ
+#endif // G_TYPE_H_QHH0TJJQ
diff --git a/src/value.c b/src/value.c
index 7bb75e2..0e0e6fa 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(str s) {
+val val_strint(u8 *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(str s) {
 }
 
 /* Convert a float string to a val. */
-val val_strflt(str s) {
+val val_strflt(u8 *s) {
 	return val_null; /* TODO */
 }
diff --git a/src/value.h b/src/value.h
index 625e980..867b652 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(str s);
-extern val val_strflt(str s);
+extern val val_strint(u8 *s);
+extern val val_strflt(u8 *s);
 
 #endif // OMKOV_G_VALUE_H_X2RKXBBA