G

type: Minor refactor types

Diffstat

5 files changed, 150 insertions, 98 deletions

diff --git a/src/init.c b/src/init.c
index d5235ee..cfc5067 100644
--- a/src/init.c
+++ b/src/init.c
@@ -13,32 +13,32 @@
 
 static sym kwds[] = {
 	/* Boolean Types */
-	{ 0, 0, 0, 0, "b8",   &types[TK_B8],   { 0 }, NULL },
-	{ 0, 0, 0, 0, "b16",  &types[TK_B16],  { 0 }, NULL },
-	{ 0, 0, 0, 0, "b32",  &types[TK_B32],  { 0 }, NULL },
-	{ 0, 0, 0, 0, "b64",  &types[TK_B64],  { 0 }, NULL },
-	{ 0, 0, 0, 0, "bool", &types[TK_B8],   { 0 }, NULL },
+	{ 0, 0, 0, 0, "b8",   &types[TY_B8],   { 0 }, NULL },
+	{ 0, 0, 0, 0, "b16",  &types[TY_B16],  { 0 }, NULL },
+	{ 0, 0, 0, 0, "b32",  &types[TY_B32],  { 0 }, NULL },
+	{ 0, 0, 0, 0, "b64",  &types[TY_B64],  { 0 }, NULL },
+	{ 0, 0, 0, 0, "bool", &types[TY_B8],   { 0 }, NULL },
 
 	/* Integer Types */
-	{ 0, 0, 0, 0, "u8",   &types[TK_U8],   { 0 }, NULL },
-	{ 0, 0, 0, 0, "u16",  &types[TK_U16],  { 0 }, NULL },
-	{ 0, 0, 0, 0, "u32",  &types[TK_U32],  { 0 }, NULL },
-	{ 0, 0, 0, 0, "u64",  &types[TK_U64],  { 0 }, NULL },
-	{ 0, 0, 0, 0, "u128", &types[TK_U128], { 0 }, NULL },
-	{ 0, 0, 0, 0, "uint", &types[TK_UINT], { 0 }, NULL },
+	{ 0, 0, 0, 0, "u8",   &types[TY_U8],   { 0 }, NULL },
+	{ 0, 0, 0, 0, "u16",  &types[TY_U16],  { 0 }, NULL },
+	{ 0, 0, 0, 0, "u32",  &types[TY_U32],  { 0 }, NULL },
+	{ 0, 0, 0, 0, "u64",  &types[TY_U64],  { 0 }, NULL },
+	{ 0, 0, 0, 0, "u128", &types[TY_U128], { 0 }, NULL },
+	{ 0, 0, 0, 0, "uint", &types[TY_UINT], { 0 }, NULL },
 
-	{ 0, 0, 0, 0, "s8",   &types[TK_S8],   { 0 }, NULL },
-	{ 0, 0, 0, 0, "s16",  &types[TK_S16],  { 0 }, NULL },
-	{ 0, 0, 0, 0, "s32",  &types[TK_S32],  { 0 }, NULL },
-	{ 0, 0, 0, 0, "s64",  &types[TK_S64],  { 0 }, NULL },
-	{ 0, 0, 0, 0, "s128", &types[TK_S128], { 0 }, NULL },
-	{ 0, 0, 0, 0, "sint", &types[TK_SINT], { 0 }, NULL },
+	{ 0, 0, 0, 0, "s8",   &types[TY_S8],   { 0 }, NULL },
+	{ 0, 0, 0, 0, "s16",  &types[TY_S16],  { 0 }, NULL },
+	{ 0, 0, 0, 0, "s32",  &types[TY_S32],  { 0 }, NULL },
+	{ 0, 0, 0, 0, "s64",  &types[TY_S64],  { 0 }, NULL },
+	{ 0, 0, 0, 0, "s128", &types[TY_S128], { 0 }, NULL },
+	{ 0, 0, 0, 0, "sint", &types[TY_SINT], { 0 }, NULL },
 
 	/* Floating Point Types */
-	{ 0, 0, 0, 0, "f16",  &types[TK_F32],  { 0 }, NULL },
-	{ 0, 0, 0, 0, "f32",  &types[TK_F32],  { 0 }, NULL },
-	{ 0, 0, 0, 0, "f64",  &types[TK_F64],  { 0 }, NULL },
-	{ 0, 0, 0, 0, "f128", &types[TK_F128], { 0 }, NULL },
+	{ 0, 0, 0, 0, "f16",  &types[TY_F32],  { 0 }, NULL },
+	{ 0, 0, 0, 0, "f32",  &types[TY_F32],  { 0 }, NULL },
+	{ 0, 0, 0, 0, "f64",  &types[TY_F64],  { 0 }, NULL },
+	{ 0, 0, 0, 0, "f128", &types[TY_F128], { 0 }, NULL },
 
 	/* Keywords */
 	{ 0, 0, 0, 0, "proc",   NULL, { 0 }, NULL },
diff --git a/src/llvm/type.c b/src/llvm/type.c
index 091036c..083003a 100644
--- a/src/llvm/type.c
+++ b/src/llvm/type.c
@@ -13,16 +13,16 @@
 /* Return the appropriate LLVMTypeRef for a G type. */
 LLVMTypeRef llvm_type(type *t) {
 	switch (t->k) {
-	case TK_UINT: case TK_SINT: { return LLVMIntType(64);  } break;
-	case TK_U8:   case TK_S8:   { return LLVMIntType(8);   } break;
-	case TK_U16:  case TK_S16:  { return LLVMIntType(16);  } break;
-	case TK_U32:  case TK_S32:  { return LLVMIntType(32);  } break;
-	case TK_U64:  case TK_S64:  { return LLVMIntType(64);  } break;
-	case TK_U128: case TK_S128: { return LLVMIntType(128); } break;
-	case TK_F16:  { return LLVMHalfType();   } break;
-	case TK_F32:  { return LLVMFloatType();  } break;
-	case TK_F64:  { return LLVMDoubleType(); } break;
-	case TK_F128: { return LLVMFP128Type();  } break;
+	case TY_UINT: case TY_SINT: { return LLVMIntType(64);  } break;
+	case TY_U8:   case TY_S8:   { return LLVMIntType(8);   } break;
+	case TY_U16:  case TY_S16:  { return LLVMIntType(16);  } break;
+	case TY_U32:  case TY_S32:  { return LLVMIntType(32);  } break;
+	case TY_U64:  case TY_S64:  { return LLVMIntType(64);  } break;
+	case TY_U128: case TY_S128: { return LLVMIntType(128); } break;
+	case TY_F16:  { return LLVMHalfType();   } break;
+	case TY_F32:  { return LLVMFloatType();  } break;
+	case TY_F64:  { return LLVMDoubleType(); } break;
+	case TY_F128: { return LLVMFP128Type();  } break;
 	default: { return NULL; } break;
 	}
 }
diff --git a/src/parse.c b/src/parse.c
index ed8dd43..a577c95 100644
--- a/src/parse.c
+++ b/src/parse.c
@@ -184,8 +184,8 @@ static ast *parse_proc(lex *l) {
 	if (lex_peek(l).k == LK_RARROW) {
 		lex_kind(l, LK_RARROW);
 
-		/* TODO dont hardcode return type */ 
-		lex_kind(l, LK_ID); a->t = t_s64;
+		/* TODO dont hardcode return type */
+		lex_kind(l, LK_ID); a->t = &TYPE(TY_S64);
 	}
 
 	ast_push(a, parse_stmt_compound(l)); return a;
diff --git a/src/type.c b/src/type.c
index 90319a7..472dd57 100644
--- a/src/type.c
+++ b/src/type.c
@@ -7,121 +7,109 @@
 
 #include "type.h"
 
-#include <stdlib.h>
-
 type types[] = {
-	{ TK_VOID, 0,       0, "void" },
-	{ TK_PTR,  TF_PTR, -1, "ptr"  },
-	{ TK_TYPE, 0,      -1, "type" },
-	{ TK_ANY,  0,      -1, "any"  },
+	{ TY_NULL, 0,       0, "void" },
+	{ TY_TYPE, 0,      -1, "type" },
+	{ TY_PTR,  TF_PTR, -1, "ptr"  },
+	{ TY_ANY,  0,      -1, "any"  },
+	
+	{ TY_BOOL, TF_BOOL, 1, "bool" },
+	{ TY_B8,   TF_BOOL, 1, "b8"   },
+	{ TY_B16,  TF_BOOL, 2, "b16"  },
+	{ TY_B32,  TF_BOOL, 4, "b32"  },
+	{ TY_B64,  TF_BOOL, 8, "b64"  },
+	
+	{ TY_UINT, TF_INT, -1, "uint" },
+	{ TY_U8,   TF_INT,  1, "u8"   },
+	{ TY_U16,  TF_INT,  2, "u16"  },
+	{ TY_U32,  TF_INT,  4, "u32"  },
+	{ TY_U64,  TF_INT,  8, "u64"  },
+	{ TY_U128, TF_INT, 16, "u128" },
 
-	{ 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"  },
+	{ TY_SINT, TF_INT | TF_SIGN, -1, "sint" },
+	{ TY_S8,   TF_INT | TF_SIGN,  1, "s8"   },
+	{ TY_S16,  TF_INT | TF_SIGN,  2, "s16"  },
+	{ TY_S32,  TF_INT | TF_SIGN,  4, "s32"  },
+	{ TY_S64,  TF_INT | TF_SIGN,  8, "s64"  },
+	{ TY_S128, TF_INT | TF_SIGN, 16, "s128" },
 
-	{ 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" },
+	{ TY_F16,  TF_FLT | TF_SIGN,  2, "f16"  },
+	{ TY_F32,  TF_FLT | TF_SIGN,  4, "f32"  },
+	{ TY_F64,  TF_FLT | TF_SIGN,  8, "f64"  },
+	{ TY_F128, TF_FLT | TF_SIGN, 16, "f128" },
 
-	{ 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" },
+	{ TY_C32,  TF_CLX | TF_SIGN,  4, "c32"  },
+	{ TY_C64,  TF_CLX | TF_SIGN,  8, "c64"  },
+	{ TY_C128, TF_CLX | TF_SIGN, 16, "c128" },
+	{ TY_C256, TF_CLX | TF_SIGN, 32, "c256" },
 
-	{ 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" },
+	{ TY_Q64,  TF_QTN | TF_SIGN,  8, "q64"  },
+	{ TY_Q128, TF_QTN | TF_SIGN, 16, "q128" },
+	{ TY_Q256, TF_QTN | TF_SIGN, 32, "q256" },
+	{ TY_Q512, TF_QTN | TF_SIGN, 64, "q512" },
 
-	{ 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" },
+	{ TY_U16LE,  TF_INT | TF_LE,  2, "u16le"  },
+	{ TY_U32LE,  TF_INT | TF_LE,  4, "u32le"  },
+	{ TY_U64LE,  TF_INT | TF_LE,  8, "u64le"  },
+	{ TY_U128LE, TF_INT | TF_LE, 16, "u128le" },
+	{ TY_U16BE,  TF_INT | TF_BE,  2, "u16be"  },
+	{ TY_U32BE,  TF_INT | TF_BE,  4, "u32be"  },
+	{ TY_U64BE,  TF_INT | TF_BE,  8, "u64be"  },
+	{ TY_U128BE, TF_INT | TF_BE, 16, "u128be" },
 
-	{ 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" },
+	{ TY_S16LE,  TF_INT | TF_SIGN | TF_LE,  2, "i16le"  },
+	{ TY_S32LE,  TF_INT | TF_SIGN | TF_LE,  4, "i32le"  },
+	{ TY_S64LE,  TF_INT | TF_SIGN | TF_LE,  8, "i64le"  },
+	{ TY_S128LE, TF_INT | TF_SIGN | TF_LE, 16, "i128le" },
+	{ TY_S16BE,  TF_INT | TF_SIGN | TF_BE,  2, "i16be"  },
+	{ TY_S32BE,  TF_INT | TF_SIGN | TF_BE,  4, "i32be"  },
+	{ TY_S64BE,  TF_INT | TF_SIGN | TF_BE,  8, "i64be"  },
+	{ TY_S128BE, 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_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" },
+	{ TY_F16LE,  TF_FLT | TF_SIGN | TF_LE,  2, "f16le"  },
+	{ TY_F32LE,  TF_FLT | TF_SIGN | TF_LE,  4, "f32le"  },
+	{ TY_F64LE,  TF_FLT | TF_SIGN | TF_LE,  8, "f64le"  },
+	{ TY_F128LE, TF_FLT | TF_SIGN | TF_LE, 16, "f128le" },
+	{ TY_F16BE,  TF_FLT | TF_SIGN | TF_BE,  2, "f16be"  },
+	{ TY_F32BE,  TF_FLT | TF_SIGN | TF_BE,  4, "f32be"  },
+	{ TY_F64BE,  TF_FLT | TF_SIGN | TF_BE,  8, "f64be"  },
+	{ TY_F128BE, TF_FLT | TF_SIGN | TF_BE, 16, "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" },
+	{ TY_C32LE,  TF_CLX | TF_SIGN | TF_LE,  4, "c32le"  },
+	{ TY_C64LE,  TF_CLX | TF_SIGN | TF_LE,  8, "c64le"  },
+	{ TY_C128LE, TF_CLX | TF_SIGN | TF_LE, 16, "c128le" },
+	{ TY_C256LE, TF_CLX | TF_SIGN | TF_LE, 32, "c256le" },
+	{ TY_C32BE,  TF_CLX | TF_SIGN | TF_BE,  4, "c32be"  },
+	{ TY_C64BE,  TF_CLX | TF_SIGN | TF_BE,  8, "c64be"  },
+	{ TY_C128BE, TF_CLX | TF_SIGN | TF_BE, 16, "c128be" },
+	{ TY_C256BE, TF_CLX | TF_SIGN | TF_BE, 32, "c256be" },
 
-	{ TK_CHAR, TF_INT | TF_CHAR,  1, "char" },
-	{ TK_RUNE, TF_INT | TF_CHAR,  4, "rune" },
-	{ TK_STR,  TF_STR,           -1, "str"  },
+	{ TY_Q64LE,  TF_CLX | TF_SIGN | TF_LE,  8, "q64le"  },
+	{ TY_Q128LE, TF_CLX | TF_SIGN | TF_LE, 16, "q128le" },
+	{ TY_Q256LE, TF_CLX | TF_SIGN | TF_LE, 32, "q256le" },
+	{ TY_Q512LE, TF_CLX | TF_SIGN | TF_LE,  4, "q512le" },
+	{ TY_Q64BE,  TF_CLX | TF_SIGN | TF_BE,  8, "q64be"  },
+	{ TY_Q128BE, TF_CLX | TF_SIGN | TF_BE, 16, "q128be" },
+	{ TY_Q256BE, TF_CLX | TF_SIGN | TF_BE, 32, "q256be" },
+	{ TY_Q512BE, TF_CLX | TF_SIGN | TF_BE,  4, "q512be" },
+	
+	{ TY_BYTE, TF_INT,            1, "byte" },
+	{ TY_CHAR, TF_INT | TF_CHAR,  1, "char" },
+	{ TY_RUNE, TF_INT | TF_CHAR,  4, "rune" },
+	{ TY_STR,  TF_STR,           -1, "str"  },
 };
 
-type *t_void = &types[TK_VOID]; type *t_ptr  = &types[TK_PTR];
-type *t_type = &types[TK_TYPE]; type *t_any  = &types[TK_ANY];
-
-type *t_bool = &types[TK_BOOL]; type *t_b8   = &types[TK_B8];
-type *t_b16  = &types[TK_B16];  type *t_b32  = &types[TK_B32];
-type *t_b64  = &types[TK_B64];
-
-type *t_uint = &types[TK_UINT]; type *t_u8   = &types[TK_U8];
-type *t_u16  = &types[TK_U16];  type *t_u32  = &types[TK_U32];
-type *t_u64  = &types[TK_U64];  type *t_u128 = &types[TK_U128];
-type *t_sint = &types[TK_SINT]; type *t_s8   = &types[TK_S8];
-type *t_s16  = &types[TK_S16];  type *t_s32  = &types[TK_S32];
-type *t_s64  = &types[TK_S64];  type *t_s128 = &types[TK_S128];
-type *t_f16  = &types[TK_F16];  type *t_f32  = &types[TK_F32];
-type *t_f64  = &types[TK_F64];  type *t_f128 = &types[TK_F128];
-type *t_c32  = &types[TK_C32];  type *t_c64  = &types[TK_C64];
-type *t_c128 = &types[TK_C128]; type *t_c256 = &types[TK_C256];
-
-type *t_i16le = &types[TK_I16LE]; type *t_i32le  = &types[TK_I32LE];
-type *t_i64le = &types[TK_I64LE]; type *t_i128le = &types[TK_I128LE];
-type *t_i16be = &types[TK_I16BE]; type *t_i32be  = &types[TK_I32BE];
-type *t_i64be = &types[TK_I64BE]; type *t_i128be = &types[TK_I128BE];
-type *t_u16le = &types[TK_U16LE]; type *t_u32le  = &types[TK_U32LE];
-type *t_u64le = &types[TK_U64LE]; type *t_u128le = &types[TK_U128LE];
-type *t_u16be = &types[TK_U16BE]; type *t_u32be  = &types[TK_U32BE];
-type *t_u64be = &types[TK_U64BE]; type *t_u128be = &types[TK_U128BE];
-type *t_f16le = &types[TK_F16LE]; type *t_f32le  = &types[TK_F32LE];
-type *t_f64le = &types[TK_F64LE]; type *t_f128le = &types[TK_F128LE];
-type *t_f16be = &types[TK_F16BE]; type *t_f32be  = &types[TK_F32BE];
-type *t_f64be = &types[TK_F64BE]; type *t_f128be = &types[TK_F128BE];
-
-type *t_char = &types[TK_CHAR]; type *t_rune = &types[TK_RUNE];
-type *t_str  = &types[TK_STR];
-
 /* Initialise a new type. */
-type *type_init(type *base) {
-	type *t = calloc(1, sizeof (type)); if (!t) { return NULL; }
-	*t = *base; t->base = base; return t;
-}
+// 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_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;
-}
+// type *ptrt_init(type *base) {
+// 	type *t = calloc(1, sizeof (type)); if (!t) { return NULL; }
+// 	t->k = TY_PTR; t->l = -1; t->base = base; return t;
+// }
 
 /* Check if a type is numerical. */
 inline bool is_num(type *t) { return (t->f & TF_NUM); }
diff --git a/src/type.h b/src/type.h
index 10c2b23..00e2933 100644
--- a/src/type.h
+++ b/src/type.h
@@ -10,34 +10,43 @@
 
 #include "util/util.h"
 
+#define TYPE(a) (types[a])
+
 typedef enum {
-	TK_VOID, TK_PTR, TK_TYPE, TK_ANY,
+	TY_NULL, TY_TYPE, TY_PTR, TY_ANY,
+	
+	TY_BOOL, TY_B8, TY_B16, TY_B32, TY_B64,
 
-	TK_BOOL, TK_B8, TK_B16, TK_B32, TK_B64,
+	TY_UINT, TY_U8, TY_U16, TY_U32, TY_U64, TY_U128,
+	TY_SINT, TY_S8, TY_S16, TY_S32, TY_S64, TY_S128,
 
-	TK_UINT, TK_U8, TK_U16, TK_U32, TK_U64, TK_U128,
-	TK_SINT, TK_S8, TK_S16, TK_S32, TK_S64, TK_S128,
+	TY_F16, TY_F32, TY_F64,   TY_F128,
+	TY_C32, TY_C64, TY_C128,  TY_C256,
+	TY_Q64, TY_Q128, TY_Q256, TY_Q512,
 
-	TK_F16, TK_F32, TK_F64,  TK_F128,
-	TK_C32, TK_C64, TK_C128, TK_C256,
+	TY_U16LE, TY_U32LE, TY_U64LE, TY_U128LE,
+	TY_U16BE, TY_U32BE, TY_U64BE, TY_U128BE,
 
-	TK_I16LE, TK_I32LE, TK_I64LE, TK_I128LE,
-	TK_I16BE, TK_I32BE, TK_I64BE, TK_I128BE,
+	TY_S16LE, TY_S32LE, TY_S64LE, TY_S128LE,
+	TY_S16BE, TY_S32BE, TY_S64BE, TY_S128BE,
 
-	TK_U16LE, TK_U32LE, TK_U64LE, TK_U128LE,
-	TK_U16BE, TK_U32BE, TK_U64BE, TK_U128BE,
+	TY_F16LE, TY_F32LE, TY_F64LE, TY_F128LE,
+	TY_F16BE, TY_F32BE, TY_F64BE, TY_F128BE,
 
-	TK_F16LE, TK_F32LE, TK_F64LE, TK_F128LE,
-	TK_F16BE, TK_F32BE, TK_F64BE, TK_F128BE,
+	TY_C32LE, TY_C64LE, TY_C128LE, TY_C256LE,
+	TY_C32BE, TY_C64BE, TY_C128BE, TY_C256BE,
 
-	TK_CHAR, TK_RUNE, TK_STR,
+	TY_Q64LE, TY_Q128LE, TY_Q256LE, TY_Q512LE,
+	TY_Q64BE, TY_Q128BE, TY_Q256BE, TY_Q512BE,
+	
+	TY_BYTE, TY_CHAR, TY_RUNE, TY_STR,
 } type_k;
 
 typedef enum {
-	TF_VOID = BIT(0),  TF_PTR  = BIT(1),
+	TF_NULL = BIT(0),  TF_PTR  = BIT(1),
 	TF_BOOL = BIT(2),  TF_INT  = BIT(3),
 	TF_FLT  = BIT(4),  TF_CLX  = BIT(5),
-	TF_SIGN = BIT(6),
+	TF_QTN  = BIT(6),  TF_SIGN = BIT(7),
 
 	TF_LE   = BIT(14), TF_BE   = BIT(15),
 	TF_CHAR = BIT(16), TF_STR  = BIT(17),
@@ -46,32 +55,14 @@ typedef enum {
 } type_f;
 
 typedef struct type_s {
-	type_k k; type_f f; sint l;
-	char *s; struct type_s *base;
+	type_k k; type_f f; s64 l; char *s;
+	struct type_s *base;
 } type;
 
 extern type types[];
 
-extern type *t_void, *t_ptr, *t_type, *t_any;
-
-extern type *t_bool, *t_b8, *t_b16, *t_b32, *t_b64;
-
-extern type *t_uint, *t_u8, *t_u16, *t_u32, *t_u64, *t_u128;
-extern type *t_sint, *t_s8, *t_s16, *t_s32, *t_s64, *t_s128;
-extern type *t_f16, *t_f32, *t_f64, *t_f128;
-extern type *t_c32, *t_c64, *t_c128, *t_c256;
-
-extern type *t_u16le, *t_u32le, *t_u64le, *t_u128le;
-extern type *t_u16be, *t_u32be, *t_u64be, *t_u128be;
-extern type *t_s16le, *t_s32le, *t_s64le, *t_s128le;
-extern type *t_s16be, *t_s32be, *t_s64be, *t_s128be;
-extern type *t_f16le, *t_f32le, *t_f64le, *t_f128le;
-extern type *t_f16be, *t_f32be, *t_f64be, *t_f128be;
-
-extern type *t_char, *t_rune, *t_str;
-
-extern type *type_init(type *base);
-extern type *ptrt_init(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);