feat(express): compile groundwork — DEF pair, leak-rule imports, comment syntax

EXPRESS.DEF (new, best-guess 22 exports incl. Desc type) + PASS1.DEF
stub (CondInsert/InsertEntry, BOOLEAN use proven from MCD frames).
MOD: Desc type moved to DEF (duplicate-type signature clash),
SYSTEM import trimmed to ADR/MOVE (leak rule proven: ADDRESS/WORD/
RecordPtr visible from DEF), {/* */} markers -> (*{}*) (29x).
Still NOT compiling (body type errors remain); NOT verified.

src/compiler/EXPRESS.DEF

@@ -0,0 +1,49 @@
+(* EXPRESS.DEF — best-guess export map (FRONTEND.md); corrected iteratively
+   by MCD-diff. Names are ours; slots follow declaration order. *)
+DEFINITION MODULE Express;
+FROM SYSTEM IMPORT ADDRESS, WORD;
+FROM Compiler IMPORT RecordPtr;
+
+TYPE DescPtr = POINTER TO Desc;
+     Desc = RECORD
+       CASE : BOOLEAN OF
+       | TRUE:
+         typ: ADDRESS;     (* word0: type descriptor *)
+         mode: CARDINAL;   (* word1: 0=const *)
+         value: CARDINAL;  (* word2: const value / offset *)
+         extra: CARDINAL;  (* word3 *)
+         kind: CARDINAL;   (* word4: type class tag *)
+         low: CARDINAL;    (* word5 *)
+         high: CARDINAL;   (* word6 *)
+         w7: CARDINAL;
+         w8: CARDINAL;
+         w9: CARDINAL;
+       | FALSE:
+         raw: ARRAY [0..9] OF WORD;
+       END;
+     END;
+
+PROCEDURE CentralError(ok: BOOLEAN; code: CARDINAL);
+PROCEDURE PushExprDesc(dst: DescPtr; src: DescPtr);
+PROCEDURE PopExprDesc(d: DescPtr);
+PROCEDURE EmitOp(subOp, typeKind: CARDINAL);
+PROCEDURE NormalizeOperand;
+PROCEDURE LoadIndirect;
+PROCEDURE BoolCondHelper;
+PROCEDURE GetConstVal;
+PROCEDURE OpSetTest(allowed: BITSET; errCode: CARDINAL);
+PROCEDURE ConstToCard(c: DescPtr; errPos: CARDINAL);
+PROCEDURE ConstToInt(c: DescPtr; errPos: CARDINAL);
+PROCEDURE EmitRangeCheck;
+PROCEDURE ParseSimpleExpression;
+PROCEDURE LoadOperand;
+PROCEDURE StoreOperand;
+PROCEDURE ParseFactor(p1, p2, p3, p4, p5: CARDINAL);
+PROCEDURE EvalConstExpr;
+PROCEDURE ParseTerm(flag, t: CARDINAL);
+PROCEDURE ParseSetCons(flag, s: CARDINAL);
+PROCEDURE ParseDesignatorBase(finA, finB, probeA, probeB: CARDINAL): BOOLEAN;
+PROCEDURE ParseAssignment;
+PROCEDURE ParseExpression;
+
+END Express.

src/compiler/EXPRESS.MOD

@@ -48,28 +48,10 @@
 
 IMPLEMENTATION MODULE Express;
 IMPORT Compiler, Scanner, Errors, CodeGen, SymTab, Pass1, Doubles;
-FROM SYSTEM IMPORT ADDRESS, ADR, MOVE, WORD;
+FROM SYSTEM IMPORT ADR, MOVE; (* ADDRESS/WORD/RecordPtr come via DEF imports (leak rule) *)
 
-(* 10-word operand descriptor: named view + raw words view (same layout). *)
-TYPE DescPtr = POINTER TO Desc;
-     Desc = RECORD
-       CASE : BOOLEAN OF
-       | TRUE:
-         typ: ADDRESS;     (* word0: type descriptor *)
-         mode: CARDINAL;   (* word1: 0=const *)
-         value: CARDINAL;  (* word2: const value / offset *)
-         extra: CARDINAL;  (* word3 *)
-         kind: CARDINAL;   (* word4: type class tag *)
-         low: CARDINAL;    (* word5 *)
-         high: CARDINAL;   (* word6 *)
-         w7: CARDINAL;
-         w8: CARDINAL;
-         w9: CARDINAL;
-       | FALSE:
-         raw: ARRAY [0..9] OF WORD;
-       END;
-     END;
-     Words = POINTER TO ARRAY [0..9] OF WORD;
+(* Desc/DescPtr come from EXPRESS.DEF; Words is module-local. *)
+     TYPE Words = POINTER TO ARRAY [0..9] OF WORD;
 
 VAR
     curDesc: Desc;        (* word2: current operand descriptor *)
