@asmlift/core 0.9.0 → 0.11.0

package/src/backend/cfamily.ts

@@ -12,7 +12,8 @@
 // too, shared with the scoring layer's synthesized declarations so the two cannot drift).
 import { doubleLiteral } from '../ir/float-bits';
 import { IrType, T, scalarTypeForAccess, typeEquals, typeToString } from '../ir/types';
-import { BinOp, Expr, SFn, SStatic, Stmt, dotBase } from '../l3/ast';
+import { BinOp, Expr, InitAddress, SFn, SStatic, Stmt, caseGotoViolation, dotBase } from '../l3/ast';
+import { foldConstantImages } from '../l3/constinit';
 import { legalizePointerCells } from '../l3/ptrcell';
 import { orderSlotLocals } from '../l3/slotorder';
 import {
@@ -27,6 +28,8 @@ import {
   renderedIntSignedness,
   writesNonPointerIntoPointer,
 } from '../l3/typing';
+import { spellableType } from '../proto';
+import { append } from './lines';
 
 // C operator precedence (lower binds tighter). Used to emit MINIMAL parentheses. Shared: C++ has
 // the same precedence for these operators.
@@ -35,6 +38,12 @@ const PREC: Record<BinOp, number> = {
   'f/': 3,
   'f+': 4,
   'f-': 4,
+  'f<': 6,
+  'f<=': 6,
+  'f>': 6,
+  'f>=': 6,
+  'f==': 7,
+  'f!=': 7,
   '*': 3,
   '/': 3,
   '/u': 3, // the unsigned twins spell as C's `/` and `%` (see C_SPELLING) — same precedence
@@ -72,8 +81,20 @@ const C_SPELLING: Partial<Record<BinOp, { token: string; signed: boolean }>> = {
 };
 
 /** The float operators (l3/ast.ts BinOp) spell as C's own tokens and take no operand pin: C's
- *  arithmetic over two floats is the IEEE operation the machine did. */
-const FLOAT_TOKEN: Partial<Record<BinOp, string>> = { 'f+': '+', 'f-': '-', 'f*': '*', 'f/': '/' };
+ *  arithmetic over two floats is the IEEE operation the machine did, and its relations over two
+ *  floats are the IEEE compares — false on a NaN, `!=` true. */
+const FLOAT_TOKEN: Partial<Record<BinOp, string>> = {
+  'f+': '+',
+  'f-': '-',
+  'f*': '*',
+  'f/': '/',
+  'f<': '<',
+  'f<=': '<=',
+  'f>': '>',
+  'f>=': '>=',
+  'f==': '==',
+  'f!=': '!=',
+};
 
 /** Spell a recovered type in the decomp C-family typedef vocabulary (`s32`/`u32`/`u8`/`T *`). */
 export function cType(t: IrType): string {
@@ -197,10 +218,10 @@ function legalizedIndexBase(ix: Extract<Expr, { k: 'index' }>, vt: PrintEnv): Ex
  *
  *  An existing integer cast AT THE SAME WIDTH is REPLACED rather than wrapped — `(u32)(s32)&g` and
  *  `(u32)&g` are the same bytes, and the arithmetic rules upstream do emit that inner cast
- *  (intifyAddr). A cast at a DIFFERENT width is a narrowing the source wrote and must be kept. The
- *  replacement CARRIES the qualifier: re-typing a `volatile` cast without it drops an assertion the
- *  differ cannot referee the loss of, which is why l3/initfirst.ts's `stripWideIntCast` refuses the
- *  same peel one pass over. */
+ *  (structure/pointer-spelling.ts ARITH_ROWS). A cast at a DIFFERENT width is a narrowing the
+ *  source wrote and must be kept. The replacement CARRIES the qualifier: re-typing a `volatile`
+ *  cast without it drops an assertion the differ cannot referee the loss of, which is why
+ *  l3/initfirst.ts's `stripWideIntCast` refuses the same peel one pass over. */
 function recastInt(x: Expr, signed: boolean, width: 32 | 64): Expr {
   const replaced = x.k === 'cast' && x.to.kind === 'int' && x.to.width === width ? x : undefined;
   return {
@@ -252,7 +273,8 @@ function pinnedOperands(e0: Extract<Expr, { k: 'bin' }>, wantSigned: boolean, vt
  *  made and the compiled code is C's: an object pointer to a pointer of another pointee (a conversion
  *  to `void *`, or one that only adds a qualifier, is implicit in C++ too), an integer to a pointer
  *  (the literal `0` is the one integer that converts), and a pointer to an integer. Only reached on a
- *  function compiled as C++ (`SFn.dialect`). */
+ *  function compiled as C++ (`SFn.dialect`), or by a C front end that refuses the same three
+ *  (`SFn.strictConversions` — mwcc). */
 function argConversion(a: Expr, to: string, vt: PrintEnv): boolean {
   const from = exprCType(a, vt.type);
   // qualifiers never decide it: a `T * const` parameter is a pointer parameter
@@ -344,7 +366,15 @@ function printExpr(e: Expr, parentPrec: number, vt: PrintEnv, leaf?: LeafHook):
       return `${e.fn}(${e.args
         .map((a, i) => {
           const to = declared?.[i];
-          return to !== undefined && argConversion(a, to, vt) ? `(${to})${rec(a, 2)}` : printConverted(a, vt, leaf);
+          // A parameter type this cannot spell is an object pointer (target.ts `declaredArgTypes`),
+          // reached through `void *` from an argument whose own type is known to differ — a value
+          // this function types, or the address of an object it declares (a static) — never from
+          // `&gW` of a global only the project declares, which may already be the parameter's type.
+          const opaque = to !== undefined && !spellableType(to);
+          const typed = exprCType(a, vt.type) !== undefined || (a.k === 'addr' && vt.type(a.name) !== undefined);
+          return to !== undefined && (!opaque || typed) && argConversion(a, to, vt)
+            ? `(${opaque ? 'void *' : to})${rec(a, 2)}`
+            : printConverted(a, vt, leaf);
         })
         .join(', ')})`;
     }
@@ -383,7 +413,7 @@ function printExpr(e: Expr, parentPrec: number, vt: PrintEnv, leaf?: LeafHook):
         }
         return `${rec(base, 1)}${e.lead.map((l) => `[${rec(l, 99)}]`).join('')}[${rec(e.idx, 99)}]`;
       }
-      if (e.idx.k === 'const' && e.idx.value === 0) {
+      if (e.idx.k === 'const' && e.idx.value === 0 && e.subscript !== true) {
         const s = `*${rec(base, 2)}`;
         return parentPrec < 2 ? `(${s})` : s;
       }
@@ -495,29 +525,31 @@ function printStmt(s: Stmt, indent: string, vt: PrintEnv, leaf?: LeafHook): stri
       }
       const out = [`${indent}if (${cond}) {`];
       for (const t of s.then) {
-        out.push(...printStmt(t, indent + '    ', vt, leaf));
+        append(out, printStmt(t, indent + '    ', vt, leaf));
       }
       if (s.else.length) {
         out.push(`${indent}} else {`);
         for (const e of s.else) {
-          out.push(...printStmt(e, indent + '    ', vt, leaf));
+          append(out, printStmt(e, indent + '    ', vt, leaf));
         }
       }
       out.push(`${indent}}`);
       return out;
     }
     case 'while': {
+      refuseMisboundBreak(s.body, 'loop');
       const out = [`${indent}while (${pe(s.cond, 99)}) {`];
       for (const t of s.body) {
-        out.push(...printStmt(t, indent + '    ', vt, leaf));
+        append(out, printStmt(t, indent + '    ', vt, leaf));
       }
       out.push(`${indent}}`);
       return out;
     }
     case 'dowhile': {
+      refuseMisboundBreak(s.body, 'loop');
       const out = [`${indent}do {`];
       for (const t of s.body) {
-        out.push(...printStmt(t, indent + '    ', vt, leaf));
+        append(out, printStmt(t, indent + '    ', vt, leaf));
       }
       out.push(`${indent}} while (${pe(s.cond, 99)});`);
       return out;
@@ -527,18 +559,28 @@ function printStmt(s: Stmt, indent: string, vt: PrintEnv, leaf?: LeafHook): stri
       // `recognizeForLoops` and l3/reindex.ts): init/inc are each a SINGLE-LINE `assign` statement. `clause` renders one
       // and strips its trailing `;` so it sits inside the header (`i = 0; c; i = i + 1`). A multi-line
       // statement (an `if`/nested loop) would render mangled — but the recognizer never builds one here.
+      refuseMisboundBreak(s.body, 'loop');
+      // An identity init (`i = i`, structure.ts `forPlanAt`: the name already holds the entry value)
+      // is the empty clause.
       const clause = (st: Stmt) => printStmt(st, '', vt, leaf).join(' ').replace(/;\s*$/, '').trim();
-      const out = [`${indent}for (${clause(s.init)}; ${pe(s.cond, 99)}; ${clause(s.inc)}) {`];
+      const identity = s.init.k === 'assign' && s.init.value.k === 'var' && s.init.value.name === s.init.name;
+      const out = [`${indent}for (${identity ? '' : clause(s.init)}; ${pe(s.cond, 99)}; ${clause(s.inc)}) {`];
       for (const t of s.body) {
-        out.push(...printStmt(t, indent + '    ', vt, leaf));
+        append(out, printStmt(t, indent + '    ', vt, leaf));
       }
       out.push(`${indent}}`);
       return out;
     }
+    // A labelled `break` is the end of a switch arm a case-end `goto` lands on (l3/ast.ts).
     case 'break':
-      return [`${indent}break;`];
+      return s.label === undefined ? [`${indent}break;`] : [`${indent}${s.label}:`, `${indent}break;`];
     case 'continue':
       return [`${indent}continue;`];
+    // Where it may sit is the tree's contract (l3/ast.ts `caseGotoViolation`), which `emitCFamily`
+    // asks of the whole function before printing any of it.
+    case 'goto':
+    case 'caseEndGoto':
+      return [`${indent}goto ${s.label};`];
     case 'switch':
       return printSwitchStmt(s, indent, vt, leaf);
   }
@@ -550,11 +592,12 @@ function printStmt(s: Stmt, indent: string, vt: PrintEnv, leaf?: LeafHook): stri
  *  is one call. */
 function printSwitchStmt(s: Extract<Stmt, { k: 'switch' }>, indent: string, vt: PrintEnv, leaf?: LeafHook): string[] {
   const pe = (e: Expr, p: number) => printExpr(e, p, vt, leaf);
-  // A `break;` in an arm BODY is the innermost LOOP's in L3 (l3/ast.ts) and the SWITCH's in C,
-  // so printing one between `case` labels rebinds it — a changed program that reads as ordinary
+  // A plain `break;` in an arm BODY is the innermost LOOP's in L3 (l3/ast.ts) and the SWITCH's in
+  // C, so printing one between `case` labels rebinds it — a changed program that reads as ordinary
   // C. Refused HERE because the rebinding is the printer's, for every producer rather than for
-  // the two switch regimes. No recovery reaches it today (both regimes decline a loop-exiting
-  // arm first, loudly), so it is a contract on the next one.
+  // the two switch regimes (`refuseMisboundBreak`, which checks a loop body the same way for a
+  // `break` marked `ofSwitch`). The structurer spells a loop exit inside an arm as the switch's
+  // own `break` or refuses it, so no recovery reaches either today: a contract on the next one.
   //
   // `continue;` is deliberately NOT refused: C binds it to the smallest enclosing ITERATION
   // statement, which a `switch` is not, so it already means what L3 means. What a pass that re-spells
@@ -563,9 +606,7 @@ function printSwitchStmt(s: Extract<Stmt, { k: 'switch' }>, indent: string, vt:
   // `respellCountdown` in l3/reindex.ts, and l3/unreduce.ts) each scan switch arms for the node
   // before firing, and a fourth must too.
   for (const body of [...s.cases.map((c) => c.body), s.default ?? []]) {
-    if (switchBoundBreakIn(body)) {
-      throw new Error('c backend: a switch arm carries a loop-scoped `break;`, which C would bind to the switch');
-    }
+    refuseMisboundBreak(body, 'switch');
   }
   const out = [`${indent}switch (${pe(s.scrutinee, 99)}) {`];
   const ci = indent + '    '; // case-label indent
@@ -585,7 +626,7 @@ function printSwitchStmt(s: Extract<Stmt, { k: 'switch' }>, indent: string, vt:
   const printDefault = (): void => {
     out.push(`${ci}default:`);
     for (const t of s.default!) {
-      out.push(...printStmt(t, bi, vt, leaf));
+      append(out, printStmt(t, bi, vt, leaf));
     }
     // A default that is NOT last would otherwise fall into the case below it — the mirror of the
     // rule for cases. The last one needs no `break;` because there is nothing under it.
@@ -608,8 +649,13 @@ function printSwitchStmt(s: Extract<Stmt, { k: 'switch' }>, indent: string, vt:
     for (const v of c.values) {
       out.push(`${ci}case ${v}:`);
     }
+    // The label a `goto` of this switch lands on, after the arm's case labels: entering it there
+    // runs exactly what falling into the arm runs.
+    if (c.label !== undefined) {
+      out.push(`${ci}${c.label}:`);
+    }
     for (const t of c.body) {
-      out.push(...printStmt(t, bi, vt, leaf));
+      append(out, printStmt(t, bi, vt, leaf));
     }
     // A case whose body ends in `return`/`break` (a terminated arm) needs no `break;`; only an
     // open non-fall-through arm gets one. `fallsThrough` omits it so control drops to the next case.
@@ -624,13 +670,26 @@ function printSwitchStmt(s: Extract<Stmt, { k: 'switch' }>, indent: string, vt:
   return out;
 }
 
-/** Does this arm body carry a `break` C would bind to the enclosing SWITCH rather than to the loop
- *  L3 meant? A loop opened inside the arm captures its own, so its body is not walked; a nested
- *  `switch` captures one too and is checked when it is printed. */
-function switchBoundBreakIn(body: Stmt[]): boolean {
-  return body.some(
-    (s) => s.k === 'break' || (s.k === 'if' && (switchBoundBreakIn(s.then) || switchBoundBreakIn(s.else))),
-  );
+/** L3 has two `break`s (l3/ast.ts) and C one: C binds `break;` to the innermost enclosing loop OR
+ *  switch, so a `break` prints as what L3 meant only where its own kind is that innermost
+ *  statement. `body` is a loop body or a switch arm (`owner`); a loop or switch opened inside it
+ *  captures its own breaks and is checked when it is printed, so it is not walked. Refused loud on
+ *  either mismatch — a plain (loop) `break` in an arm, a switch's `break` in a loop body — since
+ *  each prints as ordinary C that leaves a different statement. */
+function refuseMisboundBreak(body: Stmt[], owner: 'loop' | 'switch'): void {
+  const misbound = (ss: Stmt[]): boolean =>
+    ss.some(
+      (s) =>
+        (s.k === 'break' && (s.ofSwitch === true) !== (owner === 'switch')) ||
+        (s.k === 'if' && (misbound(s.then) || misbound(s.else))),
+    );
+  if (misbound(body)) {
+    throw new Error(
+      owner === 'switch'
+        ? 'c backend: a switch arm carries a loop-scoped `break;`, which C would bind to the switch'
+        : 'c backend: a loop body carries a switch-scoped `break;`, which C would bind to the loop',
+    );
+  }
 }
 
 // Does a statement list end in a control-flow terminator (so a trailing `break;` would be dead)?
@@ -641,10 +700,28 @@ function endsTerminated(body: Stmt[]): boolean {
     (last.k === 'return' ||
       last.k === 'break' ||
       last.k === 'continue' ||
+      last.k === 'goto' ||
+      last.k === 'caseEndGoto' ||
       (last.k === 'if' && endsTerminated(last.then) && last.else.length > 0 && endsTerminated(last.else)))
   );
 }
 
+/** Is `e` a pointer to another pointee than the pointer slot `t` declares, as rendered? Its pointer
+ *  type is its C type, or, for the address of a declared object (which `exprCType` leaves
+ *  unknown), a pointer to that object or to an array's element, the way it decays. A `void *` slot
+ *  takes every object pointer implicitly. A `void *` value converts into any pointer slot in C
+ *  (mwcc's C takes `gp = (void *)x` into an `s32 *gp`, compiled) but not in C++ (`cxx`). An unknown
+ *  type is no opinion. */
+function otherPointee(t: IrType | undefined, e: Expr, vt: (name: string) => IrType | undefined, cxx: boolean): boolean {
+  if (t?.kind !== 'ptr' || t.to.kind === 'void') {
+    return false;
+  }
+  const of = e.k === 'addr' ? vt(e.name) : undefined;
+  const ct = of !== undefined ? T.ptr(of.kind === 'array' ? of.elem : of) : exprCType(e, vt);
+  const p = ct?.kind === 'array' ? T.ptr(ct.elem) : ct;
+  return p?.kind === 'ptr' && (cxx || p.to.kind !== 'void') && !typeEquals(p, t);
+}
+
 // C-FAMILY WRITE LEGALIZATION (the assign-side sibling of the deref legalization in printExpr):
 // the C family's answer to `writesNonPointerIntoPointer` is the reinterpret cast to the DECLARED
 // type — exactly what the machine's register move does — where Pascal, having no such cast,
@@ -654,9 +731,18 @@ function legalizePointerWrites(fn: SFn): SFn {
   const vt = declaredTypes(fn);
   // …and the mirror: a rendered pointer into an INTEGER slot takes the slot's type. A cast keeps
   // the sum it wraps, so the bytes are the uncast write's; CodeWarrior rejects that write outright.
+  //
+  // …and, where the compiler refuses the third implicit conversion too (C++, or mwcc's C:
+  // `SFn.strictConversions`), a pointer of ANOTHER pointee into a pointer slot: mwcc rejects
+  // `return t;` from an `s32 *` function when `t` is a `const u32[2]` static (mwcc: "illegal implicit
+  // conversion" of an `unsigned int *` to an `int *`, compiled), and takes it cast (`otherPointee`
+  // says which `void *` converts implicitly).
+  const strict = fn.dialect === 'c++' || fn.strictConversions === true;
   const castTo = (t: IrType | undefined, e: Expr): Expr =>
-    writesNonPointerIntoPointer(t, e, vt) || (t?.kind === 'int' && exprCType(e, vt)?.kind === 'ptr')
-      ? { k: 'cast', to: t, e }
+    writesNonPointerIntoPointer(t, e, vt) ||
+    (t?.kind === 'int' && exprCType(e, vt)?.kind === 'ptr') ||
+    (strict && otherPointee(t, e, vt, fn.dialect === 'c++'))
+      ? { k: 'cast', to: t!, e }
       : e;
   const fix = (s: Stmt): Stmt => {
     switch (s.k) {
@@ -692,7 +778,7 @@ function legalizePointerWrites(fn: SFn): SFn {
 /** The body of a C-family function: local declarations + statements, one string per line. The
  *  SIGNATURE (return type + name + params, plus any C++ scope/`this`/mangling) is the caller's —
  *  that is the language-divergent part each backend owns. */
-function cFamilyBody(fn0: SFn, leaf?: LeafHook): string[] {
+function cFamilyBody(fn0: SFn, leaf: LeafHook | undefined, designators: boolean): string[] {
   const fn = legalizePointerWrites(fn0);
   // The legalization env: every printed var's declared type and pointee volatility, from the SAME
   // params/locals the emitted declarations come from — so the printer judges exactly the C the
@@ -700,7 +786,7 @@ function cFamilyBody(fn0: SFn, leaf?: LeafHook): string[] {
   const vt: PrintEnv = printEnv(fn);
   const lines: string[] = [];
   for (const st of fn.statics ?? []) {
-    lines.push(...staticDefinition(st));
+    append(lines, staticDefinition(st));
   }
   for (const l of fn.locals) {
     // Both facts render at the PREFIX position, where C's declarator grammar reads them
@@ -710,19 +796,37 @@ function cFamilyBody(fn0: SFn, leaf?: LeafHook): string[] {
     // no variation or recognizer produces one. The NAME is placed by `cDeclare`, the one
     // placement every declaration position in this backend uses: a local can carry an array type
     // — the storage extent a frame object pins — and C puts those extents after the name.
-    lines.push(`    ${l.volatile || l.pointeeVolatile ? 'volatile ' : ''}${cDeclare(l.type, l.name)};`);
+    const head = `    ${l.volatile || l.pointeeVolatile ? 'volatile ' : ''}${cDeclare(l.type, l.name)}`;
+    lines.push(
+      ...(l.init === undefined ? [`${head};`] : initialized(head, l.type, l.init, l.initString === true, designators)),
+    );
   }
   for (const s of fn.body) {
-    lines.push(...printStmt(s, '    ', vt, leaf));
+    append(lines, printStmt(s, '    ', vt, leaf));
   }
   return lines;
 }
 
-/** One initial element: hex from 10 up, a negative one with its sign, so a byte table reads as the
+/** One initial number: hex from 10 up, a negative one with its sign, so a byte table reads as the
  *  bytes and a signed one as its values. */
-const initElement = (v: number): string =>
+const initNumber = (v: number): string =>
   Math.abs(v) < 10 ? `${v}` : `${v < 0 ? '-' : ''}0x${Math.abs(v).toString(16)}`;
 
+/** One initial element of type `elem`: a number, or the address constant a relocated one holds,
+ *  converted to the element's integer type — `(u32)&sym`, and with an addend `(u32)((u8 *)&sym + k)`:
+ *  the offset in bytes, as the relocation counts it. Not `(u32)&sym + k`, which agbcc folds alike but
+ *  mwcc refuses as an illegal constant expression (compiled); through a byte pointer both write the
+ *  pointer-typed source's word and relocation (`&garr[2]`, `&garr[-1]`, compiled on both). */
+function initElement(v: number | InitAddress, elem: IrType): string {
+  if (typeof v === 'number') {
+    return initNumber(v);
+  }
+  const t = cType(elem);
+  return v.addend === 0
+    ? `(${t})&${v.symbol}`
+    : `(${t})((u8 *)&${v.symbol} ${v.addend < 0 ? '-' : '+'} ${initNumber(Math.abs(v.addend))})`;
+}
+
 /** A byte array's initial elements as a string literal: printable characters as themselves, every
  *  other byte in three-digit octal (which no following digit can extend), and a `?` after a `?`
  *  escaped so no trigraph forms. The trailing zeros are left to the declared size, which C fills
@@ -750,26 +854,45 @@ function stringLiteral(init: readonly number[]): string {
 function staticDefinition(st: SStatic): string[] {
   const aligned = st.align === undefined ? '' : ` __attribute__((aligned(${st.align})))`;
   const head = `    static ${st.const ? 'const ' : ''}${cDeclare(st.type, st.name)}${aligned}`;
-  if (st.init === undefined) {
-    return [`${head};`];
-  }
-  if (st.string) {
-    return [`${head} = ${stringLiteral(st.init)};`];
+  return st.init === undefined ? [`${head};`] : initialized(head, st.type, st.init, st.string === true, false);
+}
+
+/** A declaration `head` of `type` with its initializer: a string literal, one scalar, or an
+ *  array's elements laid out eight to a line. An element left out (null) is skipped and the next
+ *  one spelled by designator, `[k] = v` — or, where the compiler cannot parse one (`SFn.designators`
+ *  absent: IDO, mwcc) or the language has none (C++), spelled as the zero it is. */
+function initialized(
+  head: string,
+  type: IrType,
+  init: readonly (number | InitAddress | null)[],
+  string: boolean,
+  designators: boolean,
+): string[] {
+  const whole = init.map((v) => v ?? 0);
+  if (string) {
+    // a string's elements are bytes, and no byte holds an address (structure/local-statics.ts)
+    const bytes = whole.filter((v): v is number => typeof v === 'number');
+    if (bytes.length !== whole.length) {
+      throw new Error(`internal: a string initializer of '${head.trim()}' holds an address`);
+    }
+    return [`${head} = ${stringLiteral(bytes)};`];
   }
-  if (st.type.kind !== 'array') {
-    return [`${head} = ${initElement(st.init[0])};`];
+  if (type.kind !== 'array') {
+    return [`${head} = ${initElement(whole[0], type)};`];
   }
-  if (st.init.length <= 8) {
-    return [`${head} = { ${st.init.map(initElement).join(', ')} };`];
+  const items: string[] = [];
+  init.forEach((v, i) => {
+    if (v !== null || !designators) {
+      const e = initElement(v ?? 0, type.elem);
+      items.push(init[i - 1] === null && designators ? `[${i}] = ${e}` : e);
+    }
+  });
+  if (items.length <= 8) {
+    return [`${head} = { ${items.join(', ')} };`];
   }
   const rows: string[] = [];
-  for (let i = 0; i < st.init.length; i += 8) {
-    rows.push(
-      `        ${st.init
-        .slice(i, i + 8)
-        .map(initElement)
-        .join(', ')},`,
-    );
+  for (let i = 0; i < items.length; i += 8) {
+    rows.push(`        ${items.slice(i, i + 8).join(', ')},`);
   }
   return [`${head} = {`, ...rows, '    };'];
 }
@@ -783,16 +906,29 @@ function structDecls(fn: SFn): string[] {
   return (fn.structs ?? []).map((s) => renderStructDecl(s.name, s.fields));
 }
 
-/** Assemble a full C-family function from a caller-supplied signature line and the shared body. */
-export function emitCFamily(signature: string, fn0: SFn, leaf?: LeafHook): string {
+/** Assemble a full C-family function from a caller-supplied signature line and the shared body.
+ *  `designators`: the LANGUAGE spells an array element by index in an initializer (C, not C++).
+ *  Whether the compiler's dialect parses one is the function's own fact (`SFn.designators`); an
+ *  initializer is spelled by index only where both say yes. */
+export function emitCFamily(signature: string, fn0: SFn, leaf?: LeafHook, designators = true): string {
   // The declaration list is put into the target's own frame order, and a pointer cell's integer
   // uses converted (l3/ptrcell.ts), HERE — in the shared C-family assembler, reached only from
   // `cBackend.emit` and `cppBackend(...).emit`, so both C-family backends print them and no `.emit(`
   // call site does (l3/slotorder.ts says why `emit` owns it).
-  const fn = orderSlotLocals(legalizePointerCells(fn0));
+  // …and the compiler's anonymous constant images folded into the initializers of the locals
+  // their copies fill (l3/constinit.ts), which the tree keeps as copies until here.
+  const fn = orderSlotLocals(legalizePointerCells(foldConstantImages(fn0)));
+  const stray = caseGotoViolation(fn.body);
+  if (stray !== null) {
+    throw new Error(`c backend: ${stray}`);
+  }
   const decls = structDecls(fn);
   const preamble = decls.length ? decls.join('\n') + '\n' : '';
-  return preamble + [`${signature} {`, ...cFamilyBody(fn, leaf), '}'].join('\n') + '\n';
+  return (
+    preamble +
+    [`${signature} {`, ...cFamilyBody(fn, leaf, designators && fn.designators === true), '}'].join('\n') +
+    '\n'
+  );
 }
 
 // One C-family comment spelling, shared by the C and C++ backends. A `*` followed by `/`

package/src/backend/cpp.ts

@@ -138,6 +138,8 @@ export function cppBackend(spec: CppFnSpec, floatSlots: FloatSlots | undefined):
   return {
     id: 'cpp',
     spellsSwitchFallthrough: true,
+    spellsSwitchBreak: true,
+    spellsEarlyReturn: true,
     emit(fn: SFn): string {
       // Map each lifted param var → its C++ meaning: `this` (bare member access) or a named param
       // (a pointer-to-class param uses `->`). A pointer-to-known-class param is a member receiver.
@@ -223,7 +225,7 @@ export function cppBackend(spec: CppFnSpec, floatSlots: FloatSlots | undefined):
       const paramList = spec.params.map((p) => declareCpp(p.type, p.name)).join(', ');
       const decls = classDecls(spec, paramList);
       const signature = `${spellType(spec.retType)} ${spec.cls ? spec.cls + '::' : ''}${spec.method}(${paramList})`;
-      return (decls ? decls + '\n' : '') + emitCFamily(signature, fn, leaf);
+      return (decls ? decls + '\n' : '') + emitCFamily(signature, fn, leaf, false);
     },
     comment: cComment, // C++ shares C's block-comment spelling
   };

package/src/backend/lines.ts

@@ -0,0 +1,10 @@
+/** `out.push(...lines)` without the spread: a spread passes every line as an ARGUMENT, and V8 throws
+ *  "Maximum call stack size exceeded" past about 120k of them (120,000 print, 130,000 throw, node
+ *  24). A structuring with a long arm reaches that at a nesting depth of a few dozen, so the throw
+ *  reads as deep recursion when it is only size. Every printer appends a child's lines with this,
+ *  so the limit binds no backend (the C family and Pascal alike). */
+export function append(out: string[], lines: readonly string[]): void {
+  for (const line of lines) {
+    out.push(line);
+  }
+}

package/src/backend/pascal.ts

@@ -12,6 +12,7 @@ import { IrType, typeToString } from '../ir/types';
 import { BinOp, Expr, LanguageBackend, SFn, Stmt, isLoop } from '../l3/ast';
 import { orderSlotLocals } from '../l3/slotorder';
 import { type VarTypes, declaredTypes, derefStrideOk, exprCType, writesNonPointerIntoPointer } from '../l3/typing';
+import { append } from './lines';
 
 // Infix operators IDO Pascal spells directly.
 const OP: Partial<Record<BinOp, string>> = {
@@ -140,10 +141,10 @@ function makePrinter(vt: VarTypes) {
       // Casts have no faithful IDO-Pascal spelling yet — fail LOUD rather than emit silently-wrong
       // source. Tree-level producers reaching here: the width-narrowing idiom casts (agbcc-gated,
       // so never on this path today), structure.ts's STRUCT-pointer casts (unreachable too — the
-      // `field` case above throws first), intify's `(s32)ptr` legalization (any target), and the
-      // byte-pointer walk of a pointer offset by a runtime value (any target, and reachable with no
-      // `field` in the tree — it declines two functions that used to emit here, whose Pascal was
-      // silently walking ELEMENTS where the asm walked bytes).
+      // `field` case above throws first), the arithmetic table's `(s32)ptr` legalization (any
+      // target), and the byte-pointer walk of a pointer offset by a runtime value (any target,
+      // and reachable with no `field` in the tree, where a Pascal spelling would walk ELEMENTS
+      // where the asm walked bytes).
       // Scalar deref casts never appear in the tree — the index case above owns that judgment.
       case 'cast':
         throw new Error(`pascal backend: cast has no IDO Pascal spelling yet`);
@@ -202,23 +203,30 @@ function makePrinter(vt: VarTypes) {
         return s.value ? [`${indent}${fnName} := ${pe(s.value)};`] : [];
       case 'if': {
         const cond = pe(s.cond);
-        const block = (stmts: Stmt[], ind: string) =>
-          stmts.length === 1
+        // A branch goes bare only where it is ONE Pascal statement that cannot capture what follows.
+        // A `for` prints as two (its init, then a `while`), so it always takes begin/end. And with an
+        // `else` to come, a then-branch that is itself an `if` or a loop (whose body may end in one)
+        // would take that `else` as its own innermost `if`'s — Pascal's dangling else, which C's
+        // braces had ruled out: `if (a) { if (b) X; } else Y;` printed bare runs Y when b fails.
+        const bare = (stmts: Stmt[], open: boolean) =>
+          stmts.length === 1 && stmts[0].k !== 'for' && !(open && (stmts[0].k === 'if' || isLoop(stmts[0])));
+        const block = (stmts: Stmt[], ind: string, open = false) =>
+          bare(stmts, open)
             ? ps(fnName, stmts[0], ind, tail)
             : [`${ind}begin`, ...list(stmts, ind + '  ', tail), `${ind}end`];
         // Pascal: no `;` before `else`; the branch statements already carry their own.
         const out = [`${indent}if ${cond} then`];
-        out.push(...block(s.then, indent + '  '));
+        append(out, block(s.then, indent + '  ', s.else.length > 0));
         if (s.else.length) {
           out.push(`${indent}else`);
-          out.push(...block(s.else, indent + '  '));
+          append(out, block(s.else, indent + '  '));
         }
         return out;
       }
       case 'while': {
         // loop bodies are NEVER tail position — control returns to the test
         const body =
-          s.body.length === 1
+          s.body.length === 1 && s.body[0].k !== 'for'
             ? ps(fnName, s.body[0], indent + '  ')
             : [`${indent}begin`, ...s.body.flatMap((x) => ps(fnName, x, indent + '  ')), `${indent}end`];
         return [`${indent}while ${pe(s.cond)} do`, ...body];
@@ -248,12 +256,19 @@ function makePrinter(vt: VarTypes) {
         throw new Error('pascal backend: `break` has no IDO Pascal spelling');
       case 'continue':
         throw new Error('pascal backend: `continue` has no IDO Pascal spelling');
+      // A jump into another arm of a `case-of` has no Pascal spelling: an arm is a statement, and a
+      // label may not be entered from outside the statement that holds it.
+      case 'goto':
+        throw new Error('pascal backend: a `goto` into a case arm has no IDO Pascal spelling');
+      // A jump to an arm's end lands on a `break`, which Pascal has none of either.
+      case 'caseEndGoto':
+        throw new Error('pascal backend: a `goto` to the end of a case arm has no IDO Pascal spelling');
       case 'switch': {
         // IDO/SGI Pascal `case E of L: S; … otherwise S end`. There is NO fall-through in Pascal case-of,
         // so a `fallsThrough` arm has no faithful spelling → loud-fail (mirrors the `field`/`cast`/`%`
         // throws above). Each arm's body is a single statement or a begin/end block.
         const arm = (body: Stmt[], ind: string) =>
-          body.length === 1
+          body.length === 1 && body[0].k !== 'for'
             ? ps(fnName, body[0], ind + '  ')
             : [`${ind}  begin`, ...body.flatMap((x) => ps(fnName, x, ind + '  ')), `${ind}  end`];
         // Pascal has no early `return`: a `return v` inside a case renders `fnName := v` and then FALLS
@@ -277,11 +292,15 @@ function makePrinter(vt: VarTypes) {
           if (c.fallsThrough) {
             throw new Error('pascal backend: switch fall-through has no faithful IDO Pascal case-of spelling');
           }
-          out.push(`${indent}  ${c.values.join(', ')}:`, ...arm(c.body, indent + '  '));
+          out.push(`${indent}  ${c.values.join(', ')}:`);
+          append(out, arm(c.body, indent + '  '));
         }
-        if (s.default) {
-          out.push(`${indent}  otherwise`);
-          out.push(...arm(s.default, indent + '  '));
+        // A C `switch` with no `default` runs on past a value it does not list; IDO Pascal's
+        // `case` raises a run-time `caseerror` there instead. So the clause is always printed, an
+        // empty one when the source had no default.
+        out.push(`${indent}  otherwise`);
+        if (s.default?.length) {
+          append(out, arm(s.default, indent + '  '));
         }
         out.push(`${indent}end;`);
         return out;
@@ -298,17 +317,29 @@ export const pascalBackend: LanguageBackend = {
   // spells as plain if-nesting, which Pascal prints, so the choice is between a decompiled
   // function and a stub.
   spellsSwitchFallthrough: false,
+  // Nor has Pascal a `break`, so recovery must not mint a switch's mid-arm one either: a closed arm
+  // that leaves early spells as nested `if`s that copy the arm's tail into each path.
+  spellsSwitchBreak: false,
+  // Nor an early `return` (the `return` case below loud-fails one not in tail position), so
+  // structuring reads the return-tail copies rather than the join past early returns.
+  spellsEarlyReturn: false,
   emit(fn0: SFn): string {
     // The declaration list is put into the target's own frame order HERE, as the C family does it
     // in its shared assembler — owned by `emit`, never by a `.emit(` call site (l3/slotorder.ts).
     const fn = orderSlotLocals(fn0);
     // A function-scope static is a definition the MIPS frontends never recover, and IDO Pascal's
-    // spelling of one (a typed constant, or a unit-level var) has not been measured — loud.
+    // spelling of one (a typed constant, or a unit-level var) has not been measured — loud. So is
+    // the compiler's anonymous constant a local's initializer is copied from (l3/constinit.ts).
     if (fn.statics?.length) {
       throw new Error(
         `pascal backend: the function-scope static '${fn.statics[0].name}' has no IDO Pascal spelling yet`,
       );
     }
+    if (fn.images?.length) {
+      throw new Error(
+        `pascal backend: the compiler's anonymous constant '${fn.images[0].name}' a local is initialized from has no IDO Pascal spelling yet`,
+      );
+    }
     // Same env discipline as the C family (cfamily.ts cFamilyBody): the printer judges derefs
     // against the exact declarations it emits.
     const ps = makePrinter(declaredTypes(fn));
@@ -332,7 +363,7 @@ export const pascalBackend: LanguageBackend = {
       lines.push('var', ...fn.locals.map((l) => `  ${l.name}: ${pasType(l.type)};`));
     }
     lines.push('begin');
-    fn.body.forEach((s, i) => lines.push(...ps(fn.name, s, '  ', i === fn.body.length - 1)));
+    fn.body.forEach((s, i) => append(lines, ps(fn.name, s, '  ', i === fn.body.length - 1)));
     lines.push('end;');
     return lines.join('\n') + '\n';
   },