From db0367b2aa29de32d941cdea9af810b7eef0b74a Mon Sep 17 00:00:00 2001 From: Leo Tenenbaum Date: Sat, 30 Nov 2019 16:16:32 -0500 Subject: got rid of TYPE_USER!! --- cgen.c | 96 ++++++++++++++++++-------------------- copy.c | 31 ++++++------- decls_cgen.c | 2 +- eval.c | 112 +++++++++++++++++++-------------------------- instance_table.c | 14 +++--- main.c | 6 ++- parse.c | 137 ++++++++++++++++++++++++------------------------------- test.toc | 20 ++++++-- toc.c | 24 ---------- typedefs_cgen.c | 40 ++++++++-------- types.c | 111 ++++++++++++++------------------------------ types.h | 112 +++++++++++++++++++++------------------------ 12 files changed, 295 insertions(+), 410 deletions(-) diff --git a/cgen.c b/cgen.c index 44222b3..db44b76 100644 --- a/cgen.c +++ b/cgen.c @@ -217,6 +217,7 @@ static bool cgen_fn_is_direct(CGenerator *g, Declaration *d) { } static bool cgen_uses_ptr(Type *t) { + assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { case TYPE_TUPLE: case TYPE_STRUCT: @@ -230,9 +231,8 @@ static bool cgen_uses_ptr(Type *t) { case TYPE_UNKNOWN: case TYPE_TYPE: return false; - case TYPE_USER: - case TYPE_CALL: - return cgen_uses_ptr(type_user_underlying(t)); + case TYPE_EXPR: + break; } assert(0); return false; @@ -310,50 +310,43 @@ static bool cgen_type_pre(CGenerator *g, Type *t, Location where) { err_print(where, "Can't determine type."); return false; case TYPE_STRUCT: - cgen_write(g, "struct {"); - g->indent_lvl++; - cgen_nl(g); - arr_foreach(t->struc.fields, Field, f) { - if (!cgen_type_pre(g, f->type, where)) return false; - cgen_write(g, " "); - cgen_ident(g, f->name); - if (!cgen_type_post(g, f->type, where)) return false; - cgen_write(g, ";"); + cgen_write(g, "struct "); + if (t->struc->c.name) { + cgen_ident(g, t->struc->c.name); + } else if (t->struc->c.id) { + cgen_ident_id(g, t->struc->c.id); + } else { + #if 0 + /* TODO: DELME */ + cgen_write(g, "struct {"); + g->indent_lvl++; cgen_nl(g); + arr_foreach(t->struc.fields, Field, f) { + if (!cgen_type_pre(g, f->type, where)) return false; + cgen_write(g, " "); + cgen_ident(g, f->name); + if (!cgen_type_post(g, f->type, where)) return false; + cgen_write(g, ";"); + cgen_nl(g); + } + g->indent_lvl--; + cgen_write(g, "}"); + #endif + assert(0); } - g->indent_lvl--; - cgen_write(g, "}"); break; case TYPE_TUPLE: case TYPE_TYPE: + case TYPE_EXPR: /* We should never try to generate this type */ assert(0); return false; - case TYPE_USER: { - Type *this = t; - do { - Type *next = type_user_underlying(this); - if (next->kind == TYPE_STRUCT) { - /* use struct tag */ - cgen_write(g, "struct "); - t = this; - break; - } - this = next; - } while (this->kind == TYPE_USER); - - Declaration *d = t->user.decl; - int idx = t->user.index; - if (d->c.ids[idx]) - cgen_ident_id(g, d->c.ids[idx]); - else - cgen_ident(g, d->idents[idx]); - } break; } return true; } static bool cgen_type_post(CGenerator *g, Type *t, Location where) { + assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { case TYPE_PTR: cgen_write(g, ")"); @@ -415,9 +408,11 @@ static bool cgen_type_post(CGenerator *g, Type *t, Location where) { case TYPE_TUPLE: case TYPE_TYPE: case TYPE_SLICE: - case TYPE_USER: case TYPE_STRUCT: break; + case TYPE_EXPR: + assert(0); + break; } return true; } @@ -521,7 +516,6 @@ static bool cgen_set(CGenerator *g, Expression *set_expr, const char *set_str, E type = &to_expr->type; where = to_expr->where; } - type = type_inner(type); switch (type->kind) { case TYPE_BUILTIN: case TYPE_FN: @@ -578,9 +572,9 @@ static bool cgen_set(CGenerator *g, Expression *set_expr, const char *set_str, E if (!cgen_set_tuple(g, set_expr->tuple, NULL, NULL, to_expr)) return false; break; - case TYPE_USER: case TYPE_VOID: case TYPE_TYPE: + case TYPE_EXPR: assert(0); return false; } @@ -1227,7 +1221,7 @@ static bool cgen_expr(CGenerator *g, Expression *e) { case BINARY_DOT: { cgen_write(g, "("); cgen_expr(g, e->binary.lhs); - bool is_ptr = type_inner(&e->binary.lhs->type)->kind == TYPE_PTR; + bool is_ptr = e->binary.lhs->type.kind == TYPE_PTR; cgen_write(g, is_ptr ? "->" :"."); cgen_ident(g, e->binary.field->name); cgen_write(g, ")"); @@ -1452,6 +1446,7 @@ static bool cgen_block(CGenerator *g, Block *b, const char *ret_name, U16 flags) } static void cgen_zero_value(CGenerator *g, Type *t) { + assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { case TYPE_BUILTIN: cgen_write(g, "0"); @@ -1467,13 +1462,11 @@ static void cgen_zero_value(CGenerator *g, Type *t) { case TYPE_STRUCT: cgen_write(g, "{0}"); break; - case TYPE_USER: - cgen_zero_value(g, type_inner(t)); - break; case TYPE_TYPE: case TYPE_VOID: case TYPE_UNKNOWN: case TYPE_TUPLE: + case TYPE_EXPR: assert(0); break; } @@ -1578,6 +1571,7 @@ static bool cgen_fn(CGenerator *g, FnExpr *f, Location where, U64 instance, Valu } static bool cgen_val_ptr_pre(CGenerator *g, void *v, Type *t, Location where) { + assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { case TYPE_SLICE: { Slice *s = (Slice *)v; @@ -1603,10 +1597,6 @@ static bool cgen_val_ptr_pre(CGenerator *g, void *v, Type *t, Location where) { return false; } break; - case TYPE_USER: - if (!cgen_val_ptr_pre(g, v, type_inner(t), where)) - return false; - break; case TYPE_FN: case TYPE_TYPE: case TYPE_UNKNOWN: @@ -1616,12 +1606,16 @@ static bool cgen_val_ptr_pre(CGenerator *g, void *v, Type *t, Location where) { case TYPE_PTR: case TYPE_STRUCT: break; + case TYPE_EXPR: + assert(0); + return false; } return true; } /* generate a value from a pointer */ static bool cgen_val_ptr(CGenerator *g, void *v, Type *t, Location where) { + assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { case TYPE_TUPLE: case TYPE_VOID: @@ -1645,8 +1639,8 @@ static bool cgen_val_ptr(CGenerator *g, void *v, Type *t, Location where) { break; case TYPE_STRUCT: cgen_write(g, "{"); - arr_foreach(t->struc.fields, Field, f) { - if (f != t->struc.fields) + arr_foreach(t->struc->fields, Field, f) { + if (f != t->struc->fields) cgen_write(g, ", "); cgen_val_ptr(g, (char *)v + f->offset, f->type, where); } @@ -1674,10 +1668,9 @@ static bool cgen_val_ptr(CGenerator *g, void *v, Type *t, Location where) { case BUILTIN_BOOL: cgen_write(g, "%s", *(bool *)v ? "true" : "false"); break; } break; - case TYPE_USER: - if (!cgen_val_ptr(g, v, type_inner(t), where)) - return false; - break; + case TYPE_EXPR: + assert(0); + return false; } return true; } @@ -1902,6 +1895,7 @@ static bool cgen_defs_block(CGenerator *g, Block *b) { static bool cgen_file(CGenerator *g, ParsedFile *f) { g->block = NULL; + g->fn = NULL; g->file = f; /* TODO: to improve compile times, don't include stdlib.h diff --git a/copy.c b/copy.c index 3062115..f691d18 100644 --- a/copy.c +++ b/copy.c @@ -11,6 +11,7 @@ static void copy_block(Copier *c, Block *out, Block *in); static void copy_type(Copier *c, Type *out, Type *in); static void copy_val(Allocator *a, Value *out, Value *in, Type *t) { + assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { case TYPE_BUILTIN: case TYPE_FN: @@ -35,10 +36,6 @@ static void copy_val(Allocator *a, Value *out, Value *in, Type *t) { out->struc = allocr_malloc(a, bytes); memcpy(out->struc, in->struc, bytes); } break; - case TYPE_USER: - case TYPE_CALL: - copy_val(a, out, in, type_user_underlying(t)); - break; case TYPE_TYPE: /* copy_type(c, out->type = allocr_malloc(c->allocr, sizeof *out->type), in->type); */ /* @@ -51,6 +48,8 @@ static void copy_val(Allocator *a, Value *out, Value *in, Type *t) { */ *out = *in; break; + case TYPE_EXPR: + assert(0); } } @@ -64,16 +63,10 @@ static void copy_type(Copier *c, Type *out, Type *in) { case TYPE_TYPE: case TYPE_VOID: case TYPE_UNKNOWN: - case TYPE_USER: break; - case TYPE_CALL: { - copy_type(c, out->call.calling = allocr_malloc(c->allocr, sizeof *out->call.calling), - in->call.calling); - out->call.args = NULL; - arr_foreach(in->call.args, Expression, arg) { - copy_expr(c, arr_add(&out->call.args), arg); - } - } break; + case TYPE_EXPR: + copy_expr(c, out->expr = allocr_malloc(c->allocr, sizeof *out->expr), in->expr); + break; case TYPE_FN: { size_t ntypes = arr_len(in->fn.types); out->fn.types = NULL; @@ -107,12 +100,14 @@ static void copy_type(Copier *c, Type *out, Type *in) { copy_type(c, out->slice, in->slice); break; case TYPE_STRUCT: { - size_t nfields = arr_len(in->struc.fields); - out->struc.fields = NULL; - arr_set_lena(&out->struc.fields, nfields, c->allocr); + out->struc = allocr_malloc(c->allocr, sizeof *out->struc); + *out->struc = *in->struc; + size_t nfields = arr_len(in->struc->fields); + out->struc->fields = NULL; + arr_set_lena(&out->struc->fields, nfields, c->allocr); for (size_t i = 0; i < nfields; i++) { - Field *fout = &out->struc.fields[i]; - Field *fin = &in->struc.fields[i]; + Field *fout = &out->struc->fields[i]; + Field *fin = &in->struc->fields[i]; *fout = *fin; copy_type(c, fout->type, fin->type); } diff --git a/decls_cgen.c b/decls_cgen.c index f07b17e..40087f5 100644 --- a/decls_cgen.c +++ b/decls_cgen.c @@ -93,7 +93,7 @@ static bool cgen_decls_decl(CGenerator *g, Declaration *d) { cgen_write(g, "{"); cgen_nl(g); g->indent_lvl++; - arr_foreach(val->type->struc.fields, Field, f) { + arr_foreach(val->type->struc->fields, Field, f) { if (!cgen_type_pre(g, f->type, d->where)) return false; cgen_write(g, " "); cgen_ident(g, f->name); diff --git a/eval.c b/eval.c index e06dd9e..4150527 100644 --- a/eval.c +++ b/eval.c @@ -50,6 +50,7 @@ static size_t compiler_sizeof_builtin(BuiltinType b) { } static size_t compiler_alignof(Type *t) { + assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { case TYPE_BUILTIN: return compiler_sizeof_builtin(t->builtin); @@ -70,19 +71,17 @@ static size_t compiler_alignof(Type *t) { return sizeof(size_t); case TYPE_TYPE: return sizeof(Type *); - case TYPE_USER: - case TYPE_CALL: - return compiler_alignof(type_user_underlying(t)); case TYPE_STRUCT: { /* assume the align of a struct is (at most) the greatest align out of its children's */ size_t align = 1; - arr_foreach(t->struc.fields, Field, f) { + arr_foreach(t->struc->fields, Field, f) { size_t falign = compiler_alignof(f->type); if (falign > align) align = falign; } return align; } case TYPE_UNKNOWN: + case TYPE_EXPR: break; } assert(0); @@ -90,12 +89,11 @@ static size_t compiler_alignof(Type *t) { } /* finds offsets and size */ -/* OPTIM: don't do this once per Type, but once per struct */ static void eval_struct_find_offsets(Type *t) { assert(t->kind == TYPE_STRUCT); - if (!(t->flags & TYPE_STRUCT_FOUND_OFFSETS)) { + if (!(t->struc->flags & STRUCT_DEF_FOUND_OFFSETS)) { size_t bytes = 0; - arr_foreach(t->struc.fields, Field, f) { + arr_foreach(t->struc->fields, Field, f) { size_t falign = compiler_alignof(f->type); /* align */ bytes += ((falign - bytes) % falign + falign) % falign; /* = -bytes mod falign */ @@ -107,13 +105,14 @@ static void eval_struct_find_offsets(Type *t) { /* final align */ size_t align = compiler_alignof(t); bytes += ((align - bytes) % align + align) % align; /* = -bytes mod align */ - t->struc.size = bytes; - t->flags |= TYPE_STRUCT_FOUND_OFFSETS; + t->struc->size = bytes; + t->struc->flags |= STRUCT_DEF_FOUND_OFFSETS; } } /* size of a type at compile time */ static size_t compiler_sizeof(Type *t) { + assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { case TYPE_BUILTIN: return compiler_sizeof_builtin(t->builtin); @@ -129,16 +128,15 @@ static size_t compiler_sizeof(Type *t) { return sizeof(Slice); case TYPE_TYPE: return sizeof(Type *); - case TYPE_USER: - case TYPE_CALL: - return compiler_sizeof(type_user_underlying(t)); case TYPE_STRUCT: { eval_struct_find_offsets(t); - return t->struc.size; + return t->struc->size; } break; case TYPE_VOID: case TYPE_UNKNOWN: return 0; + case TYPE_EXPR: + break; } assert(0); return 0; @@ -163,6 +161,7 @@ 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; @@ -171,11 +170,10 @@ static bool val_truthiness(Value *v, Type *t) { case TYPE_FN: return v->fn != NULL; case TYPE_ARR: return t->arr.n > 0; case TYPE_SLICE: return v->slice.n > 0; - case TYPE_CALL: - case TYPE_USER: case TYPE_TYPE: case TYPE_TUPLE: case TYPE_STRUCT: + case TYPE_EXPR: break; } assert(0); @@ -238,6 +236,7 @@ static void u64_to_val(Value *v, BuiltinType v_type, U64 x) { /* rerturns a pointer to the underlying data of v, e.g. an I64 * if t is the builtin BUILTIN_I64 */ static void *val_get_ptr(Value *v, Type *t) { + assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { case TYPE_PTR: case TYPE_BUILTIN: @@ -248,19 +247,18 @@ static void *val_get_ptr(Value *v, Type *t) { case TYPE_SLICE: case TYPE_TYPE: return v; - case TYPE_USER: - case TYPE_CALL: - return val_get_ptr(v, type_user_underlying(t)); case TYPE_ARR: return v->arr; case TYPE_STRUCT: return v->struc; + case TYPE_EXPR: break; } assert(0); return NULL; } 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)"); @@ -323,14 +321,10 @@ static void fprint_val_ptr(FILE *f, void *p, Type *t) { case TYPE_TYPE: fprint_type(f, *(Type **)p); break; - case TYPE_USER: - case TYPE_CALL: - fprint_val_ptr(f, p, type_user_underlying(t)); - break; case TYPE_STRUCT: fprintf(f, "["); /* TODO: change? when struct initializers are added */ - arr_foreach(t->struc.fields, Field, fi) { - if (fi != t->struc.fields) + arr_foreach(t->struc->fields, Field, fi) { + if (fi != t->struc->fields) fprintf(f, ", "); fprint_ident(f, fi->name); fprintf(f, ": "); @@ -338,7 +332,9 @@ static void fprint_val_ptr(FILE *f, void *p, Type *t) { } fprintf(f, "]"); break; + case TYPE_EXPR: break; } + assert(0); } static void fprint_val(FILE *f, Value v, Type *t) { @@ -354,6 +350,7 @@ static void fprint_val(FILE *f, Value v, Type *t) { } static void *val_ptr_to_free(Value *v, Type *t) { + assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { case TYPE_BUILTIN: case TYPE_FN: @@ -361,17 +358,17 @@ static void *val_ptr_to_free(Value *v, Type *t) { case TYPE_SLICE: case TYPE_VOID: case TYPE_UNKNOWN: - case TYPE_TYPE: return NULL; + case TYPE_TYPE: + return v->type->was_expr; case TYPE_ARR: return v->arr; case TYPE_TUPLE: return v->tuple; case TYPE_STRUCT: return v->struc; - case TYPE_USER: - case TYPE_CALL: - return val_ptr_to_free(v, type_user_underlying(t)); + case TYPE_EXPR: + break; } assert(0); return NULL; } @@ -454,24 +451,21 @@ static void val_builtin_cast(Value *vin, BuiltinType from, Value *vout, BuiltinT } static void val_cast(Value *vin, Type *from, Value *vout, Type *to) { + assert(from->flags & TYPE_IS_RESOLVED); + assert(to->flags & TYPE_IS_RESOLVED); + if (to->kind == TYPE_BUILTIN && to->builtin == BUILTIN_BOOL) { vout->boolv = val_truthiness(vin, from); return; } - if (from->kind == TYPE_USER || to->kind == TYPE_USER - || from->kind == TYPE_CALL || to->kind == TYPE_CALL) { - *vout = *vin; - return; - } switch (from->kind) { case TYPE_VOID: case TYPE_UNKNOWN: case TYPE_TUPLE: - case TYPE_USER: - case TYPE_CALL: case TYPE_TYPE: case TYPE_STRUCT: + case TYPE_EXPR: assert(0); break; case TYPE_BUILTIN: switch (to->kind) { @@ -491,8 +485,7 @@ static void val_cast(Value *vin, Type *from, Value *vout, Type *to) { default: assert(0); break; } break; - case TYPE_USER: - case TYPE_CALL: + case TYPE_EXPR: case TYPE_STRUCT: case TYPE_SLICE: case TYPE_VOID: @@ -514,8 +507,6 @@ static void val_cast(Value *vin, Type *from, Value *vout, Type *to) { case TYPE_FN: vout->fn = vin->fn; break; - case TYPE_USER: - case TYPE_CALL: case TYPE_SLICE: case TYPE_UNKNOWN: case TYPE_TUPLE: @@ -524,6 +515,7 @@ static void val_cast(Value *vin, Type *from, Value *vout, Type *to) { case TYPE_BUILTIN: case TYPE_TYPE: case TYPE_STRUCT: + case TYPE_EXPR: assert(0); break; } break; @@ -549,12 +541,11 @@ static void val_cast(Value *vin, Type *from, Value *vout, Type *to) { case TYPE_FN: vout->fn = vin->ptr; break; - case TYPE_USER: - case TYPE_CALL: case TYPE_SLICE: case TYPE_UNKNOWN: case TYPE_TUPLE: case TYPE_VOID: + case TYPE_EXPR: case TYPE_TYPE: case TYPE_STRUCT: assert(0); @@ -570,8 +561,7 @@ static void val_cast(Value *vin, Type *from, Value *vout, Type *to) { case TYPE_ARR: vout->arr = vin->arr; break; - case TYPE_USER: - case TYPE_CALL: + case TYPE_EXPR: case TYPE_SLICE: case TYPE_FN: case TYPE_UNKNOWN: @@ -594,13 +584,12 @@ static void val_cast(Value *vin, Type *from, Value *vout, Type *to) { case TYPE_SLICE: vout->slice = vin->slice; break; - case TYPE_USER: - case TYPE_CALL: case TYPE_FN: case TYPE_UNKNOWN: case TYPE_TUPLE: case TYPE_VOID: case TYPE_BUILTIN: + case TYPE_EXPR: case TYPE_TYPE: case TYPE_STRUCT: assert(0); break; @@ -611,6 +600,7 @@ static void val_cast(Value *vin, Type *from, Value *vout, Type *to) { /* type is the underlying type, not the pointer type. */ static void eval_deref(Value *v, void *ptr, Type *type) { + assert(type->flags & TYPE_IS_RESOLVED); switch (type->kind) { case TYPE_PTR: v->ptr = *(void **)ptr; break; case TYPE_ARR: v->arr = ptr; break; /* when we have a pointer to an array, it points directly to the data in that array. */ @@ -639,18 +629,16 @@ static void eval_deref(Value *v, void *ptr, Type *type) { case TYPE_TYPE: v->type = *(Type **)ptr; break; - case TYPE_USER: - case TYPE_CALL: - eval_deref(v, ptr, type_user_underlying(type)); - break; case TYPE_VOID: case TYPE_UNKNOWN: + case TYPE_EXPR: assert(0); break; } } /* inverse of eval_deref */ static void eval_deref_set(void *set, Value *to, Type *type) { + assert(type->flags & TYPE_IS_RESOLVED); switch (type->kind) { case TYPE_PTR: *(void **)set = to->ptr; break; case TYPE_ARR: memcpy(set, to->arr, compiler_sizeof(type)); break; /* TODO: test this */ @@ -679,12 +667,9 @@ static void eval_deref_set(void *set, Value *to, Type *type) { case TYPE_TYPE: *(Type **)set = to->type; break; - case TYPE_USER: - case TYPE_CALL: - eval_deref_set(set, to, type_user_underlying(type)); - break; case TYPE_VOID: case TYPE_UNKNOWN: + case TYPE_EXPR: assert(0); break; } @@ -738,10 +723,10 @@ static bool eval_expr_ptr_at_index(Evaluator *ev, Expression *e, void **ptr, Typ } static void *eval_ptr_to_struct_field(Evaluator *ev, Expression *dot_expr) { - Type *struct_type = type_inner(&dot_expr->binary.lhs->type); + Type *struct_type = &dot_expr->binary.lhs->type; bool is_ptr = struct_type->kind == TYPE_PTR; if (is_ptr) { - struct_type = type_inner(struct_type->ptr); + struct_type = struct_type->ptr; } eval_struct_find_offsets(struct_type); @@ -991,7 +976,6 @@ static void eval_numerical_bin_op(Value lhs, Type *lhs_type, BinaryOp op, Value static Value val_zero(Type *t) { Value val = {0}; - t = type_inner(t); switch (t->kind) { case TYPE_STRUCT: val.struc = err_calloc(1, compiler_sizeof(t)); @@ -1194,7 +1178,7 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) { Value from, to; Value stepval; stepval.i64 = 1; - Type i64t; + Type i64t = {0}; i64t.flags = TYPE_IS_RESOLVED; i64t.kind = TYPE_BUILTIN; i64t.builtin = BUILTIN_I64; @@ -1228,7 +1212,7 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) { Value lhs = x; Value rhs = to; assert(ea->type.kind == TYPE_BUILTIN); - Type boolt; + Type boolt = {0}; boolt.flags = TYPE_IS_RESOLVED; boolt.kind = TYPE_BUILTIN; boolt.builtin = BUILTIN_BOOL; @@ -1345,15 +1329,11 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) { } int index = ident_index_in_decl(e->ident, d); assert(index != -1); + *v = *decl_val_at_index(d, index); if (e->type.kind == TYPE_TYPE) { - /* set v to a user type, not the underlying type */ - v->type = evalr_malloc(ev, sizeof *v->type); /* TODO: fix this (free eventually) */ - v->type->flags = TYPE_IS_RESOLVED; - v->type->kind = TYPE_USER; - v->type->user.decl = d; - v->type->user.index = index; - } else { - *v = *decl_val_at_index(d, index); + /* make sure was_expr is set */ + /* NOTE: this will be freed (see val_ptr_to_free) */ + v->type->was_expr = err_malloc(sizeof *v->type->was_expr); } } else { char *s = ident_to_str(e->ident); diff --git a/instance_table.c b/instance_table.c index 63879ce..d370a2a 100644 --- a/instance_table.c +++ b/instance_table.c @@ -64,6 +64,7 @@ static void fprint_val(FILE *f, Value v, Type *t); /* DELME */ static void fprint_type(FILE *out, Type *t); /* !! */ /* Note that for these value hashing functions, values of different types may collide */ 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; @@ -97,9 +98,6 @@ static U64 val_ptr_hash(void *v, Type *t) { } case TYPE_PTR: return (U64)*(void **)v; case TYPE_TYPE: return (U64)*(Type **)v; - case TYPE_USER: - case TYPE_CALL: - return val_ptr_hash(v, type_inner(t)); case TYPE_ARR: { U32 x = 1; U64 hash = 0; @@ -124,12 +122,13 @@ static U64 val_ptr_hash(void *v, Type *t) { case TYPE_STRUCT: { U32 x = 1; U64 hash = 0; - arr_foreach(t->struc.fields, Field, f) { + arr_foreach(t->struc->fields, Field, f) { hash += (U64)x * val_ptr_hash((char *)v + f->offset, f->type); x = rand_u32(x); } return hash; } + case TYPE_EXPR: break; } assert(0); return 0; @@ -140,6 +139,7 @@ static U64 val_hash(Value v, Type *t) { } static bool val_ptr_eq(void *u, void *v, Type *t) { + assert(t->flags & TYPE_IS_RESOLVED); switch (t->kind) { case TYPE_BUILTIN: switch (t->builtin) { @@ -163,9 +163,6 @@ static bool val_ptr_eq(void *u, void *v, Type *t) { return false; case TYPE_FN: return *(FnExpr **)u == *(FnExpr **)v; - case TYPE_USER: - case TYPE_CALL: - return val_ptr_eq(u, v, type_inner(t)); case TYPE_PTR: return *(void **)u == *(void **)v; case TYPE_TYPE: @@ -205,11 +202,12 @@ static bool val_ptr_eq(void *u, void *v, Type *t) { return true; } case TYPE_STRUCT: - arr_foreach(t->struc.fields, Field, f) { + arr_foreach(t->struc->fields, Field, f) { if (!val_ptr_eq((char *)u + f->offset, (char *)v + f->offset, f->type)) return false; } return true; + case TYPE_EXPR: break; } assert(0); return false; diff --git a/main.c b/main.c index 1866e5f..e07c049 100644 --- a/main.c +++ b/main.c @@ -1,7 +1,9 @@ /* TODO: -struct parameters -- struct type parameters +get rid of TYPE_USER +- don't do automatic type conversion + +functions returning Types test ArrInt @= Arr(int); packages diff --git a/parse.c b/parse.c index df47ee9..68e1652 100644 --- a/parse.c +++ b/parse.c @@ -167,6 +167,10 @@ static Keyword builtin_type_to_kw(BuiltinType t) { /* returns the number of characters written, not including the null character */ static size_t type_to_str_(Type *t, char *buffer, size_t bufsize) { + if ((t->flags & TYPE_IS_RESOLVED) && t->was_expr) { + /* TODO: improve this (see also: case TYPE_EXPR) */ + return str_copy(buffer, bufsize, ""); + } switch (t->kind) { case TYPE_VOID: return str_copy(buffer, bufsize, "void"); @@ -206,7 +210,7 @@ static size_t type_to_str_(Type *t, char *buffer, size_t bufsize) { } case TYPE_STRUCT: { size_t written = str_copy(buffer, bufsize, "struct { "); - arr_foreach(t->struc.fields, Field, f) { + arr_foreach(t->struc->fields, Field, f) { written += type_to_str_(f->type, buffer + written, bufsize - written); written += str_copy(buffer + written, bufsize - written, "; "); } @@ -248,23 +252,9 @@ static size_t type_to_str_(Type *t, char *buffer, size_t bufsize) { } case TYPE_TYPE: return str_copy(buffer, bufsize, ""); - case TYPE_USER: { - char *ident_str = ident_to_str((t->flags & TYPE_IS_RESOLVED) - ? t->user.decl->idents[t->user.index] - : t->user.ident); - size_t ret = str_copy(buffer, bufsize, ident_str); - free(ident_str); - return ret; - } - case TYPE_CALL: { - size_t written = 0; - written += type_to_str_(t->call.calling, buffer + written, bufsize - written); - written += str_copy(buffer + written, bufsize - written, "("); - /* TODO: show values if resolved */ - written += str_copy(buffer + written, bufsize - written, "..."); - written += str_copy(buffer + written, bufsize - written, ")"); - return written; - } + case TYPE_EXPR: + /* TODO: improve this... we're gonna need expr_to_str ): */ + return str_copy(buffer, bufsize, ""); } assert(0); @@ -390,6 +380,43 @@ static Token *expr_find_end(Parser *p, ExprEndFlags flags, bool *is_vbs) { } } +/* parses, e.g. "(3, 5, foo)" */ +static bool parse_args(Parser *p, Argument **args) { + Tokenizer *t = p->tokr; + Token *start = t->token; + assert(token_is_kw(start, KW_LPAREN)); + *args = NULL; + t->token++; /* move past ( */ + if (!token_is_kw(t->token, KW_RPAREN)) { + /* non-empty arg list */ + while (1) { + if (t->token->kind == TOKEN_EOF) { + tokr_err(t, "Expected argument list to continue."); + info_print(start->where, "This is where the argument list starts."); + return false; + } + Argument *arg = parser_arr_add(p, args); + arg->where = t->token->where; + /* named arguments */ + if (t->token->kind == TOKEN_IDENT && token_is_kw(t->token + 1, KW_EQ)) { + arg->name = t->token->ident; + t->token += 2; + } else { + arg->name = NULL; + } + if (!parse_expr(p, &arg->val, expr_find_end(p, EXPR_CAN_END_WITH_COMMA, NULL))) { + return false; + } + if (token_is_kw(t->token, KW_RPAREN)) + break; + assert(token_is_kw(t->token, KW_COMMA)); + t->token++; /* move past , */ + } + } + t->token++; /* move past ) */ + return true; +} + static bool parse_type(Parser *p, Type *type) { Tokenizer *t = p->tokr; type->where = t->token->where; @@ -525,20 +552,14 @@ static bool parse_type(Parser *p, Type *type) { case KW_STRUCT: /* struct */ type->kind = TYPE_STRUCT; - type->struc.fields = NULL; + type->struc = parser_malloc(p, sizeof *type->struc); + type->struc->flags = 0; + /* help cgen out */ + type->struc->c.name = NULL; + type->struc->c.id = 0; + type->struc->fields = NULL; t->token++; - if (token_is_kw(t->token, KW_LPAREN)) { - /* struct parameters */ - t->token++; - if (token_is_kw(t->token, KW_RPAREN)) { - t->token--; - err_print(t->token->where, "Expected parameters to struct, but found none."); - return false; - } - - if (!parse_decl_list(p, &type->struc.params, DECL_END_RPAREN_COMMA)) - return false; - } else if (!token_is_kw(t->token, KW_LBRACE)) { + if (!token_is_kw(t->token, KW_LBRACE)) { err_print(t->token->where, "Expected { or ( to follow struct."); return false; } @@ -561,7 +582,7 @@ static bool parse_type(Parser *p, Type *type) { long idx = 0; arr_foreach(field_decl.idents, Identifier, fident) { Type *ftype = field_decl.type.kind == TYPE_TUPLE ? &field_decl.type.tuple[idx] : &field_decl.type; - Field *f = parser_arr_add(p, &type->struc.fields); + Field *f = parser_arr_add(p, &type->struc->fields); f->name = *fident; f->type = parser_malloc(p, sizeof *f->type); *f->type = *ftype; @@ -576,15 +597,14 @@ static bool parse_type(Parser *p, Type *type) { return false; } break; - case TOKEN_IDENT: - /* user-defined type */ - type->kind = TYPE_USER; - type->user.ident = t->token->ident; - t->token++; - break; default: - tokr_err(t, "Unrecognized type."); - return false; + /* TYPE_EXPR */ + if (parse_expr(p, type->expr = parser_new_expr(p), expr_find_end(p, 0, NULL))) { + type->kind = TYPE_EXPR; + } else { + tokr_err(t, "Unrecognized type."); + return false; + } } return true; @@ -882,43 +902,6 @@ static bool parse_fn_expr(Parser *p, FnExpr *f) { return ret; } -/* parses, e.g. "(3, 5, foo)" */ -static bool parse_args(Parser *p, Argument **args) { - Tokenizer *t = p->tokr; - Token *start = t->token; - assert(token_is_kw(start, KW_LPAREN)); - *args = NULL; - t->token++; /* move past ( */ - if (!token_is_kw(t->token, KW_RPAREN)) { - /* non-empty arg list */ - while (1) { - if (t->token->kind == TOKEN_EOF) { - tokr_err(t, "Expected argument list to continue."); - info_print(start->where, "This is where the argument list starts."); - return false; - } - Argument *arg = parser_arr_add(p, args); - arg->where = t->token->where; - /* named arguments */ - if (t->token->kind == TOKEN_IDENT && token_is_kw(t->token + 1, KW_EQ)) { - arg->name = t->token->ident; - t->token += 2; - } else { - arg->name = NULL; - } - if (!parse_expr(p, &arg->val, expr_find_end(p, EXPR_CAN_END_WITH_COMMA, NULL))) { - return false; - } - if (token_is_kw(t->token, KW_RPAREN)) - break; - assert(token_is_kw(t->token, KW_COMMA)); - t->token++; /* move past , */ - } - } - t->token++; /* move past ) */ - return true; -} - static void fprint_expr(FILE *out, Expression *e); diff --git a/test.toc b/test.toc index 8693412..0ee769f 100644 --- a/test.toc +++ b/test.toc @@ -7,11 +7,21 @@ // "); // }; -Foo @= struct(x @ int) { - a: [x]float; -}; +// f @= fn(x @ int) Type { +// struct { +// a: [x]float; +// } +// }; + + main @= fn() { - f : Foo(13); -// puti(f.a[12]); + +t @= struct { + A: int; + b: int; +}; +x : t; + y := x; + }; \ No newline at end of file diff --git a/toc.c b/toc.c index cd931ed..203fddd 100644 --- a/toc.c +++ b/toc.c @@ -12,30 +12,6 @@ #include #include "types.h" - -/* can be used on TYPE_USERs and TYPE_CALLs */ -static Type *type_user_underlying(Type *t) { - assert(t->flags & TYPE_IS_RESOLVED); - switch (t->kind) { - case TYPE_USER: { - Declaration *d = t->user.decl; - assert(d->flags & DECL_FOUND_VAL); - return (d->type.kind == TYPE_TUPLE ? d->val.tuple[t->user.index] : d->val).type; - } - case TYPE_CALL: - return &t->call.instance->type; - default: assert(0); - } -} - -static Type *type_inner(Type *t) { - assert(t->flags & TYPE_IS_RESOLVED); - while (t->kind == TYPE_USER) { - t = type_user_underlying(t); - } - return t; -} - #include "allocator.c" #include "arr.c" #include "location.c" diff --git a/typedefs_cgen.c b/typedefs_cgen.c index 422e6cd..71b1c5f 100644 --- a/typedefs_cgen.c +++ b/typedefs_cgen.c @@ -36,35 +36,33 @@ static bool typedefs_decl(CGenerator *g, Declaration *d) { d->c.ids = allocr_calloc(g->allocr, arr_len(d->idents), sizeof *d->c.ids); /* generate typedef */ IdentID id = 0; - if (g->block != NULL || g->fn != NULL) id = d->c.ids[idx] = g->ident_counter++; + if (g->block != NULL || g->fn != NULL) + id = d->c.ids[idx] = g->ident_counter++; if (val->type->kind == TYPE_STRUCT) { /* we'll actually define the struct later; here we can just declare it */ cgen_write(g, "struct "); - if (g->block == NULL) { - /* we can refer to this by its name */ - cgen_ident(g, i); - } else { - /* we need to use an ID ): */ + if (id) { cgen_ident_id(g, id); + val->type->struc->c.id = id; + } else { + cgen_ident(g, i); + val->type->struc->c.name = i; } cgen_write(g, ";"); - cgen_nl(g); - continue; - } - cgen_write(g, "typedef "); - if (!cgen_type_pre(g, val->type, d->where)) return false; - cgen_write(g, " "); - if (g->block == NULL && g->fn == NULL) { - /* we can refer to this by its name */ - cgen_ident(g, i); } else { - /* we need to use an ID ): */ - cgen_ident_id(g, id); - } - if (val->type->kind != TYPE_STRUCT) { - if (!cgen_type_post(g, val->type, d->where)) return false; + cgen_write(g, "typedef "); + if (!cgen_type_pre(g, val->type, d->where)) return false; + cgen_write(g, " "); + if (id) { + cgen_ident_id(g, id); + } else { + cgen_ident(g, i); + } + if (val->type->kind != TYPE_STRUCT) { + if (!cgen_type_post(g, val->type, d->where)) return false; + } + cgen_write(g, ";"); } - cgen_write(g, ";"); cgen_nl(g); } } diff --git a/types.c b/types.c index f5b8e5e..5dac5e7 100644 --- a/types.c +++ b/types.c @@ -28,11 +28,7 @@ static bool type_eq(Type *a, Type *b) { assert(a->flags & TYPE_IS_RESOLVED); assert(b->flags & TYPE_IS_RESOLVED); - if ((a->kind == TYPE_USER || a->kind == TYPE_CALL) && a->user.is_alias) - return type_eq(type_user_underlying(a), b); - if ((b->kind == TYPE_USER || a->kind == TYPE_CALL) && b->user.is_alias) - return type_eq(a, type_user_underlying(b)); - + /* TODO: deal with was_expr */ if (a->kind != b->kind) return false; if (b->flags & TYPE_IS_FLEXIBLE) { @@ -55,10 +51,6 @@ static bool type_eq(Type *a, Type *b) { case TYPE_VOID: return true; case TYPE_UNKNOWN: assert(0); return false; case TYPE_TYPE: return true; - case TYPE_USER: - return a->user.decl == b->user.decl && a->user.index == b->user.index; - case TYPE_CALL: - return a->call.instance == b->call.instance; case TYPE_BUILTIN: return a->builtin == b->builtin; case TYPE_STRUCT: return false; @@ -97,6 +89,8 @@ static bool type_eq(Type *a, Type *b) { return type_eq(a->slice, b->slice); case TYPE_PTR: return type_eq(a->ptr, b->ptr); + case TYPE_EXPR: + break; } assert(0); return false; @@ -433,6 +427,7 @@ static bool type_of_ident(Typer *tr, Location where, Identifier i, Type *t) { static bool type_resolve(Typer *tr, Type *t, Location where) { Evaluator *ev = tr->evalr; if (t->flags & TYPE_IS_RESOLVED) return true; + t->was_expr = NULL; switch (t->kind) { case TYPE_ARR: { /* it's an array */ @@ -488,62 +483,39 @@ static bool type_resolve(Typer *tr, Type *t, Location where) { if (!type_resolve(tr, t->slice, where)) return false; break; - case TYPE_USER: { - t->flags |= TYPE_IS_RESOLVED; /* pre-resolve type to avoid infinite recursion */ - /* find declaration */ - Identifier ident = t->user.ident; - IdentDecl *idecl = ident_decl(ident); - if (!idecl) { - char *s = ident_to_str(ident); - err_print(where, "Use of undeclared type %s.", s); - free(s); - return false; - } - assert(idecl->kind == IDECL_DECL); - Declaration *decl = idecl->decl; - /* now, type the declaration (in case we are using it before its declaration) */ - if (!types_decl(tr, decl)) - return false; - int index = ident_index_in_decl(ident, idecl->decl); - /* make sure it's actually a type */ - if (decl_type_at_index(decl, index)->kind != TYPE_TYPE) { - char *s = ident_to_str(ident); - err_print(where, "Use of non-type identifier %s as type.", s); - info_print(decl->where, "%s is declared here.", s); - free(s); - return false; - } - /* finally, set decl and index */ - t->user.decl = decl; - t->user.index = index; - if (decl->flags & DECL_IS_PARAM) { - t->user.is_alias = true; /* type parameters are aliases */ - } - } break; case TYPE_STRUCT: - arr_foreach(t->struc.fields, Field, f) { + arr_foreach(t->struc->fields, Field, f) { if (!type_resolve(tr, f->type, where)) return false; } break; + case TYPE_EXPR: { + Value typeval; + if (!types_expr(tr, t->expr)) + return false; + t->was_expr = t->expr; + if (!eval_expr(tr->evalr, t->expr, &typeval)) + return false; + *t = *typeval.type; + } break; case TYPE_UNKNOWN: case TYPE_VOID: case TYPE_TYPE: case TYPE_BUILTIN: break; } + assert(t->kind != TYPE_EXPR); t->flags |= TYPE_IS_RESOLVED; return true; } 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_TYPE: - case TYPE_USER: - case TYPE_CALL: case TYPE_STRUCT: return false; case TYPE_FN: @@ -552,6 +524,8 @@ static bool type_can_be_truthy(Type *t) { case TYPE_PTR: case TYPE_SLICE: return true; + case TYPE_EXPR: + break; } assert(0); return false; @@ -564,20 +538,11 @@ typedef enum { } Status; static Status type_cast_status(Type *from, Type *to) { + assert(from->flags & TYPE_IS_RESOLVED); + assert(to->flags & TYPE_IS_RESOLVED); + if (to->kind == TYPE_UNKNOWN) return STATUS_NONE; - if (from->kind == TYPE_USER || from->kind == TYPE_CALL) { - if (from->user.is_alias) { - return type_cast_status(type_user_underlying(from), to); - } - return type_eq(type_user_underlying(from), to) ? STATUS_NONE : STATUS_ERR; - } - if (to->kind == TYPE_USER || to->kind == TYPE_CALL) { - if (to->user.is_alias) { - return type_cast_status(from, type_user_underlying(to)); - } - return type_eq(from, type_user_underlying(to)) ? STATUS_NONE : STATUS_ERR; - } switch (from->kind) { case TYPE_UNKNOWN: return STATUS_NONE; case TYPE_STRUCT: @@ -607,8 +572,9 @@ static Status type_cast_status(Type *from, Type *to) { case TYPE_STRUCT: case TYPE_ARR: case TYPE_VOID: - case TYPE_USER: case TYPE_CALL: /* handled above */ return STATUS_ERR; + case TYPE_EXPR: + assert(0); } break; case BUILTIN_F32: @@ -644,8 +610,7 @@ static Status type_cast_status(Type *from, Type *to) { if (to->kind == TYPE_PTR && type_eq(from->slice, to->ptr)) return STATUS_NONE; return STATUS_ERR; - case TYPE_USER: - case TYPE_CALL: + case TYPE_EXPR: break; } assert(0); @@ -739,6 +704,7 @@ static bool types_expr(Typer *tr, Expression *e) { if (e->flags & EXPR_FOUND_TYPE) return true; Type *t = &e->type; t->flags = 0; + t->was_expr = NULL; t->kind = TYPE_UNKNOWN; /* default to unknown type (in the case of an error) */ e->flags |= EXPR_FOUND_TYPE; /* even if failed, pretend we found the type */ switch (e->kind) { @@ -873,7 +839,7 @@ static bool types_expr(Typer *tr, Expression *e) { return false; } } - Type ptr_type; + Type ptr_type = {0}; if (uses_ptr) { ptr_type.flags = TYPE_IS_RESOLVED; ptr_type.kind = TYPE_PTR; @@ -992,6 +958,7 @@ static bool types_expr(Typer *tr, Expression *e) { } else { next_type->kind = TYPE_VOID; next_type->flags = TYPE_IS_RESOLVED; + next_type->was_expr = NULL; } if (!type_eq(curr_type, next_type)) { char *currstr = type_to_str(curr_type); @@ -1184,11 +1151,12 @@ static bool types_expr(Typer *tr, Expression *e) { copy_fn_expr(&cop, &fn_copy, fn, true); fn = &fn_copy; - Type table_index_type; + Type table_index_type = {0}; table_index_type.flags = TYPE_IS_RESOLVED; table_index_type.kind = TYPE_TUPLE; table_index_type.tuple = NULL; Type *u64t = arr_add(&table_index_type.tuple); + u64t->was_expr = NULL; u64t->flags = TYPE_IS_RESOLVED; u64t->kind = TYPE_BUILTIN; u64t->builtin = BUILTIN_U64; @@ -1447,19 +1415,6 @@ static bool types_expr(Typer *tr, Expression *e) { return false; } } else { - while (rhs_type->kind == TYPE_USER) { - if (rhs_type->user.is_alias) - rhs_type = type_user_underlying(rhs_type); - else - break; - } - while (lhs_type->kind == TYPE_USER) { - if (lhs_type->user.is_alias) - lhs_type = type_user_underlying(lhs_type); - else - break; - } - /* numerical binary ops */ if (lhs_type->kind == TYPE_BUILTIN && type_eq(lhs_type, rhs_type)) { /* int + int, etc. */ @@ -1562,16 +1517,15 @@ static bool types_expr(Typer *tr, Expression *e) { break; case BINARY_DOT: { if (!types_expr(tr, lhs)) return false; - Type *struct_type = type_inner(lhs_type); + Type *struct_type = lhs_type; if (struct_type->kind == TYPE_PTR) struct_type = struct_type->ptr; - struct_type = type_inner(struct_type); if (struct_type->kind == TYPE_STRUCT) { bool is_field = false; if (rhs->kind == EXPR_IDENT) { /* maybe accessing a field? */ - arr_foreach(struct_type->struc.fields, Field, f) { + arr_foreach(struct_type->struc->fields, Field, f) { if (f->name == rhs->ident) { is_field = true; *t = *f->type; @@ -1600,7 +1554,7 @@ static bool types_expr(Typer *tr, Expression *e) { } if (!eval_expr(tr->evalr, rhs, &field_name)) return false; - arr_foreach(struct_type->struc.fields, Field, f) { + arr_foreach(struct_type->struc->fields, Field, f) { if (ident_eq_str(f->name, field_name.slice.data)) { is_field = true; *t = *f->type; @@ -1818,6 +1772,7 @@ static bool types_decl(Typer *tr, Declaration *d) { if (!success) { /* use unknown type if we didn't get the type */ d->type.flags = TYPE_IS_RESOLVED; + d->type.was_expr = NULL; d->type.kind = TYPE_UNKNOWN; tr->evalr->enabled = false; /* disable evaluator completely so that it doesn't accidentally try to access this declaration */ } diff --git a/types.h b/types.h index 599ca67..3d17f0a 100644 --- a/types.h +++ b/types.h @@ -68,25 +68,32 @@ typedef struct Page { MaxAlign data[]; } Page; -typedef struct { +typedef struct Allocator { Page *first; Page *last; } Allocator; -typedef struct { +typedef struct ArrBlock { void *data; size_t n; /* number of things in this block so far */ void *last; /* last one of them */ } ArrBlock; -typedef struct { +typedef struct BlockArr { size_t item_sz; int lg_block_sz; /* NOTE: dynamic array tends to over-allocate, so we're using our own */ ArrBlock *blocks; } BlockArr; -typedef struct { +typedef struct HashTable { + void *data; + bool *occupied; + U64 n; + U64 cap; +} HashTable; + +typedef struct Slice { I64 n; void *data; } Slice; @@ -122,7 +129,7 @@ typedef enum { IDECL_EXPR } IdentDeclKind; -typedef struct { +typedef struct IdentDecl { union { struct Declaration *decl; struct Expression *expr; /* for example, this identifier is declared in an each expression */ @@ -152,7 +159,7 @@ typedef struct IdentTree { typedef IdentTree *Identifier; -typedef struct { +typedef struct Identifiers { BlockArr trees; IdentTree *root; } Identifiers; @@ -242,7 +249,7 @@ typedef enum { NUM_LITERAL_FLOAT } NumLiteralKind; -typedef struct { +typedef struct NumLiteral { NumLiteralKind kind; union { UInteger intval; @@ -250,13 +257,13 @@ typedef struct { }; } NumLiteral; -typedef struct { +typedef struct StrLiteral { char *str; size_t len; } StrLiteral; /* NOTE: Location is typedef'd in util/err.c */ -typedef struct { +typedef struct Token { TokenKind kind; Location where; union { @@ -269,7 +276,7 @@ typedef struct { }; } Token; -typedef struct { +typedef struct Tokenizer { Allocator *allocr; Token *tokens; char *s; /* string being parsed */ @@ -290,9 +297,8 @@ typedef enum { TYPE_PTR, TYPE_SLICE, TYPE_TYPE, - TYPE_USER, /* user-defined type */ - TYPE_STRUCT, - TYPE_CALL /* "calling" a type function, e.g. Arr(int) */ + TYPE_EXPR, /* just use this expression as the type. this kind of type doesn't exist after resolving. */ + TYPE_STRUCT } TypeKind; typedef enum { @@ -311,17 +317,12 @@ typedef enum { } BuiltinType; /* field of a struct */ -typedef struct { +typedef struct Field { Identifier name; struct Type *type; size_t offset; /* offset during compile time */ } Field; -enum { - TYPE_IS_FLEXIBLE = 0x01, - TYPE_IS_RESOLVED = 0x02, - TYPE_STRUCT_FOUND_OFFSETS = 0x04, -}; typedef U8 Constness; @@ -329,15 +330,34 @@ typedef U8 Constness; #define CONSTNESS_SEMI ((Constness)1) #define CONSTNESS_YES ((Constness)2) -typedef struct { +typedef struct FnType { struct Type *types; /* dynamic array [0] = ret_type, [1:] = param_types */ Constness *constness; /* [i] = constness of param #i. iff no parameters are constant, this is NULL. don't use it as a dynamic array, because eventually it might not be. */ } FnType; +enum { + STRUCT_DEF_FOUND_OFFSETS = 0x00, +}; + +typedef struct { + Field *fields; + U16 flags; + size_t size; /* size of this struct during compile time */ + struct { + Identifier name; + IdentID id; + } c; +} StructDef; + +enum { + TYPE_IS_FLEXIBLE = 0x01, + TYPE_IS_RESOLVED = 0x02, +}; typedef struct Type { Location where; TypeKind kind; uint16_t flags; + struct Expression *was_expr; /* if non-NULL, indicates that this type used to be an expression (TYPE_EXPR) */ union { BuiltinType builtin; FnType fn; @@ -351,27 +371,8 @@ typedef struct Type { } arr; struct Type *ptr; struct Type *slice; - struct { - union { - struct { - struct Declaration *decl; - int index; /* index in decl */ - }; - Identifier ident; - }; - bool is_alias; /* is this an alias for a type, rather than a new type */ - } user; - struct { - Field *fields; - size_t size; /* size of this struct during compile time */ - struct Declaration *params; /* parameters to struct, NULL if this struct has no parameters */ - - } struc; - struct { - struct Type *calling; - struct Expression *args; - struct Instance *instance; /* instance of struct. set during type resolution. */ - } call; /* "calling" a function returning a type */ + StructDef *struc; /* it's a pointer so that multiple Types can reference the same struct definition */ + struct Expression *expr; }; } Type; @@ -448,7 +449,7 @@ typedef enum { BINARY_DOT } BinaryOp; -typedef struct { +typedef struct CallExpr { struct Expression *fn; union { struct Argument *args; @@ -460,7 +461,7 @@ typedef struct { } c; } CallExpr; -typedef struct { +typedef struct IfExpr { struct Expression *cond; /* NULL = this is an else */ struct Expression *next_elif; /* next elif/else of this statement */ struct { @@ -469,7 +470,7 @@ typedef struct { Block body; } IfExpr; -typedef struct { +typedef struct WhileExpr { struct Expression *cond; struct { IdentID id; @@ -506,13 +507,6 @@ typedef struct EachExpr { }; } EachExpr; -typedef struct { - void *data; - bool *occupied; /* OPTIM: use bits instead of bytes for bools */ - U64 n; - U64 cap; -} HashTable; - typedef struct FnExpr { struct Declaration *params; /* declarations of the parameters to this function */ struct Declaration *ret_decls; /* array of decls, if this has named return values. otherwise, NULL */ @@ -540,17 +534,17 @@ typedef struct Instance { } c; } Instance; -typedef struct { +typedef struct CastExpr { Type type; struct Expression *expr; } CastExpr; -typedef struct { +typedef struct NewExpr { Type type; struct Expression *n; /* e.g. for new(int, 5) */ } NewExpr; -typedef struct { +typedef struct SliceExpr { struct Expression *of; struct Expression *from; struct Expression *to; @@ -661,7 +655,7 @@ typedef enum { enum { RET_HAS_EXPR = 0x01, }; -typedef struct { +typedef struct Return { uint16_t flags; Expression expr; } Return; @@ -681,11 +675,11 @@ typedef struct Statement { }; } Statement; -typedef struct { +typedef struct ParsedFile { Statement *stmts; } ParsedFile; -typedef struct { +typedef struct Parser { Tokenizer *tokr; Allocator *allocr; Block *block; /* which block are we in? NULL = file scope */ @@ -697,7 +691,7 @@ typedef enum { DECL_END_LBRACE_COMMA } DeclEndKind; -typedef struct { +typedef struct Evaluator { Allocator *allocr; struct Typer *typer; bool returning; @@ -715,7 +709,7 @@ typedef struct Typer { FnExpr *fn; /* the function we're currently parsing. */ } Typer; -typedef struct { +typedef struct CGenerator { Allocator *allocr; FILE *outc; IdentID ident_counter; -- cgit v1.2.3