From 5277f2222417b5366e1ef6e0871c90e3946b1742 Mon Sep 17 00:00:00 2001 From: Leo Tenenbaum Date: Fri, 1 May 2020 15:49:30 -0400 Subject: &void --- cgen.c | 21 ++----- copy.c | 2 - eval.c | 103 +++++++++++++++++---------------- foreign.c | 10 ++-- infer.c | 1 - instance_table.c | 10 ++-- main.c | 4 +- parse.c | 27 +++++---- test.toc | 10 +--- toc.c | 3 + types.c | 170 +++++++++++++++++++++++++++++-------------------------- types.h | 9 +-- 12 files changed, 188 insertions(+), 182 deletions(-) diff --git a/cgen.c b/cgen.c index 5927858..188a16e 100644 --- a/cgen.c +++ b/cgen.c @@ -169,7 +169,6 @@ static void cgen_defs_decl(CGenerator *g, Declaration *d); case TYPE_PTR: \ f(g, type->ptr); \ break; \ - case TYPE_VOID: \ case TYPE_BUILTIN: \ case TYPE_UNKNOWN: \ break; \ @@ -286,7 +285,6 @@ static bool cgen_uses_ptr(Type *t) { case TYPE_PTR: case TYPE_FN: case TYPE_SLICE: - case TYPE_VOID: case TYPE_UNKNOWN: return false; case TYPE_EXPR: @@ -326,16 +324,14 @@ static void cgen_type_pre(CGenerator *g, Type *t) { case BUILTIN_BOOL: cgen_write(g, "bool"); break; case BUILTIN_F32: cgen_write(g, "f32"); break; case BUILTIN_F64: cgen_write(g, "f64"); break; + case BUILTIN_VOID: cgen_write(g, "void"); break; case BUILTIN_NMS: case BUILTIN_TYPE: case BUILTIN_VARARGS: assert(0); break; } break; case TYPE_PTR: - if (t->ptr->kind == TYPE_UNKNOWN) - cgen_write(g, "void"); /* #C &"foo", for example */ - else - cgen_type_pre(g, t->ptr); + cgen_type_pre(g, t->ptr); cgen_write(g, "(*"); break; case TYPE_ARR: @@ -353,7 +349,6 @@ static void cgen_type_pre(CGenerator *g, Type *t) { case TYPE_SLICE: cgen_write(g, "slice_"); break; - case TYPE_VOID: cgen_write(g, "void"); break; case TYPE_STRUCT: cgen_write(g, "struct "); cgen_struct_name(g, t->struc); @@ -416,7 +411,6 @@ static void cgen_type_post(CGenerator *g, Type *t) { cgen_type_post(g, &t->fn.types[0]); } break; case TYPE_BUILTIN: - case TYPE_VOID: case TYPE_UNKNOWN: case TYPE_TUPLE: case TYPE_SLICE: @@ -543,7 +537,6 @@ static void cgen_val_ptr_pre(CGenerator *g, void *v, Type *t) { case TYPE_FN: case TYPE_UNKNOWN: case TYPE_TUPLE: - case TYPE_VOID: case TYPE_BUILTIN: case TYPE_PTR: case TYPE_STRUCT: @@ -559,7 +552,6 @@ static void cgen_val_ptr(CGenerator *g, void *v, Type *t) { assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { case TYPE_TUPLE: - case TYPE_VOID: case TYPE_EXPR: case TYPE_UNKNOWN: assert(0); @@ -612,6 +604,7 @@ static void cgen_val_ptr(CGenerator *g, void *v, Type *t) { case BUILTIN_TYPE: case BUILTIN_NMS: case BUILTIN_VARARGS: + case BUILTIN_VOID: assert(0); break; } @@ -829,7 +822,6 @@ static void cgen_set(CGenerator *g, Expression *set_expr, const char *set_str, E assert(set_expr->kind == EXPR_TUPLE); cgen_set_tuple(g, set_expr->tuple, NULL, NULL, to_expr); break; - case TYPE_VOID: case TYPE_EXPR: assert(0); break; @@ -1003,7 +995,7 @@ static void cgen_expr_pre(CGenerator *g, Expression *e) { cgen_ident_id_to_str(ret_name, id); char *p = ret_name + strlen(ret_name); - if (e->type.kind != TYPE_VOID) { + if (!type_is_void(&e->type)) { if (e->type.kind == TYPE_TUPLE) { for (unsigned long i = 0; i < arr_len(e->type.tuple); ++i) { sprintf(p, "%lu", i); @@ -1665,7 +1657,7 @@ static void cgen_expr(CGenerator *g, Expression *e) { } break; case EXPR_BLOCK: case EXPR_IF: - if (e->type.kind != TYPE_VOID) + if (!type_is_void(&e->type)) cgen_ident_id(g, e->cgen.id); break; case EXPR_CALL: @@ -1850,7 +1842,6 @@ static void cgen_zero_value(CGenerator *g, Type *t) { case TYPE_STRUCT: cgen_write(g, "{0}"); break; - case TYPE_VOID: case TYPE_UNKNOWN: case TYPE_TUPLE: case TYPE_EXPR: @@ -2104,7 +2095,7 @@ static void cgen_ret(CGenerator *g, Block *returning_from, Expression *ret_expr) ret.type = f->ret_type; #endif cgen_writeln(g, " return;"); - } else if (f->ret_type.kind == TYPE_VOID) { + } else if (type_is_void(&f->ret_type)) { cgen_writeln(g, "return;"); } else { cgen_writeln(g, "return ret_;"); diff --git a/copy.c b/copy.c index 05b1eea..e34036c 100644 --- a/copy.c +++ b/copy.c @@ -53,7 +53,6 @@ static void copy_val(Allocator *a, Value *out, Value in, Type *t) { case TYPE_FN: case TYPE_PTR: case TYPE_SLICE: - case TYPE_VOID: case TYPE_UNKNOWN: *out = in; break; @@ -122,7 +121,6 @@ static void copy_type(Copier *c, Type *out, Type *in) { *out = *in; switch (in->kind) { case TYPE_BUILTIN: - case TYPE_VOID: case TYPE_UNKNOWN: break; case TYPE_EXPR: diff --git a/eval.c b/eval.c index cda97da..1a2451d 100644 --- a/eval.c +++ b/eval.c @@ -37,6 +37,7 @@ static bool builtin_truthiness(Value v, BuiltinType b) { case BUILTIN_BOOL: return v.boolv; case BUILTIN_CHAR: return v.charv != 0; case BUILTIN_VARARGS: return arr_len(v.varargs) != 0; + case BUILTIN_VOID: case BUILTIN_TYPE: case BUILTIN_NMS: break; @@ -47,7 +48,6 @@ static bool builtin_truthiness(Value v, BuiltinType b) { static bool val_truthiness(Value v, Type *t) { assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { - case TYPE_VOID: return false; case TYPE_UNKNOWN: assert(0); return false; case TYPE_BUILTIN: return builtin_truthiness(v, t->builtin); case TYPE_PTR: return v.ptr != NULL; @@ -146,7 +146,6 @@ static void *val_get_ptr(Value *v, Type *t) { switch (t->kind) { case TYPE_PTR: case TYPE_BUILTIN: - case TYPE_VOID: case TYPE_UNKNOWN: case TYPE_FN: case TYPE_SLICE: @@ -165,9 +164,6 @@ static void *val_get_ptr(Value *v, Type *t) { static void fprint_val_ptr(FILE *f, void *p, Type *t) { assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { - case TYPE_VOID: - fprintf(f, "(void)"); - break; case TYPE_UNKNOWN: fprintf(f, "???"); break; @@ -185,6 +181,7 @@ static void fprint_val_ptr(FILE *f, void *p, Type *t) { case BUILTIN_F64: fprintf(f, F64_FMT, *(F64 *)p); break; case BUILTIN_CHAR: fprint_char_literal(f, *(char *)p); break; case BUILTIN_BOOL: fprintf(f, "%s", *(bool *)p ? "true" : "false"); break; + case BUILTIN_VOID: fprintf(f, "(void)"); break; case BUILTIN_VARARGS: fprintf(f, "...("); arr_foreach(*(VarArg **)p, VarArg, varg) { @@ -278,7 +275,6 @@ static void *val_ptr_to_free(Value *v, Type *t) { case TYPE_FN: case TYPE_PTR: case TYPE_SLICE: - case TYPE_VOID: case TYPE_UNKNOWN: return NULL; case TYPE_ARR: @@ -302,53 +298,55 @@ static inline void val_free_ptr(Value *v, Type *t) { free(v); } -#define builtin_casts_to_int(x) \ - case BUILTIN_I8: \ - vout->i8 = (I8)(I64)vin->x; break; \ - case BUILTIN_I16: \ - vout->i16 = (I16)(I64)vin->x; break; \ - case BUILTIN_I32: \ - vout->i32 = (I32)(I64)vin->x; break; \ - case BUILTIN_I64: \ - vout->i64 = (I64)vin->x; break; \ - case BUILTIN_U8: \ - vout->u8 = (U8)(U64)vin->x; break; \ - case BUILTIN_U16: \ - vout->u16 = (U16)(U64)vin->x; break; \ - case BUILTIN_U32: \ - vout->u32 = (U32)(U64)vin->x; break; \ - case BUILTIN_U64: \ +#define builtin_casts_to_int(x) \ + case BUILTIN_I8: \ + vout->i8 = (I8)(I64)vin->x; break; \ + case BUILTIN_I16: \ + vout->i16 = (I16)(I64)vin->x; break; \ + case BUILTIN_I32: \ + vout->i32 = (I32)(I64)vin->x; break; \ + case BUILTIN_I64: \ + vout->i64 = (I64)vin->x; break; \ + case BUILTIN_U8: \ + vout->u8 = (U8)(U64)vin->x; break; \ + case BUILTIN_U16: \ + vout->u16 = (U16)(U64)vin->x; break; \ + case BUILTIN_U32: \ + vout->u32 = (U32)(U64)vin->x; break; \ + case BUILTIN_U64: \ vout->u64 = (U64)vin->x; break -#define builtin_casts_to_num(x) \ - builtin_casts_to_int(x); \ - case BUILTIN_F32: \ - vout->f32 = (F32)vin->x; break; \ - case BUILTIN_F64: \ +#define builtin_casts_to_num(x) \ + builtin_casts_to_int(x); \ + case BUILTIN_F32: \ + vout->f32 = (F32)vin->x; break; \ + case BUILTIN_F64: \ vout->f64 = (F64)vin->x; break -#define builtin_int_casts(low, up) \ - case BUILTIN_##up: \ - switch (to) { \ - builtin_casts_to_num(low); \ - case BUILTIN_CHAR: vout->charv = (char)vin->low; break; \ - case BUILTIN_BOOL: vout->boolv = vin->low != 0; break; \ - case BUILTIN_NMS: \ - case BUILTIN_TYPE: \ - case BUILTIN_VARARGS: \ - assert(0); break; \ +#define builtin_int_casts(low, up) \ + case BUILTIN_##up: \ + switch (to) { \ + builtin_casts_to_num(low); \ + case BUILTIN_CHAR: vout->charv = (char)vin->low; break; \ + case BUILTIN_BOOL: vout->boolv = vin->low != 0; break; \ + case BUILTIN_NMS: \ + case BUILTIN_VOID: \ + case BUILTIN_TYPE: \ + case BUILTIN_VARARGS: \ + assert(0); break; \ } break -#define builtin_float_casts(low, up) \ - case BUILTIN_##up: \ - switch (to) { \ - builtin_casts_to_num(low); \ - case BUILTIN_BOOL: vout->boolv = vin->low != 0.0f; break; \ - case BUILTIN_CHAR: \ - case BUILTIN_TYPE: \ - case BUILTIN_NMS: \ - case BUILTIN_VARARGS: \ - assert(0); break; \ +#define builtin_float_casts(low, up) \ + case BUILTIN_##up: \ + switch (to) { \ + builtin_casts_to_num(low); \ + case BUILTIN_BOOL: vout->boolv = vin->low != 0.0f; break; \ + case BUILTIN_CHAR: \ + case BUILTIN_TYPE: \ + case BUILTIN_NMS: \ + case BUILTIN_VARARGS: \ + case BUILTIN_VOID: \ + assert(0); break; \ } break static void val_builtin_cast(Value *vin, BuiltinType from, Value *vout, BuiltinType to) { @@ -378,6 +376,7 @@ static void val_builtin_cast(Value *vin, BuiltinType from, Value *vout, BuiltinT case BUILTIN_BOOL: case BUILTIN_TYPE: case BUILTIN_NMS: + case BUILTIN_VOID: case BUILTIN_VARARGS: assert(0); break; } @@ -385,6 +384,7 @@ static void val_builtin_cast(Value *vin, BuiltinType from, Value *vout, BuiltinT case BUILTIN_TYPE: case BUILTIN_NMS: case BUILTIN_VARARGS: + case BUILTIN_VOID: assert(0); break; } @@ -400,7 +400,6 @@ static void val_cast(Value *vin, Type *from, Value *vout, Type *to) { } switch (from->kind) { - case TYPE_VOID: case TYPE_UNKNOWN: case TYPE_TUPLE: case TYPE_STRUCT: @@ -427,7 +426,6 @@ static void val_cast(Value *vin, Type *from, Value *vout, Type *to) { case TYPE_EXPR: case TYPE_STRUCT: case TYPE_SLICE: - case TYPE_VOID: case TYPE_UNKNOWN: case TYPE_TUPLE: case TYPE_FN: @@ -462,6 +460,7 @@ static void val_cast(Value *vin, Type *from, Value *vout, Type *to) { case BUILTIN_TYPE: case BUILTIN_NMS: case BUILTIN_VARARGS: + case BUILTIN_VOID: assert(0); break; } break; @@ -537,6 +536,7 @@ static void eval_deref(Value *v, void *ptr, Type *type) { case BUILTIN_TYPE: v->type = *(Type **)ptr; break; + case BUILTIN_VOID: case BUILTIN_VARARGS: assert(0); break; @@ -545,7 +545,6 @@ static void eval_deref(Value *v, void *ptr, Type *type) { case TYPE_SLICE: v->slice = *(Slice *)ptr; break; - case TYPE_VOID: case TYPE_UNKNOWN: case TYPE_EXPR: assert(0); @@ -579,6 +578,7 @@ static void eval_deref_set(void *set, Value *to, Type *type) { case BUILTIN_TYPE: *(Type **)set = to->type; break; + case BUILTIN_VOID: case BUILTIN_VARARGS: assert(0); break; @@ -587,7 +587,6 @@ static void eval_deref_set(void *set, Value *to, Type *type) { case TYPE_SLICE: *(Slice *)set = to->slice; break; - case TYPE_VOID: case TYPE_UNKNOWN: case TYPE_EXPR: assert(0); @@ -1521,7 +1520,7 @@ static Status eval_expr(Evaluator *ev, Expression *e, Value *v) { } } if (ev->returning) { - if (fn->ret_type.kind != TYPE_VOID && !fn->ret_decls) + if (!type_is_void(&fn->ret_type) && !fn->ret_decls) *v = ev->ret_val; ev->returning = NULL; } diff --git a/foreign.c b/foreign.c index 788f87b..65de87b 100644 --- a/foreign.c +++ b/foreign.c @@ -102,9 +102,6 @@ static bool arg_list_start(av_alist *arg_list, void (*fn)(), Value *return_val, warn_print(where, "Foreign function returns function pointer. If it returns a C-style function pointer, it won't be called properly by toc."); av_start_ptr(*arg_list, fn, FnExpr *, &return_val->fn); break; - case TYPE_VOID: - av_start_void(*arg_list, fn); - break; case TYPE_PTR: av_start_ptr(*arg_list, fn, void *, &return_val->ptr); break; @@ -153,6 +150,9 @@ static bool arg_list_start(av_alist *arg_list, void (*fn)(), Value *return_val, case BUILTIN_NMS: av_start_ptr(*arg_list, fn, Namespace *, &return_val->nms); break; + case BUILTIN_VOID: + av_start_void(*arg_list, fn); + break; case BUILTIN_VARARGS: assert(0); break; @@ -197,7 +197,6 @@ static bool arg_list_start(av_alist *arg_list, void (*fn)(), Value *return_val, static bool arg_list_add(av_alist *arg_list, Value val, Type *type, Location where) { switch (type->kind) { - case TYPE_VOID: case TYPE_TUPLE: case TYPE_UNKNOWN: case TYPE_ARR: { /* @TODO: maybe just pass pointer for arr? */ @@ -262,6 +261,9 @@ static bool arg_list_add(av_alist *arg_list, Value val, Type *type, Location whe arg_list_add(arg_list, arg->val, arg->type, where); } break; + case BUILTIN_VOID: + err_print(where, "Cannot pass type void to foreign function."); + return false; } break; case TYPE_SLICE: diff --git a/infer.c b/infer.c index 8367dce..0bf5e0f 100644 --- a/infer.c +++ b/infer.c @@ -81,7 +81,6 @@ static bool infer_from_type(Typer *tr, Type *match, Type *to, Identifier *idents } } switch (match->kind) { - case TYPE_VOID: case TYPE_UNKNOWN: case TYPE_BUILTIN: break; /* nothing we can do here */ diff --git a/instance_table.c b/instance_table.c index 924ac1d..870ff60 100644 --- a/instance_table.c +++ b/instance_table.c @@ -83,15 +83,13 @@ static U64 type_hash(Type *t) { 0x8191b5178d728e8c, 0x50da97f1211b2423, 0xc3977306abd0ae6c, - 0x87ea684427e1c521, - 0xcee5fd6d6cbdfe23 + 0x87ea684427e1c521 }; U64 hash = starters[t->kind]; assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { case TYPE_BUILTIN: return hash + (U64)t->builtin * 0x1307787dfff73417; - case TYPE_VOID: case TYPE_UNKNOWN: return hash; case TYPE_TUPLE: @@ -124,7 +122,6 @@ static U64 type_hash(Type *t) { static U64 val_ptr_hash(void *v, Type *t) { assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { - case TYPE_VOID: return 0; case TYPE_UNKNOWN: return 0; case TYPE_BUILTIN: switch (t->builtin) { @@ -152,6 +149,8 @@ static U64 val_ptr_hash(void *v, Type *t) { return type_hash(*(Type **)v); case BUILTIN_NMS: return (U64)*(Namespace **)v; + case BUILTIN_VOID: + return 0; } assert(0); return 0; @@ -224,6 +223,7 @@ static bool val_ptr_eq(void *u, void *v, Type *t) { case BUILTIN_F64: return *(F64 *)u == *(F64 *)v; case BUILTIN_BOOL: return *(bool *)u == *(bool *)v; case BUILTIN_CHAR: return *(char *)u == *(char *)v; + case BUILTIN_VOID: return true; case BUILTIN_VARARGS: { VarArg *us = *(VarArg **)u, *vs = *(VarArg **)v; size_t n = arr_len(us); @@ -243,8 +243,6 @@ static bool val_ptr_eq(void *u, void *v, Type *t) { return *(Namespace **)u == *(Namespace **)v; } break; - case TYPE_VOID: - return true; case TYPE_UNKNOWN: return false; case TYPE_FN: diff --git a/main.c b/main.c index 704b534..0b2fd5c 100644 --- a/main.c +++ b/main.c @@ -8,11 +8,12 @@ /* @TODO: -&void null +fix eval pointer arithmetic - we're not multiplying by the size? fix including something twice - just use the non-namespacey version if it exists or pick one namespace to use everywhere otherwise - maybe store info about namespaces which are secretly the same as inline blocks/other namespaces in the Typer &&, || +#no_warn start making a standard library... (printf; stringbuilder would be nice to have) improve type_to_str: Foo ::= struct(t::Type) {} @@ -23,6 +24,7 @@ enums unions --- switch to / add as an alternative: libffi + - better yet, inline assembly don't bother generating ret_ if nothing's deferred X ::= newtype(int); or something any odd number of "s for a string diff --git a/parse.c b/parse.c index 3780b40..b06e0e1 100644 --- a/parse.c +++ b/parse.c @@ -170,6 +170,7 @@ static int kw_to_builtin_type(Keyword kw) { case KW_BOOL: return BUILTIN_BOOL; case KW_CHAR: return BUILTIN_CHAR; case KW_TYPE: return BUILTIN_TYPE; + case KW_VOID: return BUILTIN_VOID; case KW_NAMESPACE: return BUILTIN_NMS; /* don't allow .. => varargs because it's not a normal type */ default: return -1; @@ -192,6 +193,7 @@ static Keyword builtin_type_to_kw(BuiltinType t) { case BUILTIN_BOOL: return KW_BOOL; case BUILTIN_CHAR: return KW_CHAR; case BUILTIN_TYPE: return KW_TYPE; + case BUILTIN_VOID: return KW_VOID; case BUILTIN_NMS: return KW_NAMESPACE; case BUILTIN_VARARGS: return KW_DOTDOT; } @@ -203,8 +205,6 @@ static Keyword builtin_type_to_kw(BuiltinType t) { static size_t type_to_str_(Type *t, char *buffer, size_t bufsize) { bool resolved = (t->flags & TYPE_IS_RESOLVED) != 0; switch (t->kind) { - case TYPE_VOID: - return str_copy(buffer, bufsize, "void"); case TYPE_UNKNOWN: return str_copy(buffer, bufsize, "???"); case TYPE_BUILTIN: { @@ -234,7 +234,7 @@ static size_t type_to_str_(Type *t, char *buffer, size_t bufsize) { written += type_to_str_(¶m_types[i], buffer + written, bufsize - written); } written += str_copy(buffer + written, bufsize - written, ")"); - if (ret_type->kind != TYPE_VOID) { + if (!type_is_builtin(ret_type, BUILTIN_VOID)) { written += str_copy(buffer + written, bufsize - written, " "); written += type_to_str_(ret_type, buffer + written, bufsize - written); } @@ -550,7 +550,8 @@ static Status parse_type(Parser *p, Type *type, Location *where) { && t->token->kw != KW_LPAREN && t->token->kw != KW_AMPERSAND) || t->token->kw == KW_AS) { - ret_type->kind = TYPE_VOID; + ret_type->kind = TYPE_BUILTIN; + ret_type->builtin = BUILTIN_VOID; ret_type->flags = 0; } else { if (!parse_type(p, ret_type, NULL)) @@ -930,7 +931,8 @@ static Status parse_fn_expr(Parser *p, FnExpr *f) { if (token_is_kw(t->token, KW_LBRACE)) { /* void function */ - f->ret_type.kind = TYPE_VOID; + f->ret_type.kind = TYPE_BUILTIN; + f->ret_type.builtin = BUILTIN_VOID; f->ret_type.flags = 0; } else if (is_decl(t)) { if (!parse_decl_list(p, &f->ret_decls, DECL_CAN_END_WITH_LBRACE | DECL_CAN_END_WITH_COMMA)) @@ -943,7 +945,8 @@ static Status parse_fn_expr(Parser *p, FnExpr *f) { } --t->token; /* move back to { */ /* just set return type to void. the actual return type will be set by types.c:type_of_fn */ - f->ret_type.kind = TYPE_VOID; + f->ret_type.kind = TYPE_BUILTIN; + f->ret_type.builtin = BUILTIN_VOID; f->ret_type.flags = 0; } else { if (!parse_type(p, &f->ret_type, NULL)) { @@ -1088,11 +1091,12 @@ static Status ctype_to_type(Allocator *a, CType *ctype, Type *type, Location whe case CTYPE_DOUBLE: type->builtin = BUILTIN_F64; break; - case CTYPE_PTR: + case CTYPE_PTR: { type->kind = TYPE_PTR; - type->ptr = allocr_calloc(a, 1, sizeof *type->ptr); - type->ptr->kind = TYPE_VOID; - break; + Type *p = type->ptr = allocr_calloc(a, 1, sizeof *type->ptr); + p->kind = TYPE_BUILTIN; + p->builtin = BUILTIN_VOID; + } break; case CTYPE_UNSIGNED: assert(0); break; } if (size != 0) { @@ -1537,7 +1541,8 @@ static Status parse_expr(Parser *p, Expression *e, Token *end) { if (t->token == end) { /* void */ ret_ctype->kind = CTYPE_NONE; - ret_type->kind = TYPE_VOID; + ret_type->kind = TYPE_BUILTIN; + ret_type->builtin = BUILTIN_VOID; ret_type->flags = 0; } else { if (!parse_c_type(p, ret_ctype, ret_type)) diff --git a/test.toc b/test.toc index 822084b..891b513 100644 --- a/test.toc +++ b/test.toc @@ -1,11 +1,7 @@ #include "std/io.toc"; main ::= fn() { - #if "hello" { - x := 5; - } else { - x : FOOTYPE = 6.3 + "foo"; - _+3=bar; - } - puti(x); + x : &void = 18 as &&char; + puti(x as int); + } diff --git a/toc.c b/toc.c index 6089c20..954f357 100644 --- a/toc.c +++ b/toc.c @@ -81,6 +81,9 @@ static void fprint_char_literal(FILE *f, char c) { static inline bool type_is_builtin(Type *t, BuiltinType b) { return t->kind == TYPE_BUILTIN && t->builtin == b; } +static inline bool type_is_void(Type *t) { + return t->kind == TYPE_BUILTIN && t->builtin == BUILTIN_VOID; +} static inline bool type_is_slicechar(Type *t) { return t->kind == TYPE_SLICE && type_is_builtin(t->slice, BUILTIN_CHAR); diff --git a/types.c b/types.c index 22126a0..a3fb651 100644 --- a/types.c +++ b/types.c @@ -59,6 +59,7 @@ static size_t compiler_sizeof_builtin(BuiltinType b) { case BUILTIN_TYPE: return sizeof(Type *); case BUILTIN_NMS: return sizeof(Namespace *); case BUILTIN_VARARGS: return sizeof(VarArg *); + case BUILTIN_VOID: return 1; /* void ptr arithmetic */ } assert(0); return 0; @@ -80,6 +81,7 @@ static size_t compiler_alignof_builtin(BuiltinType b) { case BUILTIN_TYPE: return toc_alignof(Type *); case BUILTIN_NMS: return toc_alignof(Namespace *); case BUILTIN_VARARGS: return toc_alignof(VarArg *); + case BUILTIN_VOID: return 1; } assert(0); return 0; @@ -227,8 +229,6 @@ static size_t compiler_alignof(Type *t) { switch (t->kind) { case TYPE_BUILTIN: return compiler_alignof_builtin(t->builtin); - case TYPE_VOID: - return 1; case TYPE_FN: return toc_alignof(FnExpr *); case TYPE_PTR: @@ -277,7 +277,6 @@ static size_t compiler_sizeof(Type *t) { return SIZE_MAX; return t->struc->size; } break; - case TYPE_VOID: case TYPE_UNKNOWN: return 0; case TYPE_EXPR: @@ -359,7 +358,6 @@ static bool type_eq_exact(Type *a, Type *b) { if (a->kind != b->kind) return false; switch (a->kind) { - case TYPE_VOID: return true; case TYPE_UNKNOWN: return true; case TYPE_BUILTIN: return a->builtin == b->builtin; @@ -429,7 +427,7 @@ static bool type_eq_implicit(Type *a, Type *b) { } if (a->kind == TYPE_PTR) { /* &void casts to &anything */ - if (a->ptr->kind == TYPE_VOID || b->ptr->kind == TYPE_VOID) + if (type_is_builtin(a->ptr, BUILTIN_VOID) || type_is_builtin(b->ptr, BUILTIN_VOID)) return true; } return type_eq_exact(a, b); @@ -447,8 +445,13 @@ static Type *overriding_type(Type *a, Type *b) { } return b; } + if (b->flags & TYPE_IS_FLEXIBLE) return a; + + if (a->kind == TYPE_PTR && type_is_builtin(a->ptr, BUILTIN_VOID)) + return b; + /* doesn't matter */ return a; } @@ -530,7 +533,6 @@ static Status expr_must_lval(Expression *e, const char *purpose) { static bool type_is_compileonly(Type *t) { assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { - case TYPE_VOID: case TYPE_UNKNOWN: return false; case TYPE_BUILTIN: @@ -708,7 +710,7 @@ static Status type_of_fn(Typer *tr, FnExpr *f, Type *t, U16 flags) { } } - if (f->ret_decls && !generic && f->ret_type.kind == TYPE_VOID /* haven't found return type yet */) { + if (f->ret_decls && !generic && type_is_builtin(&f->ret_type, BUILTIN_VOID) /* haven't found return type yet */) { /* find return type */ arr_foreach(f->ret_decls, Declaration, d) { @@ -980,7 +982,6 @@ static Status type_resolve(Typer *tr, Type *t, Location where) { } } break; case TYPE_UNKNOWN: - case TYPE_VOID: case TYPE_BUILTIN: break; } @@ -993,7 +994,6 @@ static Status type_resolve(Typer *tr, Type *t, Location where) { static bool type_can_be_truthy(Type *t) { assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { - case TYPE_VOID: case TYPE_TUPLE: case TYPE_ARR: case TYPE_STRUCT: @@ -1007,6 +1007,7 @@ static bool type_can_be_truthy(Type *t) { switch (t->builtin) { case BUILTIN_TYPE: case BUILTIN_NMS: + case BUILTIN_VOID: return false; case BUILTIN_I8: case BUILTIN_U8: @@ -1045,7 +1046,6 @@ static CastStatus type_cast_status(Type *from, Type *to) { switch (from->kind) { case TYPE_UNKNOWN: return CAST_STATUS_NONE; case TYPE_STRUCT: - case TYPE_VOID: return CAST_STATUS_ERR; case TYPE_BUILTIN: switch (from->builtin) { @@ -1076,6 +1076,7 @@ static CastStatus type_cast_status(Type *from, Type *to) { case BUILTIN_TYPE: case BUILTIN_NMS: case BUILTIN_VARARGS: + case BUILTIN_VOID: return CAST_STATUS_ERR; } assert(0); @@ -1108,6 +1109,7 @@ static CastStatus type_cast_status(Type *from, Type *to) { case BUILTIN_TYPE: case BUILTIN_NMS: case BUILTIN_VARARGS: + case BUILTIN_VOID: return CAST_STATUS_ERR; } assert(0); @@ -1121,6 +1123,7 @@ static CastStatus type_cast_status(Type *from, Type *to) { case BUILTIN_TYPE: case BUILTIN_NMS: case BUILTIN_VARARGS: + case BUILTIN_VOID: return CAST_STATUS_ERR; } break; @@ -1206,7 +1209,7 @@ static Status types_fn(Typer *tr, FnExpr *f, Type *t, Instance *instance) { success = false; goto ret; } - } else if (ret_type->kind != TYPE_VOID && !has_named_ret_vals) { + } else if (!type_is_builtin(ret_type, BUILTIN_VOID) && !has_named_ret_vals) { Statement *stmts = f->body.stmts; if (arr_len(stmts)) { Statement *last_stmt = (Statement *)stmts + (arr_len(stmts) - 1); @@ -2019,7 +2022,8 @@ static Status types_expr(Typer *tr, Expression *e) { goto for_fail; } - t->kind = TYPE_VOID; + t->kind = TYPE_BUILTIN; + t->builtin = BUILTIN_VOID; typer_block_exit(tr); }break; @@ -2173,7 +2177,7 @@ static Status types_expr(Typer *tr, Expression *e) { if (curr->body.ret_expr) { *t = curr->body.ret_expr->type; } else { - t->kind = TYPE_VOID; + t->kind = TYPE_BUILTIN; t->builtin = BUILTIN_VOID; t->flags |= TYPE_IS_RESOLVED; } while (1) { @@ -2199,7 +2203,7 @@ static Status types_expr(Typer *tr, Expression *e) { if (nexti->body.ret_expr) { *next_type = nexti->body.ret_expr->type; } else { - next_type->kind = TYPE_VOID; + next_type->kind = TYPE_BUILTIN; next_type->builtin = BUILTIN_VOID; next_type->flags = TYPE_IS_RESOLVED; } if (!type_eq_implicit(next_type, curr_type)) { @@ -2217,7 +2221,7 @@ static Status types_expr(Typer *tr, Expression *e) { } } - if (!has_else && t->kind != TYPE_VOID) { + if (!has_else && !type_is_builtin(t, BUILTIN_VOID)) { err_print(e->where, "Non-void if block with no else."); return false; } @@ -2235,7 +2239,8 @@ static Status types_expr(Typer *tr, Expression *e) { err_print(w->body.ret_expr->where, "while loops can't return values -- you're missing a semicolon (;)"); return false; } - t->kind = TYPE_VOID; + t->kind = TYPE_BUILTIN; + t->builtin = BUILTIN_VOID; } break; case EXPR_CALL: { CallExpr *c = &e->call; @@ -2829,7 +2834,8 @@ static Status types_expr(Typer *tr, Expression *e) { if (b->ret_expr) { *t = b->ret_expr->type; } else { - t->kind = TYPE_VOID; + t->kind = TYPE_BUILTIN; + t->builtin = BUILTIN_VOID; } } break; case EXPR_C: { @@ -2931,10 +2937,6 @@ static Status types_expr(Typer *tr, Expression *e) { assert(0); /* types_expr is what makes things UNARY_LEN */ break; case UNARY_TYPEOF: { - if (of->type.kind == TYPE_VOID) { - err_print(of->where, "This has type void, but you're trying to apply typeof to it."); - return false; - } if (type_is_builtin(&of->type, BUILTIN_VARARGS)) { err_print(of->where, "You can't apply typeof to varargs."); return false; @@ -3061,7 +3063,8 @@ static Status types_expr(Typer *tr, Expression *e) { switch (o) { case BINARY_SET: /* type of x = y is always void */ - t->kind = TYPE_VOID; + t->kind = TYPE_BUILTIN; + t->builtin = BUILTIN_VOID; break; case BINARY_LT: case BINARY_GT: @@ -3094,7 +3097,7 @@ static Status types_expr(Typer *tr, Expression *e) { o == BINARY_SET_SUB || o == BINARY_SET_MUL || o == BINARY_SET_DIV) { - t->kind = TYPE_VOID; /* actually, it's just void */ + t->kind = TYPE_BUILTIN; t->builtin = BUILTIN_VOID; /* actually, it's just void */ } break; @@ -3241,7 +3244,8 @@ static Status types_expr(Typer *tr, Expression *e) { /* allow access of slice pointer */ t->kind = TYPE_PTR; t->ptr = typer_calloc(tr, 1, sizeof *t->ptr); - t->ptr->kind = TYPE_VOID; + t->ptr->kind = TYPE_BUILTIN; + t->ptr->builtin = BUILTIN_VOID; t->ptr->flags = TYPE_IS_RESOLVED; break; } @@ -3396,7 +3400,7 @@ static Status types_block(Typer *tr, Block *b) { if (s->kind == STMT_EXPR && (s->flags & STMT_EXPR_NO_SEMICOLON)) { /* not voided */ Expression *e = s->expr; - if (e->type.kind == TYPE_VOID) { + if (type_is_builtin(&e->type, BUILTIN_VOID)) { if (!(e->kind == EXPR_BLOCK || e->kind == EXPR_IF || e->kind == EXPR_WHILE @@ -3427,6 +3431,7 @@ static Status types_block(Typer *tr, Block *b) { } static Status types_decl(Typer *tr, Declaration *d) { + Type *dtype = &d->type; if (d->flags & DECL_FOUND_TYPE) return true; bool success = true; @@ -3438,15 +3443,14 @@ static Status types_decl(Typer *tr, Declaration *d) { } if (d->flags & DECL_INFER) { - d->type.kind = TYPE_UNKNOWN; - d->type.flags = 0; + dtype->kind = TYPE_UNKNOWN; + dtype->flags = 0; return true; } typer_arr_add(tr, tr->in_decls, d); if (d->flags & DECL_ANNOTATES_TYPE) { /* type supplied */ - assert(d->type.kind != TYPE_VOID); /* there's no way to annotate void */ - if (!type_resolve(tr, &d->type, d->where)) { + if (!type_resolve(tr, dtype, d->where)) { success = false; goto ret; } @@ -3458,8 +3462,8 @@ static Status types_decl(Typer *tr, Declaration *d) { } assert(d->expr.type.flags & TYPE_IS_RESOLVED); if (d->flags & DECL_ANNOTATES_TYPE) { - if (!type_eq_implicit(&d->expr.type, &d->type)) { - char *decl_type = type_to_str(&d->type), + if (!type_eq_implicit(&d->expr.type, dtype)) { + char *decl_type = type_to_str(dtype), *expr_type = type_to_str(&d->expr.type); err_print(d->expr.where, "Declaration type %s does not match expression type %s.", decl_type, expr_type); free(decl_type); free(expr_type); @@ -3467,14 +3471,14 @@ static Status types_decl(Typer *tr, Declaration *d) { goto ret; } } else { - if (d->expr.type.kind == TYPE_VOID) { + if (type_is_void(&d->expr.type)) { /* e.g. x := (fn(){})(); */ err_print(d->expr.where, "Use of void value."); success = false; goto ret; } - d->type = d->expr.type; - d->type.flags &= (TypeFlags)~(TypeFlags)TYPE_IS_FLEXIBLE; /* x := 5; => x is not flexible */ + *dtype = d->expr.type; + dtype->flags &= (TypeFlags)~(TypeFlags)TYPE_IS_FLEXIBLE; /* x := 5; => x is not flexible */ } bool need_value = (d->flags & DECL_IS_CONST) || !tr->block || tr->block->kind == BLOCK_NMS; if (need_value) { @@ -3484,26 +3488,62 @@ static Status types_decl(Typer *tr, Declaration *d) { success = false; goto ret; } - copy_val(tr->allocr, &d->val, val, &d->type); + copy_val(tr->allocr, &d->val, val, dtype); d->flags |= DECL_FOUND_VAL; } } } + + size_t n_idents; n_idents = arr_len(d->idents); + + if (type_is_compileonly(dtype)) { + if (!(d->flags & DECL_IS_CONST)) { + char *s = type_to_str(dtype); + err_print(d->where, "Declarations with type %s must be constant.", s); + free(s); + success = false; + goto ret; + } + } - for (size_t i = 0; i < arr_len(d->idents); ++i) { - Type *t = d->type.kind == TYPE_TUPLE ? &d->type.tuple[i] : &d->type; - if (type_is_compileonly(&d->type)) { - if (!(d->flags & DECL_IS_CONST)) { - char *s = type_to_str(&d->type); - err_print(d->where, "Declarations with type %s must be constant.", s); - free(s); - success = false; - goto ret; - } + if (dtype->kind == TYPE_TUPLE) { + if (n_idents != arr_len(dtype->tuple)) { + err_print(d->where, "Expected to have %lu things declared in declaration, but got %lu.", (unsigned long)arr_len(dtype->tuple), (unsigned long)n_idents); + success = false; + goto ret; + } + } + if (dtype->kind == TYPE_UNKNOWN) { + if (!d->where.file->ctx->have_errored) /* don't do an error if we haven't already done one, because it might be because of that */ + err_print(d->where, "Can't determine type of declaration."); + success = false; + goto ret; + } + if (dtype->kind == TYPE_BUILTIN) { + if (dtype->builtin == BUILTIN_VARARGS && !(d->flags & DECL_IS_PARAM)) { + err_print(d->where, "Only parameters can be varargs."); + success = false; + goto ret; + } else if (dtype->builtin == BUILTIN_VOID) { + err_print(d->where, "The type of a declaration can't be void."); + success = false; + goto ret; } + } + if (d->flags & DECL_IS_CONST) { + if (dtype->kind == TYPE_PTR) { + err_print(d->where, "You can't have a constant pointer."); + success = false; + goto ret; + } + } + + + for (int i = 0, len = (int)n_idents; i < len; ++i) { + Type *t = decl_type_at_index(d, i); if (type_is_builtin(t, BUILTIN_TYPE)) { if (d->flags & DECL_HAS_EXPR) { - Value *val = d->type.kind == TYPE_TUPLE ? &d->val.tuple[i] : &d->val; + Value *val = decl_val_at_index(d, i); if (val->type->kind == TYPE_STRUCT && val->type->struc->params) { /* don't resolve it because it's not really complete */ } else { @@ -3522,34 +3562,7 @@ static Status types_decl(Typer *tr, Declaration *d) { t->fn.constness = NULL; } } - - size_t n_idents; n_idents = arr_len(d->idents); - if (d->type.kind == TYPE_TUPLE) { - if (n_idents != arr_len(d->type.tuple)) { - err_print(d->where, "Expected to have %lu things declared in declaration, but got %lu.", (unsigned long)arr_len(d->type.tuple), (unsigned long)n_idents); - success = false; - goto ret; - } - } - if (d->type.kind == TYPE_UNKNOWN) { - if (!d->where.file->ctx->have_errored) /* don't do an error if we haven't already done one, because it might be because of that */ - err_print(d->where, "Can't determine type of declaration."); - success = false; - goto ret; - } - if (type_is_builtin(&d->type, BUILTIN_VARARGS) && !(d->flags & DECL_IS_PARAM)) { - err_print(d->where, "Only parameters can be varargs."); - success = false; - goto ret; - } - if (d->flags & DECL_IS_CONST) { - if (d->type.kind == TYPE_PTR) { - err_print(d->where, "You can't have a constant pointer."); - success = false; - goto ret; - } - } - + if (d->flags & DECL_USE) { int idx = 0; if (arr_len(d->idents) > 1) { @@ -3585,8 +3598,8 @@ static Status types_decl(Typer *tr, Declaration *d) { d->flags |= DECL_FOUND_TYPE; if (!success) { /* use unknown type if we didn't get the type */ - d->type.flags = TYPE_IS_RESOLVED; - d->type.kind = TYPE_UNKNOWN; + dtype->flags = TYPE_IS_RESOLVED; + dtype->kind = TYPE_UNKNOWN; } arr_remove_lasta(tr->in_decls, tr->allocr); return success; @@ -3700,7 +3713,7 @@ static Status types_stmt(Typer *tr, Statement *s) { } r->referring_to = &tr->fn->body; if (r->flags & RET_HAS_EXPR) { - if (tr->fn->ret_type.kind == TYPE_VOID) { + if (type_is_void(&tr->fn->ret_type)) { err_print(s->where, "Return value in a void function."); return false; } @@ -3717,8 +3730,7 @@ static Status types_stmt(Typer *tr, Statement *s) { return false; } } else { - if (tr->fn->ret_type.kind != TYPE_VOID - && !tr->fn->ret_decls) { + if (type_is_void(&tr->fn->ret_type) && !tr->fn->ret_decls) { err_print(s->where, "No return value in non-void function."); return false; } diff --git a/types.h b/types.h index f3fff36..8ceaa32 100644 --- a/types.h +++ b/types.h @@ -303,6 +303,7 @@ typedef enum { KW_FLOAT, KW_F32, KW_F64, + KW_VOID, KW_TYPE, KW_NAMESPACE, KW_CHAR, @@ -326,8 +327,8 @@ static const char *const keywords[KW_COUNT] = { "if", "elif", "else", "while", "for", "return", "break", "continue", "defer", "fn", "as", "struct", "int", "i8", "i16", "i32", "i64", - "u8", "u16", "u32", "u64", "float", "f32", "f64", "Type", - "Namespace", "char", "bool", "true", "false", "nms", "use", + "u8", "u16", "u32", "u64", "float", "f32", "f64", "void", + "Type", "Namespace", "char", "bool", "true", "false", "nms", "use", "typeof", "sizeof", "alignof" }; @@ -398,7 +399,6 @@ typedef struct Tokenizer { typedef enum { TYPE_UNKNOWN, - TYPE_VOID, TYPE_BUILTIN, TYPE_FN, TYPE_TUPLE, @@ -426,7 +426,8 @@ typedef enum { BUILTIN_BOOL, BUILTIN_TYPE, BUILTIN_VARARGS, - BUILTIN_NMS + BUILTIN_NMS, + BUILTIN_VOID } BuiltinType; -- cgit v1.2.3