diff options
| -rw-r--r-- | examples/uniq.fwd | 6 | ||||
| -rw-r--r-- | lib/fwdlib.hpp | 6 | ||||
| -rw-r--r-- | src/analyze.c | 50 | ||||
| -rw-r--r-- | src/lower.c | 23 | ||||
| -rw-r--r-- | src/move.c | 95 |
5 files changed, 146 insertions, 34 deletions
diff --git a/examples/uniq.fwd b/examples/uniq.fwd index c1edc1b..cc6e0af 100644 --- a/examples/uniq.fwd +++ b/examples/uniq.fwd @@ -10,11 +10,17 @@ fwd_some(optional![string] o, fwd_insert(unordered_set![string] set, string line, (unordered_set![string]) next); +fwd_destroy(auto a); + /* at some point I'll probably add in a type system as well, but for now let's * pretend we're static-dynamic (or dynamic at compiletime? dunno) */ readlines(unordered_set![string] set, (unordered_set![string]) next) { fwd_getline() => optional![string] line; + !> e { + own set {fwd_destroy(set);} + error e + } fwd_some(line) => string line { /* we had something in our option */ diff --git a/lib/fwdlib.hpp b/lib/fwdlib.hpp index 8e6be16..6af8441 100644 --- a/lib/fwdlib.hpp +++ b/lib/fwdlib.hpp @@ -71,4 +71,10 @@ static fwd_err_t fwd_intalloc(auto ok) return ok(p); } +static fwd_err_t fwd_destroy(auto /* a */) +{ + /* RAII destroys a */ + return nullptr; +} + #endif /* FWDLIB_HPP */ diff --git a/src/analyze.c b/src/analyze.c index 7eee49a..c33a901 100644 --- a/src/analyze.c +++ b/src/analyze.c @@ -10,6 +10,7 @@ struct state { }; static int analyze(struct state *state, struct scope *scope, struct ast *node); +static int analyze_known_block(struct state *state, struct scope *scope, struct ast *node); static int analyze_list(struct state *state, struct scope *scope, struct ast *nodes); @@ -58,8 +59,10 @@ static int analyze_proc(struct state *state, struct scope *scope, } node->t = proc_type; + if (!proc_body(node)) + return 0; - return analyze(&proc_state, proc_scope, proc_body(node)); + return analyze_known_block(&proc_state, proc_scope, proc_body(node)); } static int analyze_unop(struct state *state, struct scope *scope, @@ -132,29 +135,19 @@ static int analyze_comparison(struct state *state, struct scope *scope, return 0; } -static int analyze_block(struct state *state, struct scope *scope, - struct ast *node) +static int analyze_known_block(struct state *state, struct scope *scope, struct ast *node) { - struct scope *block_scope = create_scope(); - if (!block_scope) { - internal_error("failed to allocate block scope"); - return -1; - } + assert(node && node->k == AST_BLOCK); - scope_add_scope(scope, block_scope); - if (analyze_list(state, block_scope, block_body(node))) + node->scope = scope; + node->t = tgen_void(node->loc); + if (analyze_list(state, scope, block_body(node))) return -1; - struct ast *last = ast_last(block_body(node)); - if (last) - node->t = last->t; - else - node->t = tgen_void(node->loc); - - if (!block_error(node)) + struct ast *err = block_error(node); + if (!err) return 0; - struct ast *err = block_error(node); if (error_str(err)) return 0; @@ -176,6 +169,19 @@ static int analyze_block(struct state *state, struct scope *scope, return 0; } +static int analyze_block(struct state *state, struct scope *scope, + struct ast *node) +{ + struct scope *block_scope = create_scope(); + if (!block_scope) { + internal_error("failed to allocate block scope"); + return -1; + } + + scope_add_scope(scope, block_scope); + return analyze_known_block(state, scope, node); +} + static int analyze_var(struct state *state, struct scope *scope, struct ast *node) { @@ -362,7 +368,7 @@ static int analyze_closure(struct state *state, struct scope *scope, if (analyze_list(state, closure_scope, closure_bindings(node))) return -1; - if (analyze(state, closure_scope, closure_body(node))) + if (analyze_known_block(state, closure_scope, closure_body(node))) return -1; struct type *callable = NULL; @@ -387,6 +393,9 @@ static int analyze_closure(struct state *state, struct scope *scope, static int analyze_int(struct state *state, struct scope *scope, struct ast *node) { + (void)state; + (void)scope; + /** @todo do this properly, very hacky, bad bad bad */ char *i = strdup("int"); if (!i) { @@ -407,6 +416,9 @@ static int analyze_int(struct state *state, struct scope *scope, static int analyze_str(struct state *state, struct scope *scope, struct ast *node) { + (void)state; + (void)scope; + /** @todo do this properly, very hacky, bad bad bad */ char *i = strdup("char"); if (!i) { diff --git a/src/lower.c b/src/lower.c index b683e0b..8d3e4ea 100644 --- a/src/lower.c +++ b/src/lower.c @@ -322,6 +322,9 @@ static int lower_mark_moved(struct state *state, struct ast *moves) return 0; } +/** @todo this is probably more complicated than it really needs to be, maybe + * refactor into lower_checked_call and lower_implicit_call or something for + * explicit and implicit error handling cases? */ static int lower_call(struct state *state, struct ast *call, bool ret) { struct ast *err = call_err(call); @@ -351,12 +354,28 @@ static int lower_call(struct state *state, struct ast *call, bool ret) } printf("))"); - if (err) - return lower_err_branch(state, err); + if (err) { + if (lower_err_branch(state, err)) + return -1; + + if (ret) { + printf("\n"); + indent(state); + printf("return nullptr;\n"); + } + + return 0; + } printf("\n"); indent(state); printf(" return %s;\n", err_str); + + if (ret) { + indent(state); + printf("return nullptr;\n"); + } + return 0; } @@ -12,6 +12,7 @@ struct ast_pair { struct state { struct moved moved; + struct moved queued; struct moved referenced; struct state *parent; @@ -35,6 +36,7 @@ static struct state create_state(struct state *parent) struct state state = {}; state.parent = parent; state.pure = false; + state.queued = moved_create(); state.moved = moved_create(); state.referenced = moved_create(); return state; @@ -43,6 +45,7 @@ static struct state create_state(struct state *parent) static void destroy_state(struct state *state) { moved_destroy(&state->moved); + moved_destroy(&state->queued); moved_destroy(&state->referenced); } @@ -123,6 +126,16 @@ static void merge_moves(struct state *to, struct state *from) } } +static void merge_queued(struct state *to, struct state *from) +{ + if (moved_len(&from->queued) == 0) + return; + + foreach(moved, n, &from->queued) { + moved_insert(&to->queued, *n); + } +} + static void merge_references(struct state *to, struct state *from) { if (moved_len(&from->referenced) == 0) @@ -136,6 +149,7 @@ static void merge_references(struct state *to, struct state *from) static void merge(struct state *to, struct state *from) { merge_moves(to, from); + merge_queued(to, from); merge_references(to, from); } @@ -148,9 +162,37 @@ static void push_up(struct state *state) merge(parent, state); } +static void mark_queued(struct state *state) +{ + if (moved_len(&state->moved) == 0) + return; + + foreach(moved, m, &state->moved) { + moved_insert(&state->queued, *m); + } + + /* empty out moves now that they're all queued */ + moved_destroy(&state->moved); + state->moved = moved_create(); +} + +static void mark_unqueued(struct state *state) +{ + if (moved_len(&state->queued) == 0) + return; + + foreach(moved, q, &state->queued) { + moved_insert(&state->moved, *q); + } + + moved_destroy(&state->queued); + state->queued = moved_create(); +} + static void forget_references(struct state *state) { moved_destroy(&state->referenced); + state->referenced = moved_create(); } static int mvcheck(struct state *state, struct ast *node); @@ -270,12 +312,13 @@ static int mvcheck_block(struct state *state, struct ast *node) } if (block_error(node)) { - /* don't push state up since there's no way to continue - * execution after an error, so whatever code follows this - * didn't see any moves take place */ if (total_check_proc(&new_state, node->scope)) semantic_info(node->scope, node, "at end of block"); + /* mark us queued so moves are not visible for the next scopes, + * but appear to the caller function if we're in a closure */ + mark_queued(&new_state); + push_up(&new_state); destroy_state(&new_state); return 0; } @@ -306,20 +349,17 @@ static int mvcheck_call(struct state *state, struct ast *node) return -1; } - /* check if there are any arguments that might not be moved if function - * returns immediately */ - if (!call_err(node) && total_check_proc(state, node->scope)) - semantic_info(node->scope, node, "in implicit error branch"); - /* check into closures */ int ret = 0; - struct state group_state = create_state(state); + struct state buffer_state = create_state(state); + struct state group_state = create_state(&buffer_state); foreach_node(arg, call_args(node)) { if (arg->k != AST_CLOSURE) continue; struct state arg_state = create_state(state); ret = mvcheck(&arg_state, arg); + mark_unqueued(&arg_state); merge(&group_state, &arg_state); destroy_state(&arg_state); @@ -329,7 +369,7 @@ static int mvcheck_call(struct state *state, struct ast *node) /* this group ended, push state immediately */ push_up(&group_state); - /* something like reset_state would maybe me more clear? */ + /* something like reset_state would maybe be more clear? */ destroy_state(&group_state); group_state = create_state(state); } @@ -338,14 +378,43 @@ static int mvcheck_call(struct state *state, struct ast *node) break; } - if (!ret && call_err(node)) { + destroy_state(&group_state); + + /* the next section looks a bit weird, but it kind of makes sense. We + * don't know when the error branch might get taken, so we first check + * it 'before' the moves from any possible closures take place to see if + * there's a possibility that some variable gets leaked. The second time + * around we take the closure moves into account to see if the error + * branch might accidentally move an already moved variable, i.e. the + * user would need to add `own` blocks. */ + + /** @todo this is more or less what needs to happen for correctness, but + * might mean that warnings from leaks in the first check get reprinted + * in the second round, should probably add in some mechanism to check + * against that */ + if (call_err(node)) { + struct state err_state = create_state(state); + ret |= mvcheck(&err_state, call_err(node)); + destroy_state(&err_state); + } + else if (total_check_proc(state, node->scope)) { + semantic_info(node->scope, node, "in implicit err branch"); + } + + push_up(&buffer_state); + destroy_state(&buffer_state); + + if (call_err(node)) { struct state err_state = create_state(state); - ret = mvcheck(&err_state, call_err(node)); + ret |= mvcheck(&err_state, call_err(node)); + + /* store results of this check */ push_up(&err_state); destroy_state(&err_state); } + /* no need to check implicit error branch since it by definition can't + * move already moved variables */ - destroy_state(&group_state); return ret; } |