@@ -81,81 +63,53 @@ VAR
     exprPool: ADDRESS;    (* word9 *)
 
 (* ---- unresolved EXPRESS-internal helpers: FORWARD = work list ---- *)
-PROCEDURE CentralError(ok: BOOLEAN; code: CARDINAL); FORWARD; (* proc1: proven (cond, code) via STMT @058a [bool,20] frame evidence; 1-arg call sites below need re-read *)
-(*FIXME-NYC*) PROCEDURE PushOperand; FORWARD; (* proc2 *)
-(*FIXME-NYC*) PROCEDURE PopOperand; FORWARD; (* proc3 *)
-(*FIXME-NYC*) PROCEDURE EmitOp; FORWARD; (* proc6 *)
-(*FIXME-NYC*) PROCEDURE NormalizeOperand; FORWARD; (* proc10 *)
-(*FIXME-NYC*) PROCEDURE LoadIndirect; FORWARD; (* proc11 *)
-(*FIXME-NYC*) PROCEDURE BoolCondHelper; FORWARD; (* proc12 *)
-(*FIXME-NYC*) PROCEDURE CheckAndStore; FORWARD; (* proc22, arity TBD *)
-(*FIXME-NYC*) PROCEDURE GetRangeBase; FORWARD; (* proc25 *)
-(*FIXME-NYC*) PROCEDURE IsPointer(t: CARDINAL): BOOLEAN; FORWARD; (* proc26 *)
-(*FIXME-NYC*) PROCEDURE TypeKindOf(): CARDINAL; FORWARD; (* proc27 *)
-(*FIXME-NYC*) PROCEDURE EmitAddress; FORWARD; (* proc28 *)
-(*FIXME-NYC*) PROCEDURE ParseActualList; FORWARD; (* proc29 *)
-(*FIXME-NYC*) PROCEDURE EmitIndexed(idx: CARDINAL); FORWARD; (* proc31 *)
-(*FIXME-NYC*) PROCEDURE PushStringConst; FORWARD;
-(*FIXME-NYC*) PROCEDURE LookupField(n: CARDINAL): BOOLEAN; FORWARD;
-(*FIXME-NYC*) PROCEDURE Power2(e: CARDINAL): CARDINAL; FORWARD;
-(*FIXME-NYC*) PROCEDURE ExpectBoolOrSet; FORWARD;
-(*FIXME-NYC*) PROCEDURE EmitSetMember(d: Desc): Desc; FORWARD;
-(*FIXME-NYC*) PROCEDURE IsOrdinalType(t: ADDRESS): BOOLEAN; FORWARD;
-(*FIXME-NYC*) PROCEDURE CheckForwardRef; FORWARD;
-(*FIXME-NYC*) PROCEDURE CheckAssignable2(t: ADDRESS); FORWARD;
-(*FIXME-NYC*) PROCEDURE EmitOperand31(n: ADDRESS); FORWARD;
-(*FIXME-NYC*) PROCEDURE EmitDescriptor2(d: Desc); FORWARD; (* proc2 *)
-(*FIXME-NYC*) PROCEDURE FoldLongRelation(d: Desc); FORWARD; (* DOUBLES.qmul + proc47 *)
-(*FIXME-NYC*) PROCEDURE FoldLongDiv(d: Desc); FORWARD; (* DOUBLES.qdiv + proc47 *)
-(*FIXME-NYC*) PROCEDURE FoldLongAdd(d: Desc); FORWARD; (* DOUBLES.qadd + proc47 *)
-(*FIXME-NYC*) PROCEDURE EmitSetOrArrayAssign(d: Desc); FORWARD; (* proc11 pair *)
 (* Forward refs to group-defined procedures used before definition *)
-PROCEDURE ParseExpression; FORWARD;
 PROCEDURE ParseDesignatorTail; FORWARD;
