diff options
| -rw-r--r-- | examples/err.fwd | 17 | ||||
| -rw-r--r-- | examples/own.fwd | 33 | ||||
| -rw-r--r-- | include/fwd/ast.h | 45 | ||||
| -rw-r--r-- | include/fwd/scope.h | 6 | ||||
| -rw-r--r-- | lib/fwdlib.hpp | 19 | ||||
| -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 |
12 files changed, 444 insertions, 54 deletions
diff --git a/examples/err.fwd b/examples/err.fwd new file mode 100644 index 0000000..f2833e2 --- /dev/null +++ b/examples/err.fwd @@ -0,0 +1,17 @@ +do_something((auto, auto) ok); + +/* consume can fail */ +consume(auto a); + +main() +{ + do_something() => auto a, auto b; + consume(a); + /* try commenting out error handler or consume(b); */ + !> e { + consume(b); + error "a failed" + } + + consume(b); +} diff --git a/examples/own.fwd b/examples/own.fwd new file mode 100644 index 0000000..6634886 --- /dev/null +++ b/examples/own.fwd @@ -0,0 +1,33 @@ +do_something((auto) a); +consume(auto a); + +main() +{ + do_something() => auto a; + do_something() => auto b; + !> e { + /* if do_something() fails, a is still alive, so we must kill + * it. However, we might enter this error block after the + * callback to do_something() was run, and a might've already + * been moved. own just checks if we still own the resource and + * executes the block. + * + * admittedly, purely syntactically it would look like b is + * already alive at this point, but since it's actually within + * the implicit closure, it is not. Might play around with ordering + * the error block to come before implicit closures... + */ + own a {consume(a);} + error e + } + + consume(a); + !> e { + /* if consume fails, b is still alive, but either this error + * block runs (and throws an error) or the next consume is run, + * so own is not necessary here */ + consume(b); + error e + } + consume(b); +} diff --git a/include/fwd/ast.h b/include/fwd/ast.h index 726b5e3..5f2b7cb 100644 --- a/include/fwd/ast.h +++ b/include/fwd/ast.h @@ -32,7 +32,7 @@ struct ast; enum type_kind { TYPE_ID = 1, TYPE_CONSTRUCT, TYPE_REF, TYPE_PTR, TYPE_CLOSURE, - TYPE_PURE_CLOSURE, TYPE_FUNC_PTR, TYPE_VOID + TYPE_PURE_CLOSURE, TYPE_FUNC_PTR, TYPE_VOID, TYPE_ERR }; struct type { @@ -59,6 +59,14 @@ enum ast_kind { AST_LET = 1, /** If statement */ AST_IF, + /** Nil check */ + AST_NIL, + /* Owning check */ + AST_OWN, + /** Err branch */ + AST_ERR_BRANCH, + /** Error throwing */ + AST_ERROR, /** Call procedure. */ AST_CALL, /** Procedure definition. */ @@ -266,6 +274,7 @@ static inline bool is_trivially_copyable(struct type *type) switch (type->k) { case TYPE_REF: case TYPE_PTR: + case TYPE_ERR: case TYPE_FUNC_PTR: case TYPE_PURE_CLOSURE: /** @todo primitive types */ @@ -309,6 +318,9 @@ static inline bool is_trivially_copyable(struct type *type) #define tgen_void(loc) \ tgen_type(TYPE_VOID, NULL, NULL, loc) +#define tgen_err(loc) \ + tgen_type(TYPE_ERR, NULL, NULL, loc) + #define tid_str(x) return_id(x, TYPE_ID) #define tgen_id(id, loc) \ tgen_type(TYPE_ID, NULL, id, loc) @@ -359,8 +371,9 @@ static inline bool is_trivially_copyable(struct type *type) #define call_expr(x) return_a0(x, AST_CALL) #define call_args(x) return_a1(x, AST_CALL) -#define gen_call(expr, args, loc) \ - gen2(AST_CALL, expr, args, loc) +#define call_err(x) return_a2(x, AST_CALL) +#define gen_call(expr, args, err, loc) \ + gen3(AST_CALL, expr, args, err, loc) #define proc_id(x) return_s(x, AST_PROC_DEF) #define proc_params(x) return_a0(x, AST_PROC_DEF) @@ -379,9 +392,20 @@ static inline bool is_trivially_copyable(struct type *type) #define gen_var(id, type, loc) \ gen_ast(AST_VAR_DEF, NULL, NULL, NULL, NULL, type, id, 0, 0., loc) +#define err_branch_id(x) return_s(x, AST_ERR_BRANCH) +#define err_branch_body(x) return_a0(x, AST_ERR_BRANCH) +#define gen_err_branch(id, body, loc) \ + gen_ast(AST_ERR_BRANCH, body, NULL, NULL, NULL, NULL, id, 0, 0., loc) + +#define error_str(x) return_s(x, AST_ERROR) +#define error_id(x) return_a0(x, AST_ERROR) +#define gen_error(str, id, loc) \ + gen_ast(AST_ERROR, id, NULL, NULL, NULL, NULL, str, 0, 0., loc) + #define block_body(x) return_a0(x, AST_BLOCK) -#define gen_block(body, loc) \ - gen1(AST_BLOCK, body, loc) +#define block_error(x) return_a1(x, AST_BLOCK) +#define gen_block(body, err, loc) \ + gen2(AST_BLOCK, body, err, loc) #define str_val(x) return_s(x, AST_CONST_STR) #define gen_const_str(s, loc) \ @@ -420,6 +444,17 @@ static inline bool is_trivially_copyable(struct type *type) #define gen_if(cond, body, els, loc) \ gen3(AST_IF, cond, body, els, loc) +#define nil_var(x) return_s(x, AST_NIL) +#define nil_body(x) return_a1(x, AST_NIL) +#define nil_ref(x) return_a2(x, AST_NIL) +#define gen_nil(var, body, ref, loc) \ + gen_ast(AST_NIL, NULL, body, ref, NULL, NULL, var, 0, 0., loc) + +#define own_id(x) return_s(x, AST_OWN) +#define own_body(x) return_a1(x, AST_OWN) +#define gen_own(var, body, loc) \ + gen_ast(AST_OWN, NULL, body, NULL, NULL, NULL, var, 0, 0., loc) + #define id_str(x) return_s(x, AST_ID) #define gen_id(id, loc) \ gen_str(AST_ID, id, loc) diff --git a/include/fwd/scope.h b/include/fwd/scope.h index 6a78793..2e71cdb 100644 --- a/include/fwd/scope.h +++ b/include/fwd/scope.h @@ -32,6 +32,10 @@ struct visible { struct visible *next; }; +enum scope_flags { + SCOPE_PROC = (1 << 0), +}; + /** * Scope. * Responsible for keeping track of visibilities and @@ -60,6 +64,8 @@ struct scope { struct scope *children; struct visible *symbols; + + enum scope_flags flags; }; /** diff --git a/lib/fwdlib.hpp b/lib/fwdlib.hpp index 623dc13..51450c1 100644 --- a/lib/fwdlib.hpp +++ b/lib/fwdlib.hpp @@ -10,7 +10,9 @@ using namespace std; -static void fwd_getline(auto next) +typedef const char *fwd_err_t; + +static fwd_err_t fwd_getline(auto next) { if (cin.eof()) return next(optional<string>{}); @@ -21,13 +23,13 @@ static void fwd_getline(auto next) return next(optional<string>{}); } -static void fwd_foreach(auto container, auto next) +static fwd_err_t fwd_foreach(auto container, auto next) { for (auto &n : container) next(n); } -static void fwd_some(auto option, auto ok, auto fail) +static fwd_err_t fwd_some(auto option, auto ok, auto fail) { if (option) return ok(std::move(option.value())); @@ -35,12 +37,12 @@ static void fwd_some(auto option, auto ok, auto fail) return fail(); } -static void fwd_copy(auto n, auto next) +static fwd_err_t fwd_copy(auto n, auto next) { return next(n, n); } -static void fwd_null(auto *x, auto fail, auto ok) +static fwd_err_t fwd_null(auto *x, auto fail, auto ok) { if (x) return ok(*x); @@ -48,18 +50,19 @@ static void fwd_null(auto *x, auto fail, auto ok) return fail(); } -static void fwd_insert(auto container, auto elem, auto next) +static fwd_err_t fwd_insert(auto container, auto elem, auto next) { container.insert(std::move(elem)); return next(std::move(container)); } -static void fwd_println(auto elem) +static fwd_err_t fwd_println(auto elem) { cout << elem << endl; + return nullptr; } -static void fwd_intalloc(auto ok) +static fwd_err_t fwd_intalloc(auto ok) { int *p = new int{20}; ok(p); 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 |