dymokomi/luce-base
Source of release 0.45.0
0.45.0 / src / back / c / emit / branching.lucb
#==============================================================================================
#
# emit/branching - Failure and matching
#
# DESCRIPTION:
# `try`, `else`, and `catch` over fallible and optional values (§11), and `match` as a
# statement and as an expression.
#
#==============================================================================================
extend Emitter:
# mark: Failure and matching ===============================================================
## `try x`: the value, or the caller's failure returned with cleanup run.
func try_expr(e: ast.Node*) -> !:
let inner = e.left else return
let ft = try self.ty(inner)
let payload = self.elem(ft)
let n = self.tmp()
try self.put("({ ")
try self.put_type(ft)
try self.put(" ")
try self.put_tmp("r", n)
try self.put(" = ")
try self.expr(inner)
try self.put("; if (")
try self.put_tmp("r", n)
try self.put(".failed) {")
self.indent += 1
if e.has(ast.flag_crossing):
# the error comes into this package out of another's function (§11.3)
try self.line("")
try self.put_tmp("r", n)
try self.put(".error.m.called = lb_here();")
# a failure leaving a handler takes the place of the handled error's message
let handler = self.left_handler()
if handler != 0:
try self.line("lb_message_set(&")
try self.put_tmp("r", n)
try self.put(".error, lb_core_14message_raised(lb_message_of(")
try self.put_tmp("r", n)
try self.put(".error), ")
try self.put_replaced(handler, 0)
try self.put("));")
if self.failure_target != 0:
try self.line("")
try self.put_tmp("fe", self.failure_target)
try self.put(" = ")
try self.put_tmp("r", n)
try self.put(".error;")
try self.unwind_from(self.failure_scope, true)
try self.line("goto ")
try self.put_tmp("fh", self.failure_target)
try self.put(";")
else:
try self.unwind_from(0, true)
try self.line("return ")
if self.fn_fallible():
try self.put("((")
try self.put_result_type(self.current_fn else return)
try self.put("){ .error = ")
try self.put_tmp("r", n)
try self.put(".error, .failed = true })")
else:
try self.put_tmp("r", n)
try self.put(";")
self.indent -= 1
try self.line("} ")
if payload == types.unit_id or payload == types.never_id:
try self.put("(void)0; })")
else:
try self.put_tmp("r", n)
try self.put(".value; })")
## `x else y`: the payload of an optional or fallible, or the alternative.
func else_expr(e: ast.Node*) -> !:
let l = e.left else return
let r = e.right else return
let lt = try self.ty(l)
let payload = self.elem(lt)
let n = self.tmp()
let leaves = r.kind == ast.Kind.return_ or r.kind == ast.Kind.break_ or r.kind == ast.Kind.continue_ or calls.is_error_call(r) or calls.is_trap_call(r) or r.type_id == types.never_id
try self.put("({ ")
try self.put_type(lt)
try self.put(" ")
try self.put_tmp("o", n)
try self.put(" = ")
try self.expr(l)
try self.put("; ")
var present_test = "present"
if self.is_fail(lt):
try self.put("if (")
try self.put_tmp("o", n)
try self.put(".failed) ")
elif self.is_tagged_opt(lt):
try self.put("if (!")
try self.put_tmp("o", n)
try self.put(".present) ")
elif self.is_nullable_view(lt):
try self.put("if (")
try self.put_tmp("o", n)
try self.put(".data == ((void*)0)) ")
else:
try self.put("if (")
try self.put_tmp("o", n)
try self.put(" == ((void*)0)) ")
# a fallible operand's error is handled here: an `error` alternative takes its
# message's place, any other gives the message back (§11.3)
let gives_back = self.is_fail(lt) and not calls.is_error_call(r) and not calls.is_trap_call(r)
if leaves:
try self.put("{")
self.indent += 1
if gives_back:
try self.line("lb_core_15message_handled(lb_message_of(")
try self.put_tmp("o", n)
try self.put(".error));")
if calls.is_error_call(r):
if self.is_fail(lt):
self.else_replaced = n + 1
try self.error_return(r)
elif r.kind == ast.Kind.return_:
try self.return_stmt(r)
elif r.kind == ast.Kind.break_ or r.kind == ast.Kind.continue_:
try self.jump(r)
else:
try self.line("(void)(")
try self.expr(r)
try self.put(");")
self.indent -= 1
try self.line("} ")
else:
try self.put("{ ")
if gives_back:
try self.put("lb_core_15message_handled(lb_message_of(")
try self.put_tmp("o", n)
try self.put(".error)); ")
if payload != types.unit_id:
try self.put_tmp("o", n)
if self.is_fail(lt):
try self.put(".value = ")
elif self.is_tagged_opt(lt):
try self.put(".value = ")
else:
try self.put(" = ")
try self.value(r, payload)
try self.put("; ")
else:
try self.put("(void)(")
try self.expr(r)
try self.put("); ")
try self.put("} ")
if payload == types.unit_id or payload == types.never_id:
try self.put("(void)0; })")
else:
try self.put_tmp("o", n)
if self.is_fail(lt) or self.is_tagged_opt(lt):
try self.put(".value; })")
else:
try self.put("; })")
_ = present_test
## `x catch name:` with its handler as statements.
func catch_expr(e: ast.Node*) -> !:
let l = e.left else return
let body = e.body else return
let result = try self.ty(e)
let has_value = result != types.unit_id and result != types.never_id
let n = self.tmp()
let saved_target = self.failure_target
let saved_failure_scope = self.failure_scope
let saved_var = self.catch_var
let saved_done = self.catch_done
let saved_scope = self.catch_scope
let saved_payload = self.catch_payload
let saved_in = self.in_catch
try self.put("({ lb_error ")
try self.put_tmp("fe", n)
try self.put(" __attribute__((unused)); ")
try self.put_type(result if has_value else types.i32_id)
try self.put(" ")
try self.put_tmp("v", n)
try self.put(" __attribute__((unused)) = ")
try self.zero_value(result if has_value else types.i32_id)
try self.put("; ")
if has_value:
try self.put_tmp("v", n)
try self.put(" = ")
self.failure_target = n
self.failure_scope = self.scopes.count
if has_value:
try self.value(l, result)
else:
try self.put("(void)(")
try self.expr(l)
try self.put(")")
self.failure_target = saved_target
self.failure_scope = saved_failure_scope
try self.put("; goto ")
try self.put_tmp("cd", n)
try self.put("; ")
try self.put_tmp("fh", n)
try self.put(": { ")
self.indent += 1
if e.text.length > 0:
try self.line("lb_error ")
try self.put_ident(e.text)
try self.put(" __attribute__((unused)) = ")
try self.put_tmp("fe", n)
try self.put(";")
self.catch_var = n
self.catch_done = n
self.catch_scope = self.scopes.count
self.catch_payload = result
self.in_catch = true
try self.handler_block(body, n)
self.catch_var = saved_var
self.catch_done = saved_done
self.catch_scope = saved_scope
self.catch_payload = saved_payload
self.in_catch = saved_in
self.indent -= 1
try self.line("} ")
try self.put_tmp("cd", n)
try self.put(": __attribute__((unused)); ")
if has_value:
try self.put_tmp("v", n)
try self.put("; })")
else:
try self.put("(void)0; })")
## A `catch` handler's body: a scope that gives back the message of the error in
## `fe<n>` on every exit but a failure's (§11.3).
func handler_block(b: ast.Node*, n: u32) -> !:
try self.line("{")
self.indent += 1
try self.push_scope(false, "")
var sc = self.scopes.get(self.scopes.count - 1)
sc.handler = true
sc.handled = n
self.scopes.set(self.scopes.count - 1, sc)
var cursor = b.body
while let s = cursor:
try self.stmt(s)
cursor = s.next
try self.unwind(self.scopes.count - 1, false)
self.pop_scope()
self.indent -= 1
try self.line("}")
# -- match ----------------------------------------------------------------------------
## `match` as a statement (`dest` 0) or filling the expression temporary `dest`.
func match_stmt(m: ast.Node*, dest: u32) -> !:
let scrutinee = m.left else return
let st = try self.ty(scrutinee)
let n = self.tmp()
try self.line("")
try self.put_type(st)
try self.put(" ")
try self.put_tmp("m", n)
# `match true:` with guarded `_` arms never reads its subject; C must not object
try self.put(" __attribute__((unused)) = ")
try self.value(scrutinee, st)
try self.put(";")
# a guarded arm may repeat a value, a case or a `_`, which C's `switch` cannot: those
# go to the chain
if (self.is_int(st) or self.c.is_backed_enum(st) or st == types.bool_id or st == types.char_id) and not has_guard(m):
try self.match_switch(m, st, n, dest)
elif self.kind(st) == types.Kind.enum_ and not has_guard(m):
try self.match_tags(m, st, n, dest)
else:
try self.match_chain(m, st, n, dest)
## A `match` on a value C can switch on: a `case` per value or range, `default` for `_`.
func match_switch(m: ast.Node*, st: u32, n: u32, dest: u32) -> !:
try self.line("switch ((int64_t)(")
try self.put_tmp("m", n)
try self.put(")) {")
self.indent += 1
var arm = m.body
while let a = arm:
var pattern = a.left
while let p = pattern:
if p.has(ast.flag_wildcard):
try self.line("default:")
elif let v = p.left:
if let resolved = v.resolved:
if resolved.kind == ast.Kind.enum_case:
let d = self.decl_of(st) else return
# The switch is on int64_t: a case is its signed value, and
# INT64_MIN has no literal of its own in C.
let signed = (i64)types.case_value(d, resolved)
try self.line("case ")
if signed == -9223372036854775807 - 1:
try self.put("(-9223372036854775807LL - 1)")
else:
try self.put_i64(signed)
try self.put("LL")
try self.put(":")
pattern = p.next
continue
if let hi = p.right:
try self.line("case ")
try self.value(v, st)
try self.put(" ... ")
if p.text == "..<":
try self.put("(")
try self.value(hi, st)
try self.put(" - 1)")
else:
try self.value(hi, st)
try self.put(":")
else:
try self.line("case ")
try self.value(v, st)
try self.put(":")
pattern = p.next
try self.arm_body(a, dest, n, true)
arm = a.next
self.indent -= 1
try self.line("}")
## A `match` on an enum with payloads: a `case` per tag, its payload's names bound in
## the arm.
func match_tags(m: ast.Node*, st: u32, n: u32, dest: u32) -> !:
let d = self.decl_of(st) else return
try self.line("switch ((int)(")
try self.put_tmp("m", n)
try self.put(".tag)) {")
self.indent += 1
var arm = m.body
while let a = arm:
var pattern = a.left
var payload_pattern: ast.Node*? = none
while let p = pattern:
if p.has(ast.flag_wildcard):
try self.line("default:")
elif let v = p.left:
if let resolved = v.resolved:
try self.line("case ")
try self.put_u64((u64)instances.case_tag(d, resolved))
try self.put(":")
if v.body != none:
payload_pattern = p
pattern = p.next
try self.line("{")
self.indent += 1
if let p = payload_pattern:
if let v = p.left:
if let resolved = v.resolved:
try self.bind_payload_names(v, resolved, n)
try self.arm_body(a, dest, n, false)
if a.right == none:
try self.line("break;")
self.indent -= 1
try self.line("}")
arm = a.next
self.indent -= 1
try self.line("}")
## A `match` C cannot switch on (text, pointers, optionals, guarded arms): a chain of
## tests, each arm's patterns joined by `||` and its guard by `&&`.
func match_chain(m: ast.Node*, st: u32, n: u32, dest: u32) -> !:
var first = true
var arm = m.body
while let a = arm:
try self.line("")
if not first:
try self.put("else ")
first = false
try self.put("if (")
var any = false
var pattern = a.left
while let p = pattern:
if any:
try self.put(" || ")
any = true
if p.has(ast.flag_wildcard):
try self.put("1")
elif let v = p.left:
try self.pattern_test(p, v, st, n)
try self.put("))")
pattern = p.next
if not any:
try self.put("0")
if let guard = a.right:
# a failed guard falls to the next arm: the guard joins the test, with the
# arm's names bound for it
try self.put(" && ({ ")
try self.bind_arm_names(a, st, n)
try self.put(" !!(")
try self.value(guard, types.bool_id)
try self.put("); })")
try self.put(") {")
self.indent += 1
try self.bind_arm_names(a, st, n)
try self.arm_body(a, dest, n, false)
self.indent -= 1
try self.line("}")
arm = a.next
## The test of one pattern `p` (value `v`) against the subject `m<n>` of type `st`.
func pattern_test(p: ast.Node*, v: ast.Node*, st: u32, n: u32) -> !:
# `!!` keeps clang from seeing an `==` in doubled parentheses
try self.put("(!!(")
if v.kind == ast.Kind.case_value and v.resolved == none and (self.is_tagged_opt(st) or self.is_nullable_ptr(st) or self.is_nullable_view(st)):
# `.some` and `.none` test the optional's presence (§8.4)
if v.text == "none":
try self.put("!")
try self.put_tmp("m", n)
if self.is_tagged_opt(st):
try self.put(".present")
elif self.is_nullable_view(st):
try self.put(".data")
elif v.kind == ast.Kind.case_value and self.kind(st) == types.Kind.enum_ and self.c.is_backed_enum(st):
# an integer-backed enum is its representation: compare the value
let d = self.decl_of(st) else return
let resolved = v.resolved else return
try self.put_tmp("m", n)
try self.put(" == (")
try self.put_type(st)
try self.put(")")
try self.put_u64(types.case_value(d, resolved))
try self.put("ull")
elif v.kind == ast.Kind.case_value and self.kind(st) == types.Kind.enum_:
let d = self.decl_of(st) else return
let resolved = v.resolved else return
try self.put_tmp("m", n)
try self.put(".tag == ")
try self.put_u64((u64)instances.case_tag(d, resolved))
elif st == types.str_id:
let k = self.tmp()
try self.put("({ lb_str ")
try self.put_tmp("sb", k)
try self.put(" = ")
try self.value(v, st)
try self.put("; ")
try self.put_tmp("m", n)
try self.put(".length == ")
try self.put_tmp("sb", k)
try self.put(".length && (")
try self.put_tmp("m", n)
try self.put(".length == 0 || memcmp(")
try self.put_tmp("m", n)
try self.put(".data, ")
try self.put_tmp("sb", k)
try self.put(".data, ")
try self.put_tmp("m", n)
try self.put(".length) == 0); })")
elif let hi = p.right:
# `lo..<hi` and `lo..=hi` in the chain: both bounds (§8.4)
try self.put_tmp("m", n)
try self.put(" >= ")
try self.value(v, st)
try self.put(" && ")
try self.put_tmp("m", n)
try self.put(" < " if p.text == "..<" else " <= ")
try self.value(hi, st)
else:
try self.put_tmp("m", n)
try self.put(" == ")
try self.value(v, st)
## The names an arm's first pattern binds, in the chain form: `.some(name)` over an
## optional takes the value; `.case(names)` over an enum takes the payload's fields.
func bind_arm_names(a: ast.Node*, st: u32, n: u32) -> !:
let p = a.left else return
let v = p.left else return
if v.kind != ast.Kind.case_value:
return
if v.resolved == none and (self.is_tagged_opt(st) or self.is_nullable_ptr(st) or self.is_nullable_view(st)):
if v.text != "some":
return
let nm = v.body else return
if nm.text == "_":
return
try self.line("")
try self.put_type(self.elem(st))
try self.put(" ")
try self.put_ident(nm.text)
try self.put(" __attribute__((unused)) = ")
try self.put_tmp("m", n)
if self.is_tagged_opt(st):
try self.put(".value")
try self.put(";")
return
let resolved = v.resolved else return
try self.bind_payload_names(v, resolved, n)
## The names a case pattern `v` binds to the payload fields of `case_decl`, read from the
## matched value `m<n>`; `_` binds nothing.
func bind_payload_names(v: ast.Node*, case_decl: ast.Node*, n: u32) -> !:
var name = v.body
var param = case_decl.body
while let nm = name:
let q = param else break
if nm.text != "_":
try self.line("")
try self.put_type(try self.map(nm.type_id))
try self.put(" ")
try self.put_ident(nm.text)
try self.put(" __attribute__((unused)) = ")
try self.put_tmp("m", n)
try self.put(".u.")
try self.put(try c_field_name(case_decl.text))
try self.put(".")
try self.put(try c_field_name(q.text))
try self.put(";")
name = nm.next
param = q.next
## The body of one arm, with its guard; `in_switch` adds the `break`.
func arm_body(a: ast.Node*, dest: u32, n: u32, in_switch: bool) -> !:
if in_switch:
try self.line("{")
self.indent += 1
# in the chain form the guard is part of the arm's test already
if in_switch:
if let guard = a.right:
try self.line("if (!!(")
try self.value(guard, types.bool_id)
try self.put(")) {")
self.indent += 1
if dest != 0:
let body = a.body else return
try self.line("")
try self.put_tmp("mr", dest)
try self.put(" = ")
try self.value(body, self.match_result)
try self.put(";")
elif let body = a.body:
try self.block(body)
if a.right != none and in_switch:
try self.line("break;")
self.indent -= 1
try self.line("}")
elif in_switch:
try self.line("break;")
if in_switch:
self.indent -= 1
try self.line("}")
_ = n
func match_expr(m: ast.Node*) -> !:
let t = try self.ty(m)
let n = self.tmp()
let saved = self.match_result
self.match_result = t
try self.put("({")
self.indent += 1
try self.line("")
try self.put_type(t)
try self.put(" ")
try self.put_tmp("mr", n)
try self.put(" = ")
try self.zero_value(t)
try self.put(";")
try self.match_stmt(m, n)
try self.line("")
try self.put_tmp("mr", n)
try self.put(";")
self.indent -= 1
try self.line("})")
self.match_result = saved