Hojun-Cho
b6cf68f2b8
Param-decl `name: T...` (Tparam.variadic=1, type []T), call-site
gather of N args into a fresh `[N]T`, forward via `xs...`, full
selfhost mirror, and lib/fmt graduated to the Hare shape.
Frontend:
- parse: `T...` after a param's type stamps Node.op=TK_ELLIPSIS
and breaks out (variadic must be last).
- check: resolve_type N_TFN / build_fn_type wrap the param type
as []T and set tp->variadic. N_CALL accepts either a tail of
args assignable to T (gather) or a single `xs...` spread of
[]T (forward); both bypass the "too many args" check on the
variadic slot.
- type: type_eq compares Tparam.variadic.
Cgen (cstage):
- call site: when the callee has a variadic last param,
materialise the tail args into a frame-resident `[N]T` via
localoff, write a 24B slice descriptor (ptr,len,cap), and
splice a synthesised N_IDENT into args[] so the downstream
widen/eval/pop loops see one slice slot. Tagged-element types
route each store through cg_widen_tagged_store. Forwarding
skips gather: the N_SPREAD wrapper is replaced with its inner
slice expression. Empty form writes {nil,0,0}. args[] / widen[]
bump from 16 to 64 to accommodate Hare's mixed-arg printers.
Selfhost mirror:
- lib/ww/parse: `T...` mark on N_PARAM.op.
- cgen: varargseq counter on Cg; scanlocals reserves
@vararg_d_N + @vararg_sl_N per variadic call (seq recorded on
N_CALL.uval so cgcall picks the same names). cgcall does the
same gather/forward and N_IDENT splice. cgfnparams treats
variadic params as 24B slice slots via a synthesised TSLICE
tnode. pushargsrev skips the tagged-widen detection for
variadic params (effective type is []T, not tagged).
- rhstargetname now recognises N_TRUE/N_FALSE/N_RUNELIT and
typed N_INTLIT so the variant-tag lookup finds bool/rune/iN
variants instead of falling through to "first non-str" (which
misassigned tag 0 to bool in tagged unions like formattable).
lib/fmt graduated: print/println/fprint/fprintln/errorln/fatal
take `args: formattable...`. Bare `error` (no -ln) is skipped —
the leaf name collides with strconv's `type error = !(invalid |
overflow)` under the driver's flat namespace.
Tests: 5 new e2e rows (plain gather, zero-arg, tagged element,
forwarding, fmt.println end-to-end). lib/CLAUDE.md workaround
paragraph replaced with the Hare-shape description.
97 lines
3.0 KiB
Plaintext
97 lines
3.0 KiB
Plaintext
// fmt — formatting writers. Mirrors Hare's lib/fmt subset that fmt-
|
|
// prints values via [[io::handle]]-style fd writers. Call sites take
|
|
// Hare's variadic shape: `fmt.println(42, "hi", true)` gathers the
|
|
// args into a `[]formattable` slice; wrappers forward via `args...`.
|
|
|
|
use os;
|
|
use strconv;
|
|
use strings;
|
|
|
|
// formattable — tagged union of types fmt can render. Mirrors Hare's
|
|
// `fmt::formattable = (...types::numeric | uintptr | str | rune |
|
|
// bool | nullable *opaque | void)`, narrowed to the set ww actually
|
|
// has codegen for. Slot size is 24B (8 tag + 16 str payload).
|
|
export type formattable = (i64 | str | bool | rune);
|
|
|
|
// fprint — write the formatted form of each `args` element to `fd`,
|
|
// separated by spaces. Returns total bytes written or the first
|
|
// negative os.write result. Hare's separator-by-space matches.
|
|
export fn fprint(fd: i32, args: formattable...) i64 = {
|
|
let total: i64 = 0;
|
|
let i: i32 = 0;
|
|
for (i < args.len) {
|
|
if (i > 0) {
|
|
let r: i64 = os.write(fd, " ".ptr, 1u64);
|
|
if (r < 0) { return r; };
|
|
total += r;
|
|
};
|
|
match (args[i]) {
|
|
case let n: i64 => {
|
|
let s: str = strconv.i64tos(n, strconv.base.DEC);
|
|
let r: i64 = os.write(fd, s.ptr, s.len: u64);
|
|
if (r < 0) { return r; };
|
|
total += r;
|
|
};
|
|
case let s: str => {
|
|
let r: i64 = os.write(fd, s.ptr, s.len: u64);
|
|
if (r < 0) { return r; };
|
|
total += r;
|
|
};
|
|
case let b: bool => {
|
|
let s: str = "false";
|
|
if (b) { s = "true"; };
|
|
let r: i64 = os.write(fd, s.ptr, s.len: u64);
|
|
if (r < 0) { return r; };
|
|
total += r;
|
|
};
|
|
case let r: rune => {
|
|
let buf: [4]u8;
|
|
buf[0] = r: u8;
|
|
let n: i64 = os.write(fd, &buf[0], 1u64);
|
|
if (n < 0) { return n; };
|
|
total += n;
|
|
};
|
|
};
|
|
i += 1;
|
|
};
|
|
return total;
|
|
};
|
|
|
|
// fprintln — fprint plus a trailing newline.
|
|
export fn fprintln(fd: i32, args: formattable...) i64 = {
|
|
let n: i64 = fprint(fd, args...);
|
|
if (n < 0) { return n; };
|
|
let m: i64 = os.write(fd, "\n".ptr, 1u64);
|
|
if (m < 0) { return m; };
|
|
return n + m;
|
|
};
|
|
|
|
// print / println — fprint / fprintln on stdout. Direct counterparts
|
|
// of Hare's fmt::print / fmt::println.
|
|
export fn print(args: formattable...) i64 = {
|
|
return fprint(1, args...);
|
|
};
|
|
|
|
export fn println(args: formattable...) i64 = {
|
|
return fprintln(1, args...);
|
|
};
|
|
|
|
// errorln — fprintln on stderr. Hare's `fmt::error` (without -ln) is
|
|
// skipped here: the bare `error` name collides with strconv's
|
|
// `type error = !(invalid | overflow)` under the driver's flat
|
|
// concatenation namespace. Callers wanting the no-newline form use
|
|
// `fprint(2, args...)` directly.
|
|
export fn errorln(args: formattable...) i64 = {
|
|
return fprintln(2, args...);
|
|
};
|
|
|
|
// fatal — errorln then exit(255). `never` return marks the bottom
|
|
// type so flow-control checks treat callers as terminated. The
|
|
// fprintln result is dropped as an expression statement (Hare's
|
|
// `_ = fprintln(...)` wouldn't add safety here — process exit
|
|
// follows immediately).
|
|
export fn fatal(args: formattable...) never = {
|
|
fprintln(2, args...);
|
|
os.exit(255);
|
|
};
|