-PROCEDURE ParseTerm(flag, t: CARDINAL); FORWARD; (* audit SWAP; 3-arg call sites still FIXME *)
-PROCEDURE ParseSetCons(flag, s: CARDINAL); FORWARD; (* audit SWAP; 1-arg call site still FIXME *)
 PROCEDURE ParseTypeCast(kind: CARDINAL); FORWARD;
 PROCEDURE ParseFuncCall(idx: CARDINAL): CARDINAL; FORWARD;
 PROCEDURE ExpandStdProc43(code: CARDINAL); FORWARD; (* FIXME: 0-arg call site *)
 PROCEDURE ExpandStdProc44(first: CARDINAL); FORWARD;
 PROCEDURE ExpandStdProc45(std: CARDINAL); FORWARD; (* FIXME: 0-arg call site *)
 PROCEDURE ExpandStdProc46; FORWARD;
-PROCEDURE GetConstVal; FORWARD;
-PROCEDURE PopExprDesc(d: DescPtr); FORWARD; (* FIXME: 0-arg call sites *)
-PROCEDURE PushExprDesc(dst: DescPtr; src: DescPtr); FORWARD; (* audit SWAP; arities still FIXME *)
-PROCEDURE ConstToCard(c: DescPtr; errPos: CARDINAL); FORWARD;
-PROCEDURE ConstToInt(c: DescPtr; errPos: CARDINAL); FORWARD;
 PROCEDURE MatchOpClass(allowed: BITSET; errCode: CARDINAL); FORWARD;
 PROCEDURE FoldConstOp(resTyp: DescPtr); FORWARD; (* FIXME: kind-result sites *)
 PROCEDURE EmitCompare; FORWARD;
-PROCEDURE EmitRangeCheck; FORWARD;
-PROCEDURE ParseSimpleExpression; FORWARD;
-PROCEDURE LoadOperand; FORWARD;
-PROCEDURE StoreOperand; FORWARD;
 PROCEDURE CheckRelationTypes(t1: ADDRESS); FORWARD; (* audit: op unused in body *)
 PROCEDURE FoldRelation(): ADDRESS; FORWARD;
-PROCEDURE ParseFactor(p1, p2, p3, p4, p5: CARDINAL); FORWARD; (* re-read: pK = paramK confirmed (InsertEntry-arg=param5, p2#0=param2, p3=9 test=param3); mirror hypothesis REJECTED, def stands *)
-PROCEDURE EvalConstExpr; FORWARD;
 PROCEDURE ParseSetOrCastTail; FORWARD;
-PROCEDURE ParseAssignment; FORWARD;
 PROCEDURE IsOrdinal(t: Compiler.RecordPtr): BOOLEAN; FORWARD;
 PROCEDURE IsSet(t2, t1: Compiler.RecordPtr): BOOLEAN; FORWARD;
 PROCEDURE BaseTypeOf(t2, t1: Compiler.RecordPtr): BOOLEAN; FORWARD;
 PROCEDURE CheckAssignable; FORWARD;
 PROCEDURE ParseSelector(sel: Compiler.RecordPtr; needVal: BOOLEAN; base: Compiler.RecordPtr); FORWARD;
-PROCEDURE ParseDesignatorBase(finA, finB, probeA, probeB: CARDINAL): BOOLEAN; FORWARD; (* re-read: 4 formals (fct_leave 132); param4/param3 = final operands (formals 1-2), param2/param1 = probe keys (formals 3-4); ok1..id2 dropped (unused); probeA/B assignment by call order TBD *)
 PROCEDURE GetTypeDesc(src: ADDRESS; dest: ADDRESS; mode: CARDINAL); FORWARD;
 PROCEDURE CheckAssignmentCompat(dst: ADDRESS); FORWARD;
 
 (* EXPRESS group 1 — descriptors, predicates, const-fold, designator base, selector *)
 
 (* proc4 @004a — ~PushExprDesc *)
+
+(* FIXME-NYC stubs (signatures per call sites; bodies TBD by MCD audit;
+   these 6 may merge with PushExprDesc/PopExprDesc/etc. once mapping lands). *)
+PROCEDURE PushOperand;
+BEGIN HALT; END PushOperand;
+PROCEDURE PopOperand;
+BEGIN HALT; END PopOperand;
+PROCEDURE CheckAndStore;
+BEGIN HALT; END CheckAndStore;
+PROCEDURE GetRangeBase;
+BEGIN HALT; END GetRangeBase;
+PROCEDURE IsPointer(t: CARDINAL): BOOLEAN;
+BEGIN HALT; END IsPointer;
+PROCEDURE TypeKindOf(): CARDINAL;
+BEGIN HALT; END TypeKindOf;
+
 PROCEDURE PushExprDesc(dst: DescPtr; src: DescPtr);
 VAR aligned: CARDINAL; (* local word-2 *)
 BEGIN
-  {/* 004a */} (* aligned := (src^.extra + 1) DIV 2 * 2 *)
+  (*{004a}*) (* aligned := (src^.extra + 1) DIV 2 * 2 *)
   aligned := (src^.extra + 1) DIV 2 * 2;
-  {/* 0054 */} (* if temp mark held, reserve space, check against SymTab pool *)
+  (*{0054}*) (* if temp mark held, reserve space, check against SymTab pool *)
   IF spillFlag <> 0 THEN
     DEC(spillTop, aligned);
     IF spillTop < SymTab.stringPoolPtr THEN
@@ -163,12 +117,12 @@ BEGIN
     END;
     spillTop := SymTab.stringPoolPtr; (* sync mark: 006a..006b *)
   END;
-  {/* 006d */} (* init new descriptor *)
+  (*{006d}*) (* init new descriptor *)
   dst^.mode := 1;
   IF spillFlag = 0 THEN dst^.kind := 0 ELSE dst^.kind := dst^.kind END;
   dst^.extra := spillTop;
   dst^.typ := src^.typ;
-  {/* 007e */} (* if fresh mark, claim space, overflow check 83 *)
+  (*{007e}*) (* if fresh mark, claim space, overflow check 83 *)
   IF spillFlag = 0 THEN
     INC(spillTop, aligned);
     IF spillTop > SymTab.stringPoolPtr THEN
@@ -181,17 +135,17 @@ END PushExprDesc;
 (* proc32 @0095 — ~IsOrdinal *)
 PROCEDURE IsOrdinal(t: RecordPtr): BOOLEAN;
 BEGIN
-  {/* 0095 */} (* subrange with CARDINAL bounds is not plain ordinal here *)
+  (*{0095}*) (* subrange with CARDINAL bounds is not plain ordinal here *)
   IF (t^.word4 = 1) AND (t^.word5 >= 0) AND (t^.word6 >= 0) THEN
     RETURN FALSE;
   END;
-  {/* 00ac */} (* unwrap alias: t := t^.word2 *)
+  (*{00ac}*) (* unwrap alias: t := t^.word2 *)
   t := t^.word2;
-  {/* 00af */} (* INTEGER is ordinal *)
+  (*{00af}*) (* INTEGER is ordinal *)
   IF t = Compiler.IntType THEN
     RETURN TRUE;
   END;
-  {/* 00ba */} (* otherwise ordinal iff class tag nonzero *)
+  (*{00ba}*) (* otherwise ordinal iff class tag nonzero *)
   RETURN t^.word4 <> 0;
 END IsOrdinal;
 
@@ -205,14 +159,14 @@ VAR
   lo, hi: INTEGER;    (* local word-6, word-7 *)
   sub: RecordPtr;     (* local word-8 *)
 BEGIN
-  {/* 00c0 */} (* only descriptors with kind-bit 7 set need pop work *)
+  (*{00c0}*) (* only descriptors with kind-bit 7 set need pop work *)
   IF NOT (7 IN BITSET(d^.kind)) THEN RETURN END;
-  {/* 00c8 */} (* classify *)
+  (*{00c8}*) (* classify *)
   isOrd := IsOrdinal(d^.typ);
   neg := isOrd < 0;
   hasRange := 3 IN BITSET(d^.kind);
   IF hasRange THEN lo := d^.low; hi := d^.high END;
-  {/* 00de */} (* constant-expression branch *)
+  (*{00de}*) (* constant-expression branch *)
   IF curDesc.mode = 0 THEN
     IF neg THEN
       IF (curDesc.typ = Compiler.CardType) OR (curDesc.value >= 0) THEN
@@ -232,7 +186,7 @@ BEGIN
     END;
     RETURN;
   END;
-  {/* 0120 */} (* codegen branch, range-check flag bit 8 *)
+  (*{0120}*) (* codegen branch, range-check flag bit 8 *)
   IF 8 IN Scanner.scanOpt THEN
     emitConv := FALSE;
     IF IsOrdinal(curDesc.typ) - isOrd = 2 THEN
@@ -267,7 +221,7 @@ END PopExprDesc;
 (* proc33 @017d — ~IsSet *)
 PROCEDURE IsSet(t2, t1: RecordPtr): BOOLEAN;
 BEGIN
-  {/* 017d */} (* set-compatibility: identity, subrange unwrap, BITSET/CARD compat *)
+  (*{017d}*) (* set-compatibility: identity, subrange unwrap, BITSET/CARD compat *)
   IF (t2 = t1) THEN RETURN TRUE END;
   IF (t2^.word4 = 1) AND IsSet(t2^.word2, t1) THEN RETURN TRUE END;
   IF (t1^.word4 = 1) AND IsSet(t2, t1^.word2) THEN RETURN TRUE END;
@@ -285,7 +239,7 @@ END IsSet;
 (* proc34 @01c5 — ~BaseTypeOf *)
 PROCEDURE BaseTypeOf(t2, t1: RecordPtr): BOOLEAN;
 BEGIN
-  {/* 01c5 */} (* base-type compatibility for assignment / param passing *)
+  (*{01c5}*) (* base-type compatibility for assignment / param passing *)
   IF (t2 = t1) THEN RETURN TRUE END;
   IF (t2 = t1) OR IsSet(t2, t1) THEN RETURN TRUE END;
   IF (t2^.word4 = 1) AND (BaseTypeOf(t2^.word2, t1)) THEN RETURN TRUE END;
@@ -299,7 +253,7 @@ END BaseTypeOf;
 (* proc35 @0212 — ~FoldConstOp *)
 PROCEDURE FoldConstOp(resTyp: RecordPtr);
 BEGIN
-  {/* 0212 */} (* both sides CARDINAL/INTEGER constants: keep resTyp *)
+  (*{0212}*) (* both sides CARDINAL/INTEGER constants: keep resTyp *)
   IF (resTyp^.typ = Compiler.IntType)
      AND ((curDesc.typ = Compiler.RealType)
           OR ((curDesc.typ = Compiler.CardType) AND (resTyp^.mode = 0))
@@ -307,7 +261,7 @@ BEGIN
     curDesc.typ := resTyp^.typ;
     RETURN;
   END;
-  {/* 023a */} (* mirrored: curDesc side constant *)
+  (*{023a}*) (* mirrored: curDesc side constant *)
   IF (curDesc.typ = Compiler.IntType)
      AND ((resTyp^.typ = Compiler.RealType)
           OR ((resTyp^.typ = Compiler.CardType) AND (curDesc.mode = 0))
@@ -315,7 +269,7 @@ BEGIN
     curDesc.typ := resTyp^.typ; (* 025a..025e *)
     RETURN;
   END;
-  {/* 0260 */} (* incompatible operand types *)
+  (*{0260}*) (* incompatible operand types *)
   IF NOT IsSet(resTyp^.typ, curDesc.typ) THEN
     Errors.ReportIncompatibleTypes(resTyp^.typ, curDesc.typ, 0);
   END;
@@ -324,14 +278,14 @@ END FoldConstOp;
 (* proc7 @0275 — ~ConstToCard *)
 PROCEDURE ConstToCard(c: DescPtr; errPos: CARDINAL);
 BEGIN
-  {/* 0275 */} (* CARDINAL context: reject INTEGER/alias mismatches, negatives *)
+  (*{0275}*) (* CARDINAL context: reject INTEGER/alias mismatches, negatives *)
   IF (c^.typ <> Compiler.CardType) AND (c^.kind <> 1)
      AND (c^.value <> Compiler.CardType) THEN
     IF curDesc.mode <> 0 THEN RETURN END;
     IF curDesc.typ <> Compiler.IntType THEN RETURN END;
     IF curDesc.value < 0 THEN RETURN END;
   END;
-  {/* 029c */} (* must be set-compatible with target element type *)
+  (*{029c}*) (* must be set-compatible with target element type *)
   IF NOT IsSet(c^.typ, curDesc.typ) THEN
     Errors.ReportAssignMismatch(c^.typ, curDesc.typ, errPos);
   END;
@@ -340,7 +294,7 @@ END ConstToCard;
 (* proc8 @02ac — ~ConstToInt *)
 PROCEDURE ConstToInt(c: DescPtr; errPos: CARDINAL);
 BEGIN
-  {/* 02ac */} (* INTEGER context: base-type check only *)
+  (*{02ac}*) (* INTEGER context: base-type check only *)
   IF NOT BaseTypeOf(c^.typ, curDesc.typ) THEN
     Errors.ReportAssignMismatch(c^.typ, curDesc.typ, errPos);
   END;
@@ -349,7 +303,7 @@ END ConstToInt;
 (* proc9 @02be — ~MatchOpClass *)
 PROCEDURE MatchOpClass(allowed: BITSET; errCode: CARDINAL);
 BEGIN
-  {/* 02be */} (* operator class check on current expression type *)
+  (*{02be}*) (* operator class check on current expression type *)
   IF NOT (curDesc.typ^.word4 IN allowed) THEN
     Errors.ReportTypeMismatch(errCode, curDesc.typ, allowed);
   END;
@@ -362,10 +316,10 @@ VAR
   w8, w9: CARDINAL;        (* local-8, local-9 *)
   f1, f2: CARDINAL;        (* local-2, local-3 *)
 BEGIN
-  {/* 02d0 */} (* double PASS1.CondInsert probe for qualified pair *)
+  (*{02d0}*) (* double PASS1.CondInsert probe for qualified pair *)
   Pass1.CondInsert(probeB, ADR(w8), ADR(f1), ADR(found1));
   Pass1.CondInsert(probeA, ADR(w9), ADR(f2), ADR(found2));
-  {/* 02e6 */} (* walk while both found *)
+  (*{02e6}*) (* walk while both found *)
   WHILE found1 AND found2 DO
     IF w8 <> w9 THEN RETURN FALSE END;
     (* FIXME: LookupField internal helper — decompile from @02f4 *)
@@ -376,7 +330,7 @@ BEGIN
     Pass1.InsertEntry(probeB, ADR(w8), ADR(f1), ADR(found1));
     Pass1.InsertEntry(probeA, ADR(w9), ADR(f2), ADR(found2));
   END;
-  {/* 0324 */} (* match iff same head and same tail selector *)
+  (*{0324}*) (* match iff same head and same tail selector *)
   RETURN (found1 = found2) AND (finA = finB);
 END ParseDesignatorBase;
 
@@ -384,7 +338,7 @@ END ParseDesignatorBase;
 PROCEDURE CheckAssignable();
 VAR save: CARDINAL; (* local-2 *)
 BEGIN
-  {/* 032f */} (* void context: discard pending load, force ADDRESS-typed empty desc *)
+  (*{032f}*) (* void context: discard pending load, force ADDRESS-typed empty desc *)
   IF (curDesc.mode = 0) AND (curDesc.typ = Compiler.AddressType) THEN
     CodeGen.DiscardPending();
     curDesc.typ := Compiler.CharType;
@@ -404,11 +358,11 @@ VAR
   t: RecordPtr;      (* local-2 *)
   flags: CARDINAL;   (* local-3 *)
 BEGIN
-  {/* 0358 */} (* selector only if previous type is structured *)
+  (*{0358}*) (* selector only if previous type is structured *)
   IF sel^.kind = 11 THEN CheckAssignable() END;
   t := curDesc.typ;
   IF NOT LookupField(sel) THEN RETURN END;
-  {/* 036a */} (* address/word indirection *)
+  (*{036a}*) (* address/word indirection *)
   IF sel^.typ = Compiler.AddressType THEN
     IF LookupField(t) THEN
       flags := t^.word3;
@@ -438,7 +392,7 @@ BEGIN
     END;
     RETURN;
   END;
-  {/* 03dc */} (* set-membership / index loop *)
+  (*{03dc}*) (* set-membership / index loop *)
   WHILE 2048H IN BITSET(sel^.kind) DO
     EmitAddress() (*FIXME: dropped sel*);
     sel := sel^.word5;
@@ -446,7 +400,7 @@ BEGIN
       IF sel^.typ = curDesc.typ THEN Errors.ReportError(64) END;
     END;
   END;
-  {/* 0401 */} (* dispatch on selector class *)
+  (*{0401}*) (* dispatch on selector class *)
   IF Scanner.AcceptSy(5) THEN
     IF (sel = t) OR ((sel = Compiler.BitsetType) AND (t^.kind = 5)) THEN
     ELSIF (sel^.kind = 5) AND (t = Compiler.BitsetType) THEN

src/compiler/PASS1.DEF

@@ -0,0 +1,11 @@
+(* PASS1 stub DEF — minimal interface for EXPRESS verification.
+   CondInsert/InsertEntry signatures proven from MCD call shapes:
+   4 pushes (value + 3 addresses), BOOLEAN use (jpfalse). Full PASS1.DEF
+   comes with the PASS1 verification pass (param names TBD). *)
+DEFINITION MODULE Pass1;
+FROM SYSTEM IMPORT ADDRESS;
+
+PROCEDURE CondInsert(flag: CARDINAL; a, b, c: ADDRESS): BOOLEAN;
+PROCEDURE InsertEntry(p1: CARDINAL; a, b, c: ADDRESS): BOOLEAN;
+
+END Pass1.