dymokomi/luce-base
Source of release 0.41.0
0.41.0 / src / back / ir / lower / text.lucb
#==============================================================================================
#
# lower/text - Text
#
# DESCRIPTION:
# Formatted text and string literals.
#
#==============================================================================================
extend Lowerer:
# mark: Text ===============================================================================
## A fresh `core.FormatBuffer` over `capacity` stack bytes: its address and the bytes'.
## A pooled buffer is a level of the dynamic area below the frame, reserved from here to
## the end of the statement (`stmt`): a recursive function whose error path formats a
## message keeps no kilobyte in every frame of the recursion. A `growing` buffer moves
## to the heap when its text outgrows it, and joins `grown` to be released.
func fresh_format_buffer(capacity: u32, growing: bool = false) -> (ir.Ref, ir.Ref)!:
var chars: u32 = 0
var fb: u32 = 0
if not self.pooling:
chars = try self.f.slot(capacity, 8)
fb = try self.f.slot(format_buffer_size, 8)
elif capacity == 1024 and self.pool_used < self.pool_count:
chars = self.pool_chars[self.pool_used]
fb = self.pool_fb[self.pool_used]
self.pool_used += 1
try self.reserve_levels()
elif capacity == 1024 and self.pool_count < self.pool_chars.length and self.pool_used == self.pool_count:
let level = u32(self.pool_count + 1)
chars = try self.f.dynamic_slot(level, 0, capacity, 8)
fb = try self.f.dynamic_slot(level, capacity, format_buffer_size, 8)
self.pool_chars[self.pool_count] = chars
self.pool_fb[self.pool_count] = fb
self.pool_count += 1
self.pool_used += 1
try self.reserve_levels()
else:
chars = try self.f.slot(capacity, 8)
fb = try self.f.slot(format_buffer_size, 8)
let chars_address = try self.slot_address(chars)
let fb_address = try self.slot_address(fb)
try self.f.store(ir.Op.storel, chars_address, fb_address)
try self.f.store(ir.Op.storel, ir.const_ref((i64)capacity), try self.offset_address(fb_address, 8))
try self.f.store(ir.Op.storel, ir.const_ref(0), try self.offset_address(fb_address, 16))
try self.f.store(ir.Op.storel, ir.const_ref(1 if growing else 0), try self.offset_address(fb_address, 24))
if growing:
try self.grown.push(fb)
return (fb_address, chars_address)
## `core.format_release` on each growing buffer of `grown` from `first` on: after the
## call they fed, or on an exit that leaves them.
func release_grown(first: usize) -> !:
var k = first
while k < self.grown.count:
let start = u32(self.f.args.count)
try self.f.args.push(ir.Arg(value = try self.slot_address(self.grown.get(k)), cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
_ = try self.call_named("lb_core_14format_release", start, 1, ir.Class.w, false, types.unit_id)
k += 1
## Append one value to the format buffer at `fb`.
func display(fb: ir.Ref, v: ast.Node*) -> !:
if v.has(ast.flag_format_sink):
# `value.display(__sink)` at a scalar or text: a `Display` parameter instantiated
# at a type the compiler displays itself (§14.4)
if let receiver = calls.sink_receiver(v):
if self.kind(try self.map(receiver.type_id)) != types.Kind.struct_:
try self.display(fb, receiver)
return
# `value.display(__sink)`: the sink is this buffer; a failed write leaves the
# buffer over capacity, which `format` reports
let saved = self.format_sink
self.format_sink = fb
_ = try self.expr(v)
self.format_sink = saved
return
var t = try self.ty(v)
if self.kind(t) == types.Kind.atomic:
# a plain read of `@T` is a load (§15.1)
t = self.elem(t)
let x = try self.value(v, t)
if t == types.bool_id:
let start = u32(self.f.args.count)
try self.f.args.push(ir.Arg(value = fb, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
try self.f.args.push(ir.Arg(value = x.ref, cls = ir.Class.w, size = 0, align = 4, type_id = types.bool_id, shape = 0))
_ = try self.call_named("lb_core_11format_bool", start, 2, ir.Class.w, true, types.i32_id)
return
if t == types.char_id:
let start = u32(self.f.args.count)
try self.f.args.push(ir.Arg(value = fb, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
try self.f.args.push(ir.Arg(value = x.ref, cls = ir.Class.w, size = 0, align = 4, type_id = types.char_id, shape = 0))
_ = try self.call_named("lb_core_11format_char", start, 2, ir.Class.w, true, types.i32_id)
return
if t == types.str_id or t == types.fmt_id:
let data = try self.f.load(ir.Op.loadl, ir.Class.l, x.ref)
let length = try self.f.load(ir.Op.loadl, ir.Class.l, try self.offset_address(x.ref, 8))
let start = u32(self.f.args.count)
try self.f.args.push(ir.Arg(value = fb, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
try self.f.args.push(ir.Arg(value = data, cls = ir.Class.l, size = 0, align = 8, type_id = types.cstr_id, shape = 0))
try self.f.args.push(ir.Arg(value = length, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
_ = try self.call_named("lb_core_10format_put", start, 3, ir.Class.w, true, types.i32_id)
return
if self.is_float(t) or t == types.untyped_float_id:
# an f32 or f16 shows the f32's own shortest digits, an f64 the f64's (§14)
let single = t == types.f32_id or t == types.f16_id
let width = types.f32_id if single else types.f64_id
let wide = try self.convert_float(x.ref, t, width)
let start = u32(self.f.args.count)
try self.f.args.push(ir.Arg(value = fb, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
try self.f.args.push(ir.Arg(value = wide, cls = ir.Class.s if single else ir.Class.d, size = 0, align = 4 if single else 8, type_id = width, shape = 0))
_ = try self.call_named("lb_core_10format_f32" if single else "lb_core_10format_f64", start, 2, ir.Class.w, true, types.i32_id)
return
let unsigned = self.is_ptr(t) or (self.is_int(t) and not self.is_signed(t)) or t == types.char_id or (self.c.is_backed_enum(t) and not self.signed_of(t)) or t == types.error_code_id or t == types.cstr_id
let word = try self.to_word(x.ref, t) if t != types.untyped_int_id and not self.is_ptr(t) and t != types.cstr_id else x.ref
let start = u32(self.f.args.count)
try self.f.args.push(ir.Arg(value = fb, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
try self.f.args.push(ir.Arg(value = word, cls = ir.Class.l, size = 0, align = 8, type_id = types.i64_id, shape = 0))
_ = try self.call_named("lb_core_10format_u64" if unsigned else "lb_core_10format_i64", start, 2, ir.Class.w, true, types.i32_id)
## The pieces of a formatted string appended to the buffer at `fb`.
func pieces(fb: ir.Ref, f: ast.Node*) -> !:
var part = f.body
while let p = part:
if p.kind == ast.Kind.format_text:
let text = literals.unescape_braces(literals.decode_text(p.text))
let index = try self.program_unit.text(text)
let data = try self.f.address_of(ir.text_ref(index))
let start = u32(self.f.args.count)
try self.f.args.push(ir.Arg(value = fb, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
try self.f.args.push(ir.Arg(value = data, cls = ir.Class.l, size = 0, align = 8, type_id = types.cstr_id, shape = 0))
try self.f.args.push(ir.Arg(value = ir.const_ref((i64)text.length), cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
_ = try self.call_named("lb_core_10format_put", start, 3, ir.Class.w, true, types.i32_id)
elif p.kind == ast.Kind.format_field:
let v = p.left else return
try self.display(fb, v)
part = p.next
## `print(f"...")`: the text streamed to standard output, then the newline.
func print_formatted(v: ast.Node*) -> !:
try self.stream_formatted(v, 1)
## `trap(message)`: a formatted message streams to the diagnostic, so its length is not
## bounded by a format buffer; any other text is passed whole.
func trap_call(arg: ast.Node*?) -> !:
var streamed: ast.Node*? = none
if let msg = arg:
if msg.kind == ast.Kind.formatted:
streamed = msg
if let msg = streamed:
let start = u32(self.f.args.count)
try self.f.args.push(ir.Arg(value = try self.f.address_of(try self.position_ref()), cls = ir.Class.l, size = 0, align = 8, type_id = types.cstr_id, shape = 0))
_ = try self.call_named("lb_core_13trap_begin_at", start, 1, ir.Class.w, false, types.unit_id)
try self.stream_formatted(msg, 2)
_ = try self.call_named("lb_core_8trap_end", u32(self.f.args.count), 0, ir.Class.w, false, types.unit_id)
elif let msg = arg:
let m = try self.expr(msg)
let start = u32(self.f.args.count)
let position = try self.position_ref()
try self.f.args.push(ir.Arg(value = try self.f.address_of(position), cls = ir.Class.l, size = 0, align = 8, type_id = types.cstr_id, shape = 0))
try self.f.args.push(try self.arg_of(LowerValue(ref = m.ref, type_id = types.str_id, in_memory = true)))
_ = try self.call_named("lb_core_12trap_text_at", start, 2, ir.Class.w, false, types.unit_id)
else:
try self.trap_with("trap")
## A formatted string streamed to `descriptor` through a format buffer that is written out
## as it fills (`core.stream_put`), then a newline: text and `str` fields of any length go
## whole, and every other field is displayed into the half of the buffer kept free.
func stream_formatted(f: ast.Node*, descriptor: i64) -> !:
let (fb, chars) = try self.fresh_format_buffer(1024)
_ = chars
var part = f.body
while let p = part:
part = p.next
if p.kind == ast.Kind.format_text:
let text = literals.unescape_braces(literals.decode_text(p.text))
let data = try self.f.address_of(ir.text_ref(try self.program_unit.text(text)))
try self.stream_put(fb, data, ir.const_ref((i64)text.length), descriptor)
elif p.kind == ast.Kind.format_field:
let v = p.left else return
let t = types.none_id if v.has(ast.flag_format_sink) else try self.ty(v)
if t == types.str_id or t == types.fmt_id:
let x = try self.value(v, t)
let data = try self.f.load(ir.Op.loadl, ir.Class.l, x.ref)
let length = try self.f.load(ir.Op.loadl, ir.Class.l, try self.offset_address(x.ref, 8))
try self.stream_put(fb, data, length, descriptor)
else:
try self.display(fb, v)
let newline = try self.f.address_of(ir.text_ref(try self.program_unit.text("\n")))
try self.stream_put(fb, newline, ir.const_ref(1), descriptor)
let start = u32(self.f.args.count)
try self.f.args.push(ir.Arg(value = fb, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
try self.f.args.push(ir.Arg(value = ir.const_ref(descriptor), cls = ir.Class.w, size = 0, align = 4, type_id = types.i32_id, shape = 0))
_ = try self.call_named("lb_core_12stream_flush", start, 2, ir.Class.w, false, types.unit_id)
## `core.stream_put(fb, data, length, descriptor)`.
func stream_put(fb: ir.Ref, data: ir.Ref, length: ir.Ref, descriptor: i64) -> !:
let start = u32(self.f.args.count)
try self.f.args.push(ir.Arg(value = fb, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
try self.f.args.push(ir.Arg(value = data, cls = ir.Class.l, size = 0, align = 8, type_id = types.cstr_id, shape = 0))
try self.f.args.push(ir.Arg(value = length, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
try self.f.args.push(ir.Arg(value = ir.const_ref(descriptor), cls = ir.Class.w, size = 0, align = 4, type_id = types.i32_id, shape = 0))
_ = try self.call_named("lb_core_10stream_put", start, 4, ir.Class.w, false, types.unit_id)
## A formatted string as `str` in a stack buffer; an argument's (`growing`) goes on in
## the heap past it, until the call returns.
func formatted_value(f: ast.Node*, growing: bool = false) -> LowerValue!:
let (fb, chars) = try self.fresh_format_buffer(1024, growing)
try self.pieces(fb, f)
let start = u32(self.f.args.count)
try self.f.args.push(ir.Arg(value = fb, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
_ = chars
return try self.call_aggregate("lb_core_13format_finish", start, 1, types.fmt_id)
## `strings.format(buffer, text)` into the caller's bytes, yielding `str!`.
func format_call(buf: ast.Node*, msg: ast.Node*) -> LowerValue!:
let bv = try self.value(buf, try self.c.table.span(types.u8_id, false))
let fb_slot = try self.f.slot(format_buffer_size, 8)
let fb = try self.slot_address(fb_slot)
let data = try self.f.load(ir.Op.loadl, ir.Class.l, bv.ref)
let length = try self.f.load(ir.Op.loadl, ir.Class.l, try self.offset_address(bv.ref, 8))
try self.f.store(ir.Op.storel, data, fb)
try self.f.store(ir.Op.storel, length, try self.offset_address(fb, 8))
try self.f.store(ir.Op.storel, ir.const_ref(0), try self.offset_address(fb, 16))
try self.f.store(ir.Op.storel, ir.const_ref(0), try self.offset_address(fb, 24))
if msg.kind == ast.Kind.formatted:
try self.pieces(fb, msg)
else:
try self.display(fb, msg)
let result = try self.c.table.fallible(types.str_id)
let slot = try self.new_slot(result)
let a = try self.slot_address(slot)
let used = try self.f.load(ir.Op.loadl, ir.Class.l, try self.offset_address(fb, 16))
let cap = try self.f.load(ir.Op.loadl, ir.Class.l, try self.offset_address(fb, 8))
let over = try self.f.binary(ir.Op.cugt, ir.Class.l, used, cap)
let bad = self.f.label()
let good = self.f.label()
let done = self.f.label()
try self.f.branch(over, bad, good)
try self.f.place_label(bad)
try self.store_error(a, result, (i64)check.exhausted_code(), "memory.exhausted: the formatted text does not fit its buffer")
try self.f.jump(done)
try self.f.place_label(good)
let start = u32(self.f.args.count)
try self.f.args.push(ir.Arg(value = fb, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
let text = try self.call_aggregate("lb_core_13format_finish", start, 1, types.str_id)
try self.f.copy_bytes(a, text.ref, 16)
try self.f.store(ir.Op.storeb, ir.const_ref(0), try self.offset_address(a, self.failed_offset(result)))
try self.f.jump(done)
try self.f.place_label(done)
return LowerValue(ref = a, type_id = result, in_memory = true)
## `value.hash()` over the runtime's mixer.
## `v.hash()` (§14.4): equal values hash the same, so an aggregate hashes its members in
## the order `==` compares them, text its bytes, a float its bits with both zeros as one,
## and a pointer its address; the C backend folds the same way.
func hash_of(v: ast.Node*) -> LowerValue!:
let t = try self.ty(v)
let x = try self.expr(v)
let seed = try self.call_named("lb_core_9hash_seed", u32(self.f.args.count), 0, ir.Class.l, true, types.u64_id)
let h = try self.hash_at(x.ref, t, seed) if x.in_memory else try self.hash_word(x.ref, t, seed)
return LowerValue(ref = h, type_id = types.u64_id, in_memory = false)
## `core.hash_mix(seed, word)`.
func hash_mix(seed: ir.Ref, word: ir.Ref) -> ir.Ref!:
let start = u32(self.f.args.count)
try self.f.args.push(ir.Arg(value = seed, cls = ir.Class.l, size = 0, align = 8, type_id = types.u64_id, shape = 0))
try self.f.args.push(ir.Arg(value = word, cls = ir.Class.l, size = 0, align = 8, type_id = types.u64_id, shape = 0))
return try self.call_named("lb_core_8hash_mix", start, 2, ir.Class.l, true, types.u64_id)
## `core.hash_bytes(seed, data, count)`.
func hash_bytes(seed: ir.Ref, data: ir.Ref, count: ir.Ref) -> ir.Ref!:
let start = u32(self.f.args.count)
try self.f.args.push(ir.Arg(value = seed, cls = ir.Class.l, size = 0, align = 8, type_id = types.u64_id, shape = 0))
try self.f.args.push(ir.Arg(value = data, cls = ir.Class.l, size = 0, align = 8, type_id = types.cstr_id, shape = 0))
try self.f.args.push(ir.Arg(value = count, cls = ir.Class.l, size = 0, align = 8, type_id = types.usize_id, shape = 0))
return try self.call_named("lb_core_10hash_bytes", start, 3, ir.Class.l, true, types.u64_id)
## The hash of the scalar `x` of type `t` folded onto `seed`: its bits, a float's with
## both zeros as one.
func hash_word(x: ir.Ref, t: u32, seed: ir.Ref) -> ir.Ref!:
var word = x
if self.is_float(t):
word = try self.f.unary(ir.Op.cast, ir.Class.l if t == types.f64_id else ir.Class.w, x)
if t != types.f64_id:
word = try self.f.unary(ir.Op.extuw, ir.Class.l, word)
# the negative zero's bits become the positive zero's: a mask of ones otherwise
let negative_zero: i64 = -9223372036854775807 - 1 if t == types.f64_id else (2147483648 if t == types.f32_id else 32768)
let is_negative_zero = try self.f.binary(ir.Op.ceq, ir.Class.l, word, ir.const_ref(negative_zero))
let flag = try self.f.unary(ir.Op.extuw, ir.Class.l, is_negative_zero)
let keep = try self.f.binary(ir.Op.sub, ir.Class.l, flag, ir.const_ref(1))
word = try self.f.binary(ir.Op.and_, ir.Class.l, word, keep)
elif t != types.untyped_int_id and not self.is_ptr(t) and t != types.cstr_id and self.class_of(t) == ir.Class.w:
word = try self.f.unary(ir.Op.extuw, ir.Class.l, x)
return try self.hash_mix(seed, word)
## The hash of the value of type `t` at address `a` folded onto `seed`, member by member.
func hash_at(a: ir.Ref, t: u32, seed: ir.Ref) -> ir.Ref!:
if t == types.str_id or t == types.fmt_id:
let data = try self.f.load(ir.Op.loadl, ir.Class.l, a)
let length = try self.f.load(ir.Op.loadl, ir.Class.l, try self.offset_address(a, 8))
return try self.hash_bytes(seed, data, length)
if self.is_scalar(t):
let x = try self.load_from(a, t)
return try self.hash_word(x.ref, t, seed)
let tt = self.c.table.get(t)
if self.is_tagged_opt(t):
return try self.hash_optional(a, t, seed)
if tt.kind == types.Kind.struct_ or tt.kind == types.Kind.tuple:
return try self.hash_fields(a, t, seed)
if tt.kind == types.Kind.array:
return try self.hash_elements(a, t, seed)
if tt.kind == types.Kind.enum_ and tt.decl != none:
return try self.hash_payload(a, t, seed)
return try self.hash_bytes(seed, a, ir.const_ref((i64)self.size(t)))
## An optional: `present` folded first, then the value when there is one.
func hash_optional(a: ir.Ref, t: u32, seed: ir.Ref) -> ir.Ref!:
let et = self.elem(t)
let present = try self.f.load(ir.Op.loadub, ir.Class.w, try self.offset_address(a, (u64)self.c.table.size_of(et)))
let slot = try self.f.slot(8, 8)
let out = try self.slot_address(slot)
let some = self.f.label()
let none_label = self.f.label()
let done = self.f.label()
try self.f.branch(present, some, none_label)
try self.f.place_label(some)
let with_value = try self.hash_at(a, et, try self.hash_mix(seed, ir.const_ref(1)))
try self.f.store(ir.Op.storel, with_value, try self.slot_address(slot))
try self.f.jump(done)
try self.f.place_label(none_label)
try self.f.store(ir.Op.storel, try self.hash_mix(seed, ir.const_ref(0)), out)
try self.f.jump(done)
try self.f.place_label(done)
return try self.f.load(ir.Op.loadl, ir.Class.l, try self.slot_address(slot))
## A struct's fields or a tuple's members, in order, at their offsets.
func hash_fields(a: ir.Ref, t: u32, seed: ir.Ref) -> ir.Ref!:
let tt = self.c.table.get(t)
var h = seed
var offset: u64 = 0
if tt.kind == types.Kind.tuple:
for at in tt.args:
let ft = try self.map(at)
offset = lower_round_up(offset, self.c.table.align_of(ft))
h = try self.hash_at(try self.offset_address(a, offset), ft, h)
offset += self.c.table.size_of(ft)
return h
let d = tt.decl else return try self.hash_bytes(seed, a, ir.const_ref((i64)self.size(t)))
var cursor = d.body
while let m = cursor:
if m.kind == ast.Kind.field:
let ft = try self.map(try self.c.substitute(m.type_id, d, tt.args))
if not d.has(ast.flag_packed):
offset = lower_round_up(offset, self.c.table.field_alignment(ft, m))
h = try self.hash_at(try self.offset_address(a, offset), ft, h)
offset += self.c.table.size_of(ft)
cursor = m.next
return h
## An array's elements in order, the running hash in a slot across the loop.
func hash_elements(a: ir.Ref, t: u32, seed: ir.Ref) -> ir.Ref!:
let tt = self.c.table.get(t)
let et = try self.map(tt.elem)
let stride = (u64)self.c.table.size_of(et)
let slot = try self.f.slot(8, 8)
try self.f.store(ir.Op.storel, seed, try self.slot_address(slot))
let counting = try self.count_up((i64)tt.length)
let i = counting.index
let element = try self.f.binary(ir.Op.add, ir.Class.l, a, try self.f.binary(ir.Op.mul, ir.Class.l, i, ir.const_ref((i64)stride)))
let so_far = try self.f.load(ir.Op.loadl, ir.Class.l, try self.slot_address(slot))
try self.f.store(ir.Op.storel, try self.hash_at(element, et, so_far), try self.slot_address(slot))
try self.count_on(counting)
return try self.f.load(ir.Op.loadl, ir.Class.l, try self.slot_address(slot))
## A payload enum: the tag, then the payload of the case it carries.
func hash_payload(a: ir.Ref, t: u32, seed: ir.Ref) -> ir.Ref!:
let tt = self.c.table.get(t)
let d = tt.decl else return try self.hash_bytes(seed, a, ir.const_ref((i64)self.size(t)))
let tag = try self.f.load(ir.Op.loadsw, ir.Class.w, a)
let slot = try self.f.slot(8, 8)
try self.f.store(ir.Op.storel, try self.hash_mix(seed, try self.f.unary(ir.Op.extuw, ir.Class.l, tag)), try self.slot_address(slot))
let done = self.f.label()
let base = self.payload_offset(t)
var cursor = d.body
while let c = cursor:
if c.kind == ast.Kind.enum_case and c.body != none:
let this_case = try self.f.binary(ir.Op.ceq, ir.Class.w, tag, ir.const_ref((i64)instances.case_tag(d, c)))
let here = self.f.label()
let next = self.f.label()
try self.f.branch(this_case, here, next)
try self.f.place_label(here)
var offset: u64 = 0
var h = try self.f.load(ir.Op.loadl, ir.Class.l, try self.slot_address(slot))
var param = c.body
while let q = param:
let pt = try self.map(try self.c.substitute(q.type_id, d, tt.args))
offset = lower_round_up(offset, self.c.table.align_of(pt))
h = try self.hash_at(try self.offset_address(a, base + offset), pt, h)
offset += self.c.table.size_of(pt)
param = q.next
try self.f.store(ir.Op.storel, h, try self.slot_address(slot))
try self.f.jump(done)
try self.f.place_label(next)
cursor = c.next
try self.f.jump(done)
try self.f.place_label(done)
return try self.f.load(ir.Op.loadl, ir.Class.l, try self.slot_address(slot))