From ef29776bb66629a28a3f4dfeac2d450c83a22b7b Mon Sep 17 00:00:00 2001 From: Leo Tenenbaum Date: Wed, 12 Feb 2020 21:26:23 -0500 Subject: got rid of #cache; decided it wasnt the way to go --- copy.c | 3 +++ eval.c | 83 ++++++++++++++++++++----------------------------------------- main.c | 10 +++++--- parse.c | 6 ----- test.toc | 15 ++++------- tokenizer.c | 2 +- types.c | 10 ++++++++ types.h | 22 +++++++--------- 8 files changed, 62 insertions(+), 89 deletions(-) diff --git a/copy.c b/copy.c index 4a69967..0b03257 100644 --- a/copy.c +++ b/copy.c @@ -118,6 +118,7 @@ static void copy_type(Copier *c, Type *out, Type *in) { out->slice = copy_type_(c, in->slice); break; case TYPE_STRUCT: { + /* FIXME */ out->struc = allocr_malloc(c->allocr, sizeof *out->struc); *out->struc = *in->struc; size_t nfields = arr_len(in->struc->fields); @@ -366,6 +367,8 @@ static void copy_stmt(Copier *c, Statement *out, Statement *in) { } static void copy_block(Copier *c, Block *out, Block *in, U8 flags) { + assert(!(in->flags & BLOCK_FINDING_TYPES)); + Identifiers out_idents = out->idents; *out = *in; if (flags & COPY_BLOCK_DONT_CREATE_IDENTS) diff --git a/eval.c b/eval.c index b9001fc..83e2648 100644 --- a/eval.c +++ b/eval.c @@ -1523,15 +1523,6 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) { return false; break; } - /* make sure function body is typed before calling it */ - if (!types_block(ev->typer, &fn->body)) { - return false; - } - /* NOTE: we're not calling fn_enter because we're manually entering the function */ - - Value *ret_val; - Value *arg_tuple = NULL; - Type *arg_type_tuple = NULL; /* set parameter values */ Declaration *params = fn->params; @@ -1549,42 +1540,12 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) { Type *type = is_tuple ? &p->type.tuple[idx] : &p->type; Value *ival = multiple_idents ? &pval->tuple[idx] : pval; copy_val(NULL, ival, &arg_val, type); - if (fn->flags & FN_EXPR_CACHE) { - Value *arg_tuple_member = arr_add(&arg_tuple); - *(Type *)arr_add(&arg_type_tuple) = *type; - copy_val(ev->allocr, arg_tuple_member, &arg_val, type); - } ++arg; ++idx; } ++arr_hdr(p->val_stack)->len; } - if (fn->flags & FN_EXPR_CACHE) { - Value args; - args.tuple = arg_tuple; - Type args_type = {0}; - args_type.flags = TYPE_IS_RESOLVED; - args_type.tuple = arg_type_tuple; - bool already_there; - Instance *i = instance_table_adda(ev->allocr, fn->cache, args, &args_type, &already_there); - arr_clear(&arg_tuple); - arr_clear(&arg_type_tuple); - if (already_there) { - *v = *i->ret_val; - return true; - } else { - ret_val = i->ret_val = evalr_calloc(ev, 1, sizeof *ret_val); - if (type_is_builtin(&e->type, BUILTIN_TYPE)) { - /* placeholder type, overwritten when done */ - ret_val->type = evalr_calloc(ev, 1, sizeof *ret_val); - ret_val->type->kind = TYPE_UNKNOWN; - ret_val->type->flags = TYPE_IS_RESOLVED; - } - } - - } - arr_foreach(fn->ret_decls, Declaration, d) { int idx = 0; Value ret_decl_val; @@ -1605,6 +1566,11 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) { ++idx; } } + + /* make sure function body is typed before calling it */ + if (!types_block(ev->typer, &fn->body)) + return false; + if (!eval_block(ev, &fn->body, v)) { return false; } @@ -1642,13 +1608,6 @@ static bool eval_expr(Evaluator *ev, Expression *e, Value *v) { decl_remove_val(p); arr_foreach(fn->ret_decls, Declaration, d) decl_remove_val(d); - if (fn->flags & FN_EXPR_CACHE) { - if (type_is_builtin(&e->type, BUILTIN_TYPE)) { - *ret_val->type = *v->type; - } else { - *ret_val = *v; - } - } } break; case EXPR_SLICE: { SliceExpr *s = &e->slice; @@ -1792,21 +1751,33 @@ static void eval_exit_stmts(Statement *stmts) { } static bool eval_block(Evaluator *ev, Block *b, Value *v) { + Block *prev = ev->typer->block; + ev->typer->block = b; + bool success = true; arr_foreach(b->stmts, Statement, stmt) { - if (!eval_stmt(ev, stmt)) - return false; + if (!eval_stmt(ev, stmt)) { + success = false; + goto ret; + } if (ev->returning) break; } if (!ev->returning && b->ret_expr) { Value r; - if (!eval_expr(ev, b->ret_expr, &r)) - return false; - /* make a copy so that r's data isn't freed when we exit the block */ - copy_val(NULL, v, &r, &b->ret_expr->type); - if (b->ret_expr->kind == EXPR_TUPLE) - free(r.tuple); + if (!eval_expr(ev, b->ret_expr, &r)) { + success = false; + goto ret; + } + if (!type_is_builtin(&b->ret_expr->type, BUILTIN_TYPE)) { + /* make a copy so that r's data isn't freed when we exit the block */ + copy_val(NULL, v, &r, &b->ret_expr->type); + if (b->ret_expr->kind == EXPR_TUPLE) + free(r.tuple); + } else { + *v = r; + } } eval_exit_stmts(b->stmts); - - return true; + ret: + ev->typer->block = prev; + return success; } diff --git a/main.c b/main.c index 391475f..b5e4c6d 100644 --- a/main.c +++ b/main.c @@ -18,7 +18,11 @@ /* TODO: -allow circular dependencies in types +fix circular dependencies in types +struct parameters +fix struct copying +replace is_reference in type_resolve_ with system for checking if type is + circularly dependent in a bad way, with compiler_sizeof foo, _ := bar(); nice syntax for #including something into a namespace run stuff at compile time without assigning it to a constant @@ -35,14 +39,14 @@ don't allow while {3; 5} or for 0..10 { 3; 5 } (once break is added) do we need was_expr? (now that, presumably, we have struct arguments) any odd number of "s for a string make sure futurely/currently-declared types are only used by pointer/slice -allow omission of trailing ; in foo ::= fn() {...} or foo ::= nms {...} ? +allow omission of trailing ; in foo ::= fn() {...} or foo ::= nms {...} or foo ::= struct { ... }? */ #include "toc.c" -#if defined TOC_DEBUG && defined __linux__ +#if defined TOC_DEBUG && defined __linux__ && defined __GNU_LIBRARY__ #include #include #include diff --git a/parse.c b/parse.c index e258416..b03a213 100644 --- a/parse.c +++ b/parse.c @@ -866,11 +866,6 @@ static bool parse_fn_expr(Parser *p, FnExpr *f) { /* only called when token is fn */ assert(token_is_kw(t->token, KW_FN)); ++t->token; - if (token_is_direct(t->token, DIRECT_CACHE)) { - f->flags |= FN_EXPR_CACHE; - f->cache = parser_calloc(p, 1, sizeof *f->cache); - ++t->token; - } if (!token_is_kw(t->token, KW_LPAREN)) { tokr_err(t, "Expected '(' after 'fn'."); return false; @@ -1775,7 +1770,6 @@ static bool parse_expr(Parser *p, Expression *e, Token *end) { case DIRECT_FOREIGN: case DIRECT_EXPORT: case DIRECT_INCLUDE: - case DIRECT_CACHE: tokr_err(t, "Unrecognized expression."); return false; case DIRECT_COUNT: assert(0); break; diff --git a/test.toc b/test.toc index 56718ab..9eddb80 100644 --- a/test.toc +++ b/test.toc @@ -1,14 +1,9 @@ -io ::= nms{ - #include "std/io.toc"; +b ::= struct { + next : &a; }; - -ll ::= fn() Type { - struct { - head : int; - tail : &ll(); - } +a::=struct { + next : &b; }; - main ::= fn() { - l : ll(); + l : ll; }; diff --git a/tokenizer.c b/tokenizer.c index 36d9aa5..5a7e272 100644 --- a/tokenizer.c +++ b/tokenizer.c @@ -19,7 +19,7 @@ static const char *const keywords[KW_COUNT] = static inline const char *kw_to_str(Keyword k) { return keywords[k]; } static const char *directives[DIRECT_COUNT] = - {"C", "sizeof", "alignof", "export", "foreign", "builtin", "include", "cache"}; + {"C", "sizeof", "alignof", "export", "foreign", "builtin", "include"}; /* Returns KW_COUNT if it's not a keyword */ /* OPTIM: don't use strncmp so much */ diff --git a/types.c b/types.c index 6765314..abe6795 100644 --- a/types.c +++ b/types.c @@ -2213,6 +2213,14 @@ static bool types_expr(Typer *tr, Expression *e) { static bool types_block(Typer *tr, Block *b) { if (b->flags & BLOCK_FOUND_TYPES) return true; + + if (b->flags & BLOCK_FINDING_TYPES) { + err_print(b->where, "A circular dependency was found when finding types in this block.\n" + "You are using recursion in a way that is not allowed by this language. Sorry!"); + return false; + } + b->flags |= BLOCK_FINDING_TYPES; + typer_block_enter(tr, b); bool success = true; arr_foreach(b->stmts, Statement, s) { @@ -2248,6 +2256,8 @@ static bool types_block(Typer *tr, Block *b) { ret: typer_block_exit(tr); b->flags |= BLOCK_FOUND_TYPES; + b->flags &= (BlockFlags)~(BlockFlags)BLOCK_FINDING_TYPES; + return success; } diff --git a/types.h b/types.h index c4851c4..9034f38 100644 --- a/types.h +++ b/types.h @@ -230,7 +230,6 @@ typedef enum { DIRECT_FOREIGN, DIRECT_BUILTIN, DIRECT_INCLUDE, - DIRECT_CACHE, DIRECT_COUNT } Directive; @@ -472,10 +471,12 @@ typedef struct StructDef { enum { BLOCK_IS_FN = 0x01, BLOCK_IS_NMS = 0x02, - BLOCK_FOUND_TYPES = 0x04 + BLOCK_FINDING_TYPES = 0x04, + BLOCK_FOUND_TYPES = 0x08 }; +typedef U8 BlockFlags; typedef struct Block { - U8 flags; + BlockFlags flags; Location where; Identifiers idents; struct Statement *stmts; @@ -596,8 +597,7 @@ typedef struct ForExpr { enum { FN_EXPR_FOREIGN = 0x01, - FN_EXPR_EXPORT = 0x02, /* set by sdecls_cgen.c */ - FN_EXPR_CACHE = 0x04 + FN_EXPR_EXPORT = 0x02 /* set by sdecls_cgen.c */ }; typedef struct FnExpr { @@ -617,7 +617,6 @@ typedef struct FnExpr { the first element is a u64 value whose ith bit (1<