@scriptc/compiler 0.0.0 → 0.0.1

package/dist/backend/emission/emit-stmts.d.ts

@@ -0,0 +1,78 @@
+import type { CEmitter, ScopeEntry } from "./emitter.js";
+import type { IrFunction } from "../../ir/nodes.js";
+import { IrExpr, IrStmt } from "../../ir/nodes.js";
+export declare function emitFunction(E: CEmitter, fn: IrFunction): void;
+/** Emits a block in its own lexical scope (refcounted locals released at
+   * end). `setup` runs after the scope opens, before the statements — the
+   * catch-binding hook: it may emit prelude lines and register entries the
+   * scope owns (released on every exit, jumps and unwinds included). */
+export declare function emitBlock(E: CEmitter, stmts: IrStmt[], setup?: (scope: ScopeEntry[]) => void): void;
+export declare function emitStmts(E: CEmitter, stmts: IrStmt[]): void;
+export declare function emitStmt(E: CEmitter, s: IrStmt): void;
+/** try/catch/finally via pending-flag unwinding. Entering a try emits NO
+   * code: the try context is compile-time state (tryStack) that redirects
+   * unwinds inside the region to a label here instead of out of the
+   * function. Shape:
+   *
+   *   { try body }          unwinds inside release frames/scopes down to
+   *                         this statement's depths, then goto the handler
+   *   goto after;           (normal completion skips the handler)
+   *   sc_catch_N:;         (emitted only when some unwind targets it)
+   *     scr_exc_clear();   catch TAKES the exception (payload discarded —
+   *     { catch body }      the supported catch form is bindingless)
+   *   after/sc_fin_N:;
+   *   { finally body }      normal path
+   *   goto sc_tryend_N;
+   *   sc_finexc_N:;        exception path: pending flag still set
+   *   { finally body }      (emitted twice — fresh temps/labels each time;
+   *   <unwind>               duplication is safe, and the pending flag is
+   *   sc_tryend_N:;         the dispatch)
+   *
+   * Without a catch, unwinds in the try body target sc_finexc_N directly.
+   * A catch body's own exceptions target sc_finexc_N (when a finally
+   * exists) or the ENCLOSING context — never its own handler. After the
+   * exception-path finally, propagation continues (emitUnwind: enclosing
+   * handler or dummy return). A `return` inside the try/catch body rides a
+   * THIRD finally copy (sc_finret_N — the pending-return path: value
+   * snapshotted into sc_pret at the return site, dispatch outward after
+   * the copy runs); break/continue never cross a finally and no jump
+   * leaves a finally body (frontend fence + validator backstop), so
+   * normal, exception, and pending-return are the only paths a finally
+   * must model; jumps out of PLAIN try/catch need nothing here —
+   * release-on-jump already walks the try scopes. */
+export declare function emitTryCatch(E: CEmitter, s: IrStmt & {
+    kind: "tryCatch";
+}): void;
+/** JS-exact switch as a goto chain — C `switch` cannot express lazily
+   * evaluated, arbitrary-expression case tests. Shape:
+   *
+   *   disc temp
+   *   NULL-reset of refcounted case-body locals   (see below)
+   *   per test, in source order: eval test; if (== disc) goto case_i;
+   *   goto default (or end when there is none)
+   *   case_0:; body_0   ─┐ bodies in source order fall through
+   *   case_1:; body_1   ─┘ naturally, JS-exact
+   *   scope releases (natural fall-off path)
+   *   end:;                (break jumps here, after releasing scopes itself)
+   *
+   * All case bodies share ONE scope (JS: one lexical scope per switch body).
+   * Because dispatch can jump PAST a varDecl into a later case, a refcounted
+   * local of a skipped body is never written — and inside an enclosing loop
+   * it still holds the pointer a previous iteration's scope exit already
+   * released. The declarations are therefore NULL-reset up front; the
+   * scope-exit releases rely on the runtime's NULL-tolerant release calls. */
+export declare function emitSwitch(E: CEmitter, s: IrStmt & {
+    kind: "switch";
+}): void;
+/** Emits `if (cond) ` followed by a block on the same line for readability. */
+export declare function mergeBrace(E: CEmitter, emitBlockFn: () => void): void;
+/** Evaluates `expr` in its own statement frame inside an already-open
+   * branch and moves the result into the C lvalue `target`: the chosen
+   * value's ownership transfers, every other temp the evaluation allocated
+   * releases inside the branch. The shared core of the lazily-branched
+   * expressions (`logical`, `ternary`); the caller owns the surrounding
+   * braces/indentation and registers `target` in ITS frame. */
+export declare function emitBranchInto(E: CEmitter, target: string, expr: IrExpr): void;
+/** Evaluates a condition; its string temps are released before the branch,
+   * which is safe because the result is a scalar bool. */
+export declare function emitCondition(E: CEmitter, cond: IrExpr): string;