diff options
| -rw-r--r-- | allocator.c | 35 | ||||
| -rw-r--r-- | eval.c | 161 | ||||
| -rw-r--r-- | identifiers.c | 1 | ||||
| -rw-r--r-- | main.c | 2 | ||||
| -rw-r--r-- | scope.c | 51 | ||||
| -rw-r--r-- | test.toc | 5 | ||||
| -rw-r--r-- | toc.c | 1 | ||||
| -rw-r--r-- | types.c | 105 | ||||
| -rw-r--r-- | types.h | 48 |
9 files changed, 296 insertions, 113 deletions
diff --git a/allocator.c b/allocator.c index 4dc05c8..793c6cc 100644 --- a/allocator.c +++ b/allocator.c @@ -1,22 +1,29 @@ - +/* #define NO_ALLOCATOR 1 */ /* number of bytes a page hold, not including the header */ -#define PAGE_SIZE (16384 - sizeof(Page)) +#define PAGE_BYTES (16384 - sizeof(Page)) +#define PAGE_MAX_ALIGNS (PAGE_BYTES / sizeof(max_align_t)) static void allocr_create(Allocator *a) { a->first = a->last = NULL; } static void *allocr_malloc(Allocator *a, size_t bytes) { + assert(bytes); +#if NO_ALLOCATOR + (void)a; + return err_malloc(bytes); +#else /* position in this page to return */ - size_t pos = PAGE_SIZE; + size_t pos = PAGE_MAX_ALIGNS; if (a->last) - pos = (a->last->used + sizeof(max_align_t) - 1) / sizeof(max_align_t); + pos = a->last->used; + size_t max_aligns = (bytes + sizeof(max_align_t) - 1) / sizeof(max_align_t); - if (pos * sizeof(max_align_t) + bytes > PAGE_SIZE) { + if (pos + max_aligns > PAGE_MAX_ALIGNS) { /* make a new page for this data */ - Page *page = err_malloc(sizeof *page + (bytes > PAGE_SIZE ? bytes : PAGE_SIZE)); + Page *page = err_malloc(sizeof *page + (bytes > PAGE_BYTES ? bytes : PAGE_BYTES)); page->next = NULL; - page->used = bytes; + page->used = max_aligns; if (a->last) a->last->next = page; else @@ -24,24 +31,36 @@ static void *allocr_malloc(Allocator *a, size_t bytes) { a->last = page; return page->data; } else { - a->last->used += bytes; + a->last->used += max_aligns; return &a->last->data[pos]; } +#endif } static void *allocr_calloc(Allocator *a, size_t n, size_t sz) { +#if NO_ALLOCATOR + (void)a; + return err_calloc(n, sz); +#else /* OPTIM: use calloc */ size_t bytes = n * sz; void *data = allocr_malloc(a, bytes); memset(data, 0, bytes); return data; +#endif } /* OPTIM */ static void *allocr_realloc(Allocator *a, void *data, size_t old_size, size_t new_size) { +#if NO_ALLOCATOR + (void)a; + (void)old_size; + return err_realloc(data, new_size); +#else void *ret = allocr_malloc(a, new_size); memcpy(ret, data, old_size); return ret; +#endif } static void allocr_free_all(Allocator *a) { @@ -1,9 +1,11 @@ static bool eval_block(Evaluator *ev, Block *b, Value *v); -static bool type_resolve(Typer *tr, Type *t); +static bool eval_expr(Evaluator *ev, Expression *e, Value *v); +static bool type_resolve(Evaluator *ev, Type *t); +static bool block_enter(Block *b, Statement *stmts); +static void block_exit(Block *b, Statement *stmts); -static void evalr_create(Evaluator *ev, Typer *tr) { +static void evalr_create(Evaluator *ev) { allocr_create(&ev->allocr); - ev->typer = tr; } static void evalr_free(Evaluator *ev) { @@ -318,8 +320,102 @@ 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) { - /* TODO */ + switch (type->kind) { + case TYPE_PTR: v->ptr = *(void **)ptr; break; + case TYPE_ARR: v->arr = *(void **)ptr; break; + case TYPE_FN: v->fn = *(FnExpr **)ptr; break; + case TYPE_TUPLE: v->tuple = *(Value **)ptr; break; + case TYPE_BUILTIN: + switch (type->builtin) { + case BUILTIN_I8: v->i8 = *(I8 *)ptr; break; + case BUILTIN_U8: v->u8 = *(U8 *)ptr; break; + case BUILTIN_I16: v->i16 = *(I16 *)ptr; break; + case BUILTIN_U16: v->u16 = *(U16 *)ptr; break; + case BUILTIN_I32: v->i32 = *(I32 *)ptr; break; + case BUILTIN_U32: v->u32 = *(U32 *)ptr; break; + case BUILTIN_I64: v->i64 = *(I64 *)ptr; break; + case BUILTIN_U64: v->u64 = *(U64 *)ptr; break; + case BUILTIN_F32: v->f32 = *(F32 *)ptr; break; + case BUILTIN_F64: v->f64 = *(F64 *)ptr; break; + case BUILTIN_CHAR: v->charv = *(char *)ptr; break; + case BUILTIN_BOOL: v->boolv = *(bool *)ptr; break; + case BUILTIN_TYPE_COUNT: assert(0); break; + } + break; + case TYPE_VOID: + case TYPE_UNKNOWN: + assert(0); + break; + } +} +/* inverse of eval_deref */ +static void eval_deref_set(void *set, Value *to, Type *type) { + switch (type->kind) { + case TYPE_PTR: *(void **)set = to->ptr; break; + case TYPE_ARR: *(void **)set = to->arr; break; + case TYPE_FN: *(FnExpr **)set = to->fn; break; + case TYPE_TUPLE: *(Value **)set = to->tuple; break; + case TYPE_BUILTIN: + switch (type->builtin) { + case BUILTIN_I8: *(I8 *)set = to->i8; break; + case BUILTIN_U8: *(U8 *)set = to->u8; break; + case BUILTIN_I16: *(I16 *)set = to->i16; break; + case BUILTIN_U16: *(U16 *)set = to->u16; break; + case BUILTIN_I32: *(I32 *)set = to->i32; break; + case BUILTIN_U32: *(U32 *)set = to->u32; break; + case BUILTIN_I64: *(I64 *)set = to->i64; break; + case BUILTIN_U64: *(U64 *)set = to->u64; break; + case BUILTIN_F32: *(F32 *)set = to->f32; break; + case BUILTIN_F64: *(F64 *)set = to->f64; break; + case BUILTIN_CHAR: *(char *)set = to->charv; break; + case BUILTIN_BOOL: *(bool *)set = to->boolv; break; + case BUILTIN_TYPE_COUNT: assert(0); break; + } + break; + case TYPE_VOID: + case TYPE_UNKNOWN: + assert(0); + break; + } +} + +static bool eval_set(Evaluator *ev, Expression *set, Value *to) { + switch (set->kind) { + case EXPR_IDENT: { + IdentDecl *id = ident_decl(set->ident); + if (!(id->flags & IDECL_FLAG_HAS_VAL)) { + err_print(set->where, "Cannot set value of run time variable at compile time."); + return false; + } + id->val = *to; + } break; + case EXPR_UNARY_OP: + switch (set->unary.op) { + case UNARY_DEREF: { + Value ptr; + if (!eval_expr(ev, set->unary.of, &ptr)) return false; + eval_deref_set(ptr.ptr, to, &set->type); + } break; + default: assert(0); break; + } + break; + case EXPR_BINARY_OP: + switch (set->binary.op) { + case BINARY_AT_INDEX: + /* TODO */ + break; + default: break; + } + case EXPR_TUPLE: + /* TODO */ + break; + default: + assert(0); + break; + } + return true; } static bool eval_expr(Evaluator *ev, Expression *e, Value *v) { @@ -364,6 +460,7 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) { #define eval_binary_op_nums_only(op) \ val_cast(&lhs, &e->binary.lhs->type, &lhs, &e->type); \ val_cast(&rhs, &e->binary.rhs->type, &rhs, &e->type); \ + assert(e->type.kind == TYPE_BUILTIN); \ switch (builtin) { \ eval_binary_op_nums(builtin, op); \ default: assert(0); break; \ @@ -386,12 +483,13 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) { eval_binary_bool_op_one(f32, F32, op); \ eval_binary_bool_op_one(f64, F64, op); -#define eval_binary_bool_op_nums_only(op) \ +#define eval_binary_bool_op_nums_only(op) \ val_cast(&lhs, &e->binary.lhs->type, &lhs, &e->type); \ val_cast(&rhs, &e->binary.rhs->type, &rhs, &e->type); \ + assert(e->type.kind == TYPE_BUILTIN); \ switch (builtin) { \ eval_binary_bool_op_nums(builtin, op); \ - default: assert(0); break; \ + default: assert(0); break; \ } @@ -401,6 +499,9 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) { Value of; if (!eval_expr(ev, e->unary.of, &of)) return false; switch (e->unary.op) { + case UNARY_DEREF: + eval_deref(v, of.ptr, &e->type); + break; case UNARY_MINUS: { BuiltinType builtin = e->type.builtin; assert(e->type.kind == TYPE_BUILTIN); @@ -409,15 +510,23 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) { case UNARY_NOT: v->boolv = !val_truthiness(v, &e->unary.of->type); break; + case UNARY_DEL: + if (e->unary.of->type.kind == TYPE_PTR) + free(of.ptr); + else { + assert(e->unary.of->type.kind == TYPE_ARR); + free(of.arr); + } + break; } } break; case EXPR_BINARY_OP: { Value lhs, rhs; /* TODO(eventually): short-circuiting */ - if (!eval_expr(ev, e->binary.lhs, &lhs)) return false; + if (e->binary.op != BINARY_SET) + if (!eval_expr(ev, e->binary.lhs, &lhs)) return false; if (!eval_expr(ev, e->binary.rhs, &rhs)) return false; BuiltinType builtin = e->type.builtin; - assert(e->type.kind == TYPE_BUILTIN); switch (e->binary.op) { case BINARY_ADD: eval_binary_op_nums_only(+); break; @@ -439,6 +548,9 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) { eval_binary_bool_op_nums_only(==); break; case BINARY_NE: eval_binary_bool_op_nums_only(!=); break; + case BINARY_SET: + if (!eval_set(ev, e->binary.lhs, &rhs)) return false; + break; case BINARY_AT_INDEX: { U64 index; U64 arr_sz = e->binary.lhs->type.arr.n; @@ -524,7 +636,9 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) { case EXPR_IDENT: { IdentDecl *idecl = ident_decl(e->ident); Declaration *d = idecl->decl; - if (d->flags & DECL_FLAG_CONST) { + if (idecl->flags & IDECL_FLAG_HAS_VAL) { + *v = idecl->val; + } else if (d->flags & DECL_FLAG_CONST) { if (!(d->flags & DECL_FLAG_FOUND_VAL)) { if (!eval_expr(ev, &d->expr, &d->val)) return false; d->flags |= DECL_FLAG_FOUND_VAL; @@ -567,22 +681,38 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) { } } break; case EXPR_NEW: - /* it's not strictly necessary to do the if here */ - if (!type_resolve(ev->typer, &e->new.type)) + if (!type_resolve(ev, &e->new.type)) return false; + /* it's not strictly necessary to do the if here */ if (e->new.type.kind == TYPE_ARR) - v->arr = err_malloc(compiler_sizeof(&e->new.type)); + v->arr = err_calloc(1, compiler_sizeof(&e->new.type)); else - v->ptr = err_malloc(compiler_sizeof(&e->new.type)); + v->ptr = err_calloc(1, compiler_sizeof(&e->new.type)); + break; } return true; } +static bool eval_decl(Evaluator *ev, Declaration *d) { + arr_foreach(d->idents, Identifier, i) { + IdentDecl *id = ident_decl(*i); + id->flags |= IDECL_FLAG_HAS_VAL; + assert(id->decl == d); + if (d->flags & DECL_FLAG_HAS_EXPR) { + if (!eval_expr(ev, &d->expr, &id->val)) + return false; + } else { + id->val = (Value){0}; + } + } + return true; +} + static bool eval_stmt(Evaluator *ev, Statement *stmt) { switch (stmt->kind) { case STMT_DECL: - /* TODO */ + if (!eval_decl(ev, &stmt->decl)) return false; break; case STMT_EXPR: { Value unused; @@ -597,6 +727,7 @@ static bool eval_stmt(Evaluator *ev, Statement *stmt) { } static bool eval_block(Evaluator *ev, Block *b, Value *v) { + block_enter(b, b->stmts); arr_foreach(b->stmts, Statement, stmt) { if (!eval_stmt(ev, stmt)) return false; @@ -605,5 +736,7 @@ static bool eval_block(Evaluator *ev, Block *b, Value *v) { if (!eval_expr(ev, b->ret_expr, v)) return false; } + block_exit(b, b->stmts); + return true; } diff --git a/identifiers.c b/identifiers.c index d7ad02d..b59e67f 100644 --- a/identifiers.c +++ b/identifiers.c @@ -148,6 +148,7 @@ static void ident_add_decl(Identifier i, struct Declaration *d, struct Block *b) IdentDecl *id_decl = arr_add(&i->decls); id_decl->decl = d; id_decl->scope = b; + id_decl->flags = 0; } static IdentDecl *ident_decl(Identifier i) { @@ -72,7 +72,7 @@ int main(int argc, char **argv) { block_enter(NULL, f.stmts); /* enter global scope */ Typer tr; Evaluator ev; - evalr_create(&ev, &tr); + evalr_create(&ev); typer_create(&tr, &ev); if (!types_file(&tr, &f)) { err_fprint(TEXT_IMPORTANT("Errors occured while determining types.\n")); @@ -0,0 +1,51 @@ +static bool add_ident_decls(Block *b, Declaration *d) { + bool ret = true; + arr_foreach(d->idents, Identifier, ident) { + IdentDecl **decls = &(*ident)->decls; + if (arr_len(*decls)) { + /* check that it hasn't been declared in this block */ + IdentDecl *prev = arr_last(*decls); + if (prev->scope == b) { + err_print(d->where, "Re-declaration of identifier in the same block."); + info_print(prev->decl->where, "Previous declaration was here."); + ret = false; + continue; + } + } + ident_add_decl(*ident, d, b); + } + return ret; +} + +static void remove_ident_decls(Block *b, Declaration *d) { + arr_foreach(d->idents, Identifier, ident) { + IdentTree *id_info = *ident; + IdentDecl **decls = &id_info->decls; + IdentDecl *last_decl = arr_last(*decls); + if (last_decl && last_decl->scope == b) { + arr_remove_last(decls); /* remove that declaration */ + } + } +} + +/* pass NULL for block for global scope */ +static bool block_enter(Block *b, Statement *stmts) { + bool ret = true; + arr_foreach(stmts, Statement, stmt) { + if (stmt->kind == STMT_DECL) { + Declaration *decl = &stmt->decl; + if (!add_ident_decls(b, decl)) + ret = false; + } + } + return ret; +} + +static void block_exit(Block *b, Statement *stmts) { + arr_foreach(stmts, Statement, stmt) { + if (stmt->kind == STMT_DECL) { + Declaration *decl = &stmt->decl; + remove_ident_decls(b, decl); + } + } +} @@ -1,6 +1,7 @@ main @= fn() { // foo @= true; // N, M @= 8 * if foo { 8 } else { 3} - 3, 894; - foo @= new[3]int; - x : [foo[0]]int; + // foo @= new[3]int; + // x : [foo[0]]int; + y : [{x := (439 as &u8); *x = 7; *x }]f32; };
\ No newline at end of file @@ -21,6 +21,7 @@ #include "identifiers.c" #include "tokenizer.c" #include "parse.c" +#include "scope.c" #include "eval.c" #include "types.c" @@ -2,7 +2,7 @@ static bool types_stmt(Typer *tr, Statement *s); static bool types_decl(Typer *tr, Declaration *d); static bool types_expr(Typer *tr, Expression *e); static bool types_block(Typer *tr, Block *b); -static bool type_resolve(Typer *tr, Type *t); +static bool types_type(Typer *tr, Type *t); static inline void *typer_malloc(Typer *tr, size_t bytes) { return allocr_malloc(&tr->allocr, bytes); @@ -18,59 +18,6 @@ static inline void *typer_arr_add_(Typer *tr, void **arr, size_t sz) { #define typer_arr_add(tr, a) typer_arr_add_(tr, (void **)(a), sizeof **(a)) -static bool add_ident_decls(Block *b, Declaration *d) { - bool ret = true; - arr_foreach(d->idents, Identifier, ident) { - IdentDecl **decls = &(*ident)->decls; - if (arr_len(*decls)) { - /* check that it hasn't been declared in this block */ - IdentDecl *prev = arr_last(*decls); - if (prev->scope == b) { - err_print(d->where, "Re-declaration of identifier in the same block."); - info_print(prev->decl->where, "Previous declaration was here."); - ret = false; - continue; - } - } - ident_add_decl(*ident, d, b); - } - return ret; -} - -static void remove_ident_decls(Block *b, Declaration *d) { - arr_foreach(d->idents, Identifier, ident) { - IdentTree *id_info = *ident; - IdentDecl **decls = &id_info->decls; - IdentDecl *last_decl = arr_last(*decls); - if (last_decl && last_decl->scope == b) { - arr_remove_last(decls); /* remove that declaration */ - } - } -} - -/* pass NULL for block for global scope */ -static bool block_enter(Block *b, Statement *stmts) { - bool ret = true; - arr_foreach(stmts, Statement, stmt) { - if (stmt->kind == STMT_DECL) { - Declaration *decl = &stmt->decl; - if (!add_ident_decls(b, decl)) - ret = false; - } - } - return ret; -} - -static void block_exit(Block *b, Statement *stmts) { - /* OPTIM: figure out some way of not re-iterating over everything */ - arr_foreach(stmts, Statement, stmt) { - if (stmt->kind == STMT_DECL) { - Declaration *decl = &stmt->decl; - remove_ident_decls(b, decl); - } - } -} - static bool type_eq(Type *a, Type *b) { if (a->kind == TYPE_UNKNOWN || b->kind == TYPE_UNKNOWN) return true; /* allow things such as 3 + #C("5") */ @@ -177,12 +124,12 @@ static bool type_of_fn(Typer *tr, FnExpr *f, Type *t) { t->kind = TYPE_FN; t->fn.types = NULL; Type *ret_type = typer_arr_add(tr, &t->fn.types); - if (!type_resolve(tr, &f->ret_type)) + if (!types_type(tr, &f->ret_type) || !type_resolve(tr->evalr, &f->ret_type)) return false; *ret_type = f->ret_type; arr_foreach(f->params, Declaration, decl) { if (!types_decl(tr, decl)) return false; - if (!type_resolve(tr, &decl->type)) + if (!types_type(tr, &decl->type) || !type_resolve(tr->evalr, &decl->type)) return false; for (size_t i = 0; i < arr_len(decl->idents); i++) { Type *param_type = typer_arr_add(tr, &t->fn.types); @@ -271,15 +218,13 @@ static bool type_of_ident(Typer *tr, Location where, Identifier i, Type *t) { } /* fixes the type (replaces [5+3]int with [8]int, etc.) */ -static bool type_resolve(Typer *tr, Type *t) { +static bool type_resolve(Evaluator *ev, Type *t) { if (t->flags & TYPE_FLAG_RESOLVED) return true; switch (t->kind) { case TYPE_ARR: { /* it's an array */ - if (!type_resolve(tr, t->arr.of)) return false; /* resolve inner type */ Value val; Expression *n_expr = t->arr.n_expr; - if (!types_expr(tr, n_expr)) return false; if (n_expr->type.kind == TYPE_UNKNOWN) { err_print(n_expr->where, "Cannot determine type of array size at compile time."); return false; @@ -290,7 +235,7 @@ static bool type_resolve(Typer *tr, Type *t) { free(s); return false; } - if (!eval_expr(tr->evalr, n_expr, &val)) + if (!eval_expr(ev, n_expr, &val)) return false; U64 size; @@ -308,18 +253,18 @@ static bool type_resolve(Typer *tr, Type *t) { } break; case TYPE_FN: arr_foreach(t->fn.types, Type, child_type) { - if (!type_resolve(tr, child_type)) + if (!type_resolve(ev, child_type)) return false; } break; case TYPE_TUPLE: arr_foreach(t->tuple, Type, child_type) { - if (!type_resolve(tr, child_type)) + if (!type_resolve(ev, child_type)) return false; } break; case TYPE_PTR: - if (!type_resolve(tr, t->ptr.of)) + if (!type_resolve(ev, t->ptr.of)) return false; break; case TYPE_UNKNOWN: @@ -331,6 +276,32 @@ static bool type_resolve(Typer *tr, Type *t) { return true; } +static bool types_type(Typer *tr, Type *t) { + switch (t->kind) { + case TYPE_ARR: + if (!types_expr(tr, t->arr.n_expr)) return false; + if (!types_type(tr, t->arr.of)) return false; + break; + case TYPE_PTR: + if (!types_type(tr, t->ptr.of)) return false; + break; + case TYPE_TUPLE: { + arr_foreach(t->tuple, Type, x) + if (!types_type(tr, x)) + return false; + } break; + case TYPE_FN: + arr_foreach(t->fn.types, Type, x) + if (!types_type(tr, x)) + return false; + break; + case TYPE_UNKNOWN: + case TYPE_BUILTIN: + case TYPE_VOID: + break; + } + return true; +} static bool type_can_be_truthy(Type *t) { switch (t->kind) { @@ -542,7 +513,7 @@ static bool types_expr(Typer *tr, Expression *e) { CastExpr *c = &e->cast; if (!types_expr(tr, c->expr)) return false; - if (!type_resolve(tr, &c->type)) + if (!types_type(tr, &c->type) || !type_resolve(tr->evalr, &c->type)) return false; Status status = type_cast_status(&c->expr->type, &c->type); if (status != STATUS_NONE) { @@ -561,6 +532,9 @@ static bool types_expr(Typer *tr, Expression *e) { } break; case EXPR_NEW: t->kind = TYPE_PTR; + /* type the type, but don't resolve it (e.g. fn(x:int)int{(new [x]int)[0]}) */ + if (!types_type(tr, &e->new.type)) + return false; if (e->new.type.kind == TYPE_ARR) { *t = e->new.type; } else { @@ -828,6 +802,7 @@ static bool types_expr(Typer *tr, Expression *e) { free(s); return false; } + *t = *of_type->ptr.of; break; case UNARY_DEL: @@ -992,7 +967,7 @@ static bool types_decl(Typer *tr, Declaration *d) { if (d->flags & DECL_FLAG_ANNOTATES_TYPE) { /* type supplied */ assert(d->type.kind != TYPE_VOID); /* there's no way to annotate void */ - if (!type_resolve(tr, &d->type)) { + if (!types_type(tr, &d->type) || !type_resolve(tr->evalr, &d->type)) { success = false; goto ret; } @@ -34,7 +34,7 @@ typedef struct { typedef struct Page { struct Page *next; - size_t used; + size_t used; /* number of max_align_t's used, not bytes */ max_align_t data[]; } Page; @@ -56,9 +56,31 @@ typedef struct { ArrBlock *blocks; } BlockArr; +typedef union Value { + U8 u8; + U16 u16; + U32 u32; + U64 u64; + I8 i8; + I16 i16; + I32 i32; + I64 i64; + bool boolv; + char charv; + float f32; + double f64; + struct FnExpr *fn; + void *arr; + void *ptr; + union Value *tuple; +} Value; + +#define IDECL_FLAG_HAS_VAL 0x01 typedef struct { - struct Block *scope; /* NULL for file scope */ struct Declaration *decl; + struct Block *scope; /* NULL for file scope */ + Value val; + uint16_t flags; } IdentDecl; /* @@ -328,7 +350,7 @@ typedef struct { Block body; } WhileExpr; -typedef struct { +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 */ Type ret_type; @@ -386,25 +408,6 @@ typedef struct Argument { Expression val; } Argument; -typedef union Value { - U8 u8; - U16 u16; - U32 u32; - U64 u64; - I8 i8; - I16 i16; - I32 i32; - I64 i64; - bool boolv; - char charv; - float f32; - double f64; - FnExpr *fn; - void *arr; - void *ptr; - union Value *tuple; -} Value; - #define DECL_FLAG_ANNOTATES_TYPE 0x01 #define DECL_FLAG_CONST 0x02 #define DECL_FLAG_HAS_EXPR 0x04 @@ -464,7 +467,6 @@ typedef enum { typedef struct { Allocator allocr; - struct Typer *typer; } Evaluator; typedef struct Typer { |