diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/analyze.c | 63 | ||||
| -rw-r--r-- | src/ast.c | 10 | ||||
| -rw-r--r-- | src/debug.c | 4 | ||||
| -rw-r--r-- | src/lexer.l | 5 | ||||
| -rw-r--r-- | src/lower.c | 91 | ||||
| -rw-r--r-- | src/move.c | 143 | ||||
| -rw-r--r-- | src/parser.y | 62 |
7 files changed, 337 insertions, 41 deletions
diff --git a/src/analyze.c b/src/analyze.c index 8e76892..7eee49a 100644 --- a/src/analyze.c +++ b/src/analyze.c @@ -30,6 +30,7 @@ static int analyze_proc(struct state *state, struct scope *scope, return -1; } + proc_scope->flags |= SCOPE_PROC; scope_add_scope(scope, proc_scope); struct state proc_state = {}; @@ -150,6 +151,28 @@ static int analyze_block(struct state *state, struct scope *scope, else node->t = tgen_void(node->loc); + if (!block_error(node)) + return 0; + + struct ast *err = block_error(node); + if (error_str(err)) + return 0; + + struct ast *id = error_id(err); + assert(id); + + struct ast *def = file_scope_find_symbol(scope, id_str(id)); + if (!def) { + semantic_error(scope, id, "no such symbol"); + return -1; + } + + struct type *t = def->t; + if (t->k != TYPE_ERR) { + semantic_error(scope, id, "invalid error variable type"); + return -1; + } + return 0; } @@ -248,7 +271,7 @@ static int analyze_call(struct state *state, struct scope *scope, return -1; } - return 0; + return analyze(state, scope, call_err(node)); } static int analyze_ref(struct state *state, struct scope *scope, @@ -332,6 +355,8 @@ static int analyze_closure(struct state *state, struct scope *scope, return -1; } + node->scope = closure_scope; + closure_scope->flags |= SCOPE_PROC; scope_add_scope(scope, closure_scope); if (analyze_list(state, closure_scope, closure_bindings(node))) @@ -427,6 +452,40 @@ static int analyze_if(struct state *state, struct scope *scope, return 0; } +static int analyze_err_branch(struct state *state, struct scope *scope, struct ast *node) +{ + struct scope *branch_scope = create_scope(); + if (!branch_scope) { + internal_error("failed allocating err branch scope"); + return -1; + } + + node->t = tgen_void(node->loc); + + scope_add_scope(scope, branch_scope); + struct ast *var = gen_var(strdup(err_branch_id(node)), NULL, node->loc); + struct type *err_type = tgen_err(node->loc); + var->t = err_type; + scope_add_var(branch_scope, var); + return analyze(state, branch_scope, err_branch_body(node)); +} + +static int analyze_own(struct state *state, struct scope *scope, struct ast *node) +{ + struct ast *found = file_scope_find_symbol(scope, own_id(node)); + if (!found) { + semantic_error(scope, node, "no symbol named \"%s\"", + own_id(node)); + return -1; + } + + if (is_trivially_copyable(found->t)) + semantic_warn(scope, node, "trivially copyable type is never owned"); + + node->t = tgen_void(node->loc); + return analyze(state, scope, own_body(node)); +} + static int analyze(struct state *state, struct scope *scope, struct ast *node) { if (!node) @@ -464,6 +523,7 @@ static int analyze(struct state *state, struct scope *scope, struct ast *node) } switch (node->k) { + case AST_ERR_BRANCH: ret = analyze_err_branch(state, scope, node); break; case AST_CLOSURE: ret = analyze_closure(state, scope, node); break; case AST_PROC_DEF: ret = analyze_proc(state, scope, node); break; case AST_VAR_DEF: ret = analyze_var(state, scope, node); break; @@ -473,6 +533,7 @@ static int analyze(struct state *state, struct scope *scope, struct ast *node) case AST_CALL: ret = analyze_call(state, scope, node); break; case AST_REF: ret = analyze_ref(state, scope, node); break; case AST_LET: ret = analyze_let(state, scope, node); break; + case AST_OWN: ret = analyze_own(state, scope, node); break; case AST_ID: ret = analyze_id(state, scope, node); break; case AST_IF: ret = analyze_if(state, scope, node); break; @@ -201,6 +201,10 @@ void ast_dump(int depth, struct ast *n) switch (n->k) { DUMP(AST_CLOSURE); DUMP(AST_IF); + DUMP(AST_NIL); + DUMP(AST_OWN); + DUMP(AST_ERR_BRANCH); + DUMP(AST_ERROR); DUMP(AST_LET); DUMP(AST_INIT); DUMP(AST_CALL); @@ -558,7 +562,7 @@ void fix_closures(struct ast *root) assert(next); - struct ast *block = gen_block(next, root->loc); + struct ast *block = gen_block(next, NULL, root->loc); closure_body(arg) = block; root->n = NULL; root = next; @@ -627,6 +631,10 @@ const char *ast_str(enum ast_kind k) switch (k) { CASE(AST_CLOSURE); CASE(AST_IF); + CASE(AST_NIL); + CASE(AST_OWN); + CASE(AST_ERR_BRANCH); + CASE(AST_ERROR); CASE(AST_LET); CASE(AST_INIT); CASE(AST_CALL); diff --git a/src/debug.c b/src/debug.c index 1f4d3a8..b13a459 100644 --- a/src/debug.c +++ b/src/debug.c @@ -177,6 +177,10 @@ static void _type_str(FILE *f, struct type *type) return; switch (type->k) { + case TYPE_ERR: + fprintf(f, "err"); + break; + case TYPE_VOID: fprintf(f, "void"); break; diff --git a/src/lexer.l b/src/lexer.l index ccae93e..e11b51e 100644 --- a/src/lexer.l +++ b/src/lexer.l @@ -122,12 +122,17 @@ STRING \"(\\.|[^"\\])*\" "==" {return EQ;} "=>" {return FATARROW;} +"!>" {return ERRARROW;} "<<" {return LSHIFT;} ">>" {return RSHIFT;} "if" {return IF;} "else" {return ELSE;} +"nil" {return NIL;} +"own" {return OWN;} + +"error" {return ERROR;} "mut" {return MUT;} diff --git a/src/lower.c b/src/lower.c index df095e4..141453c 100644 --- a/src/lower.c +++ b/src/lower.c @@ -34,7 +34,7 @@ static void indent(struct state *state) static int lower_var(struct ast *expr); static int lower_expr(struct state *state, struct ast *expr); -static int lower_block(struct state *state, struct ast *block); +static int lower_block(struct state *state, struct ast *block, bool ret); static int lower_closure(struct state *state, struct ast *closure); static int lower_statement(struct state *state, struct ast *stmt); @@ -287,8 +287,18 @@ static int lower_moves(struct state *state, struct ast *moves) return 0; } +static int lower_err_branch(struct state *state, struct ast *err) +{ + return lower_block(state, err_branch_body(err), false); +} + static int lower_call(struct state *state, struct ast *call) { + struct ast *err = call_err(call); + /** @todo better default error name? */ + const char *err_str = err ? err_branch_id(err) : "_fwd_err"; + + printf("if (auto %s = ", err_str); if (lower_expr(state, call_expr(call))) return -1; @@ -297,7 +307,19 @@ static int lower_call(struct state *state, struct ast *call) if (lower_moves(state, call_args(call))) return -1; - printf(");\n"); + printf("))"); + + if (!err) { + printf("\n"); + indent(state); + printf(" return %s;\n", err_str); + return 0; + } + + if (lower_err_branch(state, call_err(call))) + return -1; + + printf("\n"); return 0; } @@ -323,7 +345,7 @@ static int lower_if(struct state *state, struct ast *stmt) printf(") "); - if (lower_block(state, if_body(stmt))) + if (lower_block(state, if_body(stmt), false)) return -1; if (!if_else(stmt)) { @@ -332,16 +354,36 @@ static int lower_if(struct state *state, struct ast *stmt) } printf(" else "); - if (lower_block(state, if_else(stmt))) + if (lower_block(state, if_else(stmt), false)) return -1; printf("\n"); return 0; } +static int lower_error(struct ast *err) +{ + assert(error_str(err) || error_id(err)); + if (error_str(err)) { + printf("return %s;\n", error_str(err)); + return 0; + } + + struct ast *id = error_id(err); + printf("return %s;\n", id_str(id)); + return 0; +} + +static int lower_own(struct state *state, struct ast *stmt) +{ + printf("/* TODO own */\n"); + return 0; +} + static int lower_statement(struct state *state, struct ast *stmt) { switch (stmt->k) { + case AST_OWN: return lower_own(state, stmt); case AST_LET: return lower_let(state, stmt); case AST_CALL: return lower_call(state, stmt); case AST_IF: return lower_if(state, stmt); @@ -354,7 +396,7 @@ static int lower_statement(struct state *state, struct ast *stmt) return 0; } -static int lower_block(struct state *state, struct ast *block) +static int lower_block(struct state *state, struct ast *block, bool ret) { printf("{\n"); increase_indent(state); @@ -366,8 +408,18 @@ static int lower_block(struct state *state, struct ast *block) return -1; } - decrease_indent(state); + if (block_error(block)) { + indent(state); + if (lower_error(block_error(block))) + return -1; + } + + if (ret) { + indent(state); + printf("return nullptr;\n"); + } + decrease_indent(state); indent(state); printf("}"); return 0; @@ -407,7 +459,7 @@ static int lower_closure(struct state *state, struct ast *closure) printf(")"); - if (lower_block(state, closure_body(closure))) + if (lower_block(state, closure_body(closure), true)) return -1; return 0; @@ -420,12 +472,12 @@ static int lower_proto(struct ast *proc) if (!proc_body(proc)) return 0; + printf("fwd_err_t "); if (strcmp("main", proc_id(proc)) == 0) - printf("int "); + printf("fwd_main("); else - printf("void "); + printf("%s(", proc_id(proc)); - printf("%s(", proc_id(proc)); if (lower_vars(proc_params(proc))) return -1; @@ -439,12 +491,11 @@ static int lower_proc(struct ast *proc) if (!proc_body(proc)) return 0; + printf("fwd_err_t "); if (strcmp("main", proc_id(proc)) == 0) - printf("int "); + printf("fwd_main("); else - printf("void "); - - printf("%s(", proc_id(proc)); + printf("%s(", proc_id(proc)); if (lower_vars(proc_params(proc))) return -1; @@ -452,7 +503,7 @@ static int lower_proc(struct ast *proc) printf(")\n"); struct state state = {0}; - if (lower_block(&state, proc_body(proc))) + if (lower_block(&state, proc_body(proc), true)) return -1; printf("\n\n"); @@ -476,5 +527,15 @@ int lower(struct scope *root) return -1; } + + puts("int main()"); + puts("{"); + puts(" fwd_err_t err = fwd_main();"); + puts(" if (err) {"); + puts(" fprintf(stderr, \"%s\", err);"); + puts(" return -1;"); + puts(" }"); + puts("}"); + return 0; } @@ -46,6 +46,34 @@ static void destroy_state(struct state *state) moved_destroy(&state->referenced); } +struct rm_move { + struct ast_pair data; + struct state *owner; +}; + +static struct rm_move remove_move(struct state *state, struct ast *def) +{ + if (!state) + return (struct rm_move){.data = {}, .owner = NULL}; + + struct ast_pair search = {.def = def}; + struct ast_pair *found = moved_find(&state->moved, search); + if (found) { + moved_remove_found(&state->moved, found); + return (struct rm_move){.data = *found, .owner = state}; + } + + return remove_move(state->parent, def); +} + +static void reinsert_move(struct rm_move move) +{ + if (!move.owner) + return; + + moved_insert(&move.owner->moved, move.data); +} + static struct ast_pair *find_move(struct state *state, struct ast *def) { if (!state) @@ -195,9 +223,66 @@ static int mvcheck_proc(struct state *state, struct ast *node) return ret; } +static int total_check_single(struct state *state, struct scope *scope) +{ + int ret = 0; + foreach_visible(n, scope->symbols) { + struct ast *def = n->node; + if (def->k != AST_VAR_DEF) + continue; + + if (is_trivially_copyable(def->t)) + continue; + + struct ast_pair *prev = find_move(state, def); + if (prev) + continue; + + semantic_warn(scope, def, "%s not moved, might leak", var_id(def)); + ret |= 1; + } + + return ret; +} + +static int total_check_proc(struct state *state, struct scope *scope) +{ + int ret = total_check_single(state, scope); + if (scope->flags & SCOPE_PROC) + return ret; + + if (!scope->parent) + return ret; + + return ret | total_check_proc(state, scope->parent); +} + static int mvcheck_block(struct state *state, struct ast *node) { - return mvcheck_statements(state, block_body(node)); + struct state new_state = create_state(state); + int ret = mvcheck_statements(&new_state, block_body(node)); + if (ret) { + destroy_state(&new_state); + return ret; + } + + 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"); + + destroy_state(&new_state); + return 0; + } + + if (total_check_single(&new_state, node->scope)) + semantic_info(node->scope, node, "at end of block"); + + push_up(&new_state); + destroy_state(&new_state); + return 0; } static int mvcheck_call(struct state *state, struct ast *node) @@ -233,6 +318,17 @@ static int mvcheck_call(struct state *state, struct ast *node) break; } + if (!ret && call_err(node)) { + struct state err_state = create_state(state); + ret = mvcheck(&err_state, call_err(node)); + push_up(&err_state); + destroy_state(&err_state); + } + else if (!ret) { + if (total_check_proc(state, node->scope)) + semantic_info(node->scope, node, "in implicit error branch"); + } + destroy_state(&group_state); return ret; } @@ -244,8 +340,11 @@ static int mvcheck_closure(struct state *state, struct ast *node) int ret = mvcheck(&new_state, closure_body(node)); push_up(&new_state); - destroy_state(&new_state); + + if (total_check_single(state, node->scope)) + semantic_info(node->scope, node, "in closure"); + return ret; } @@ -398,6 +497,24 @@ static int mvcheck_statements(struct state *state, struct ast *nodes) return 0; } +static int mvcheck_err_branch(struct state *state, struct ast *node) +{ + return mvcheck(state, err_branch_body(node)); +} + +static int mvcheck_own(struct state *state, struct ast *node) +{ + struct ast *def = file_scope_find_symbol(node->scope, own_id(node)); + assert(def); + + struct rm_move prev = remove_move(state, def); + int ret = mvcheck(state, own_body(node)); + + /* insert back */ + reinsert_move(prev); + return ret; +} + static int mvcheck(struct state *state, struct ast *node) { if (is_unop(node)) @@ -410,16 +527,18 @@ static int mvcheck(struct state *state, struct ast *node) return mvcheck_comparison(state, node); switch (node->k) { - case AST_PROC_DEF: return mvcheck_proc (state, node); - case AST_BLOCK: return mvcheck_block (state, node); - case AST_CALL: return mvcheck_call (state, node); - case AST_CLOSURE: return mvcheck_closure (state, node); - case AST_LET: return mvcheck_let (state, node); - case AST_ID: return mvcheck_id (state, node); - case AST_INIT: return mvcheck_init (state, node); - case AST_IF: return mvcheck_if (state, node); - case AST_REF: return mvcheck_ref (state, node); - case AST_DEREF: return mvcheck_deref (state, node); + case AST_PROC_DEF: return mvcheck_proc (state, node); + case AST_BLOCK: return mvcheck_block (state, node); + case AST_CALL: return mvcheck_call (state, node); + case AST_CLOSURE: return mvcheck_closure (state, node); + case AST_ERR_BRANCH: return mvcheck_err_branch(state, node); + case AST_OWN: return mvcheck_own (state, node); + case AST_LET: return mvcheck_let (state, node); + case AST_ID: return mvcheck_id (state, node); + case AST_INIT: return mvcheck_init (state, node); + case AST_IF: return mvcheck_if (state, node); + case AST_REF: return mvcheck_ref (state, node); + case AST_DEREF: return mvcheck_deref (state, node); case AST_EMPTY: case AST_CONST_INT: case AST_CONST_STR: diff --git a/src/parser.y b/src/parser.y index 751aaa1..68725a8 100644 --- a/src/parser.y +++ b/src/parser.y @@ -72,10 +72,14 @@ %token RBRACKET "]" %token IF "if" %token ELSE "else" +%token NIL "nil" +%token OWN "own" %token MUT "mut" +%token ERROR "error" %token DOT "." %token SCOPE "::" %token FATARROW "=>" +%token ERRARROW "!>" %right "[" "]" /* precedence */ @@ -94,10 +98,10 @@ %left "::" %nterm <node> top unit proc call closure var expr statement body -%nterm <node> vars exprs statements closures trailing_closure -%nterm <node> opt_vars opt_exprs opt_statements opt_trailing_closure +%nterm <node> vars exprs statements closures err trailing_closure +%nterm <node> opt_vars opt_exprs opt_statements opt_trailing_closure opt_err opt_error %nterm <node> rev_vars rev_exprs rev_closures rev_statements -%nterm <node> let if unop binop construct +%nterm <node> let if nil own unop binop construct %nterm <type> type rev_types types opt_types @@ -299,7 +303,9 @@ opt_exprs | { $$ = NULL; } closure - : "=>" opt_vars body { $$ = gen_closure($[opt_vars], $[body], src_loc(@$)); } + : "=>" opt_vars body { + $$ = gen_closure($[opt_vars], $[body], src_loc(@$)); + } | "&" "=>" opt_vars body { $$ = gen_closure($[opt_vars], $[body], src_loc(@$)); ast_set_flags($$, AST_FLAG_NOMOVES); @@ -330,20 +336,29 @@ closures } } +err + : "!>" ID body { + $$ = gen_err_branch($2, $3, src_loc(@$)); + } + +opt_err + : err + | { $$ = NULL; } + call - : expr "(" opt_exprs ")" ";" { - $$ = gen_call($1, $[opt_exprs], src_loc(@$)); + : expr "(" opt_exprs ")" ";" opt_err { + $$ = gen_call($1, $[opt_exprs], $[opt_err], src_loc(@$)); } - | expr "(" opt_exprs ")" "=>" opt_vars ";" { + | expr "(" opt_exprs ")" "=>" opt_vars ";" opt_err { /* the rest of the function body is our closure, gets fixed up * later */ struct ast *closure = gen_closure($[opt_vars], NULL, src_loc(@$)); ast_append(&$[opt_exprs], closure); - $$ = gen_call($[expr], $[opt_exprs], src_loc(@$)); + $$ = gen_call($[expr], $[opt_exprs], $[opt_err], src_loc(@$)); } - | expr "(" opt_exprs ")" closures { + | expr "(" opt_exprs ")" closures opt_err { ast_append(&$[opt_exprs], $[closures]); - $$ = gen_call($[expr], $[opt_exprs], src_loc(@$)); + $$ = gen_call($[expr], $[opt_exprs], $[opt_err], src_loc(@$)); } let @@ -354,11 +369,32 @@ if | "if" expr body "else" body { $$ = gen_if($2, $3, $5, src_loc(@$)); } | "if" expr body "else" if { $$ = gen_if($2, $3, $5, src_loc(@$)); } +nil + : "nil" ID body "=>" var { + $$ = gen_nil($2, $3, $5, src_loc(@$)); + } + +own + : "own" ID body { + $$ = gen_own($2, $3, src_loc(@$)); + } + +opt_error + : "error" STRING { + $$ = gen_error($2, NULL, src_loc(@$)); + } + | "error" ID { + $$ = gen_error(NULL, gen_id($2, src_loc(@$)), src_loc(@$)); + } + | { $$ = NULL; } + statement : call + | body | let + | nil + | own | if - | body | ";" { $$ = gen_empty(src_loc(@$)); } rev_statements @@ -373,7 +409,9 @@ opt_statements | { $$ = NULL; } body - : "{" opt_statements "}" { $$ = gen_block($2, src_loc(@$)); } + : "{" opt_statements opt_error "}" { + $$ = gen_block($2, $3, src_loc(@$)); + } top : proc |