|
|
@@ -105,12 +105,12 @@ CONST symReadError = 790; (* RAISE code in LibRead {/*0497*/} *)
|
|
|
UnlinkScope/EnterIdent recursion cycle (group B) ---- *)
|
|
|
PROCEDURE SymbolAssert(cond: BOOLEAN; code: CARDINAL); FORWARD;
|
|
|
PROCEDURE CheckNode(node: T1); FORWARD;
|
|
|
-PROCEDURE EnterChained(node: T1; scope: ADDRESS); FORWARD;
|
|
|
-PROCEDURE AllocSym(node: T1; scope: ADDRESS); FORWARD;
|
|
|
-PROCEDURE UnlinkScope(idx: CARDINAL; scope: ADDRESS); FORWARD;
|
|
|
-PROCEDURE EnterIdent(idx: CARDINAL; scope: ADDRESS); FORWARD;
|
|
|
-PROCEDURE PutAttr(src: T1; VAR slot: CARDINAL); FORWARD;
|
|
|
-PROCEDURE GetAttr(idx: CARDINAL; VAR node: T1); FORWARD;
|
|
|
+PROCEDURE EnterChained(scope: ADDRESS; node: T1); FORWARD;
|
|
|
+PROCEDURE AllocSym(scope: ADDRESS; node: T1); FORWARD;
|
|
|
+PROCEDURE UnlinkScope(scope: ADDRESS; idx: CARDINAL); FORWARD;
|
|
|
+PROCEDURE EnterIdent(scope: ADDRESS; idx: CARDINAL); FORWARD;
|
|
|
+PROCEDURE PutAttr(VAR slot: CARDINAL; src: T1); FORWARD;
|
|
|
+PROCEDURE GetAttr(VAR node: T1; idx: CARDINAL); FORWARD;
|
|
|
PROCEDURE LookupChain(scopeNo: CARDINAL; key: CARDINAL): T1; FORWARD;
|
|
|
PROCEDURE InitHeaps; FORWARD;
|
|
|
PROCEDURE EnterStandards; FORWARD;
|
|
|
@@ -189,7 +189,7 @@ BEGIN
|
|
|
END;
|
|
|
END CheckNode;
|
|
|
|
|
|
-PROCEDURE NewString(src: ADDRESS; VAR off: CARDINAL);
|
|
|
+PROCEDURE NewString(VAR off: CARDINAL; src: ADDRESS);
|
|
|
(* proc17 @00d4 — intern a string into the string pool; returns pool offset *)
|
|
|
VAR len: CARDINAL;
|
|
|
BEGIN
|
|
|
@@ -204,7 +204,7 @@ BEGIN
|
|
|
END;
|
|
|
END NewString;
|
|
|
|
|
|
-PROCEDURE GetName(off: CARDINAL; VAR name: ADDRESS);
|
|
|
+PROCEDURE GetName(VAR name: ADDRESS; off: CARDINAL);
|
|
|
(* proc21 @0268 — inverse of NewString: heap copy of pooled string *)
|
|
|
BEGIN
|
|
|
IF off <> 0 THEN (*{/*026a*/}*)
|
|
|
@@ -214,7 +214,7 @@ BEGIN
|
|
|
END;
|
|
|
END GetName;
|
|
|
|
|
|
-PROCEDURE PutAttr(src: T1; VAR slot: CARDINAL);
|
|
|
+PROCEDURE PutAttr(VAR slot: CARDINAL; src: T1);
|
|
|
(* proc18 @0106 — store a type/attr node into the scope-descriptor table *)
|
|
|
VAR i: CARDINAL; e: Words; sw: Words;
|
|
|
BEGIN
|
|
|
@@ -246,7 +246,7 @@ BEGIN
|
|
|
e := Words(scopeHeapBase + 16 * scopeTop);
|
|
|
sw := Words(src);
|
|
|
e^[1] := 0; (*{/*016b*/}*)
|
|
|
- PutAttr(T1(sw^[2]), e^[2]); (* copy link2 chain {/*016e*/} *)
|
|
|
+ PutAttr(e^[2], T1(sw^[2])); (* copy link2 chain {/*016e*/} *)
|
|
|
e^[3] := sw^[3]; (*{/*0176*/}*)
|
|
|
e^[4] := sw^[4]; (* kind {/*017a*/} *)
|
|
|
CASE sw^[4] OF (* kind switch {/*01b3*/} *)
|
|
|
@@ -254,17 +254,17 @@ BEGIN
|
|
|
e^[5] := sw^[5]; e^[6] := sw^[6]; (*{/*0182*/}*)
|
|
|
| 99, 100:
|
|
|
CheckNode(T1(sw^[5])); (*{/*0192*/}*)
|
|
|
- EnterChained(T1(sw^[5]), ADR(e^[5])); (*{/*0197*/}*)
|
|
|
+ EnterChained(ADR(e^[5]), T1(sw^[5])); (*{/*0197*/}*)
|
|
|
| 101:
|
|
|
- PutAttr(T1(sw^[5]), e^[5]); (*{/*0189*/}*)
|
|
|
+ PutAttr(e^[5], T1(sw^[5])); (*{/*0189*/}*)
|
|
|
| 102:
|
|
|
- PutAttr(T1(sw^[5]), e^[5]); (*{/*019e*/}*)
|
|
|
- PutAttr(T1(sw^[6]), e^[6]);
|
|
|
+ PutAttr(e^[5], T1(sw^[5])); (*{/*019e*/}*)
|
|
|
+ PutAttr(e^[6], T1(sw^[6]));
|
|
|
e^[7] := sw^[7];
|
|
|
ELSE (* 92..98: name/link/attr words suffice *)
|
|
|
END;
|
|
|
END PutAttr;
|
|
|
-PROCEDURE GetAttr(idx: CARDINAL; VAR node: T1);
|
|
|
+PROCEDURE GetAttr(VAR node: T1; idx: CARDINAL);
|
|
|
(* proc22 @0281 — load a scope entry back into a heap node (inverse of PutAttr).
|
|
|
Entry word1 = static node pointer or memoized node (returned as-is). *)
|
|
|
VAR e: Words; new: T1; nw: Words;
|
|
|
@@ -280,18 +280,18 @@ BEGIN
|
|
|
nw := Words(new);
|
|
|
e^[1] := CARDINAL(new); (* memoize {/*029e*/} *)
|
|
|
node := new; (*{/*02a1*/}*)
|
|
|
- GetAttr(e^[2], new^.link2); (* subtype {/*02a4*/} *)
|
|
|
+ GetAttr(new^.link2, e^[2]); (* subtype {/*02a4*/} *)
|
|
|
nw^[3] := e^[3]; (*{/*02ac*/}*)
|
|
|
CASE e^[4] OF (* kind switch {/*02e1*/} *)
|
|
|
| 90, 91:
|
|
|
nw^[5] := e^[5]; nw^[6] := e^[6]; (*{/*02b4*/}*)
|
|
|
| 99, 100:
|
|
|
- UnlinkScope(e^[5], ADR(nw^[5])); (*{/*02c4*/}*)
|
|
|
+ UnlinkScope(ADR(nw^[5]), e^[5]); (*{/*02c4*/}*)
|
|
|
| 101:
|
|
|
- GetAttr(e^[5], nw^[5]); (*{/*02bb*/}*)
|
|
|
+ GetAttr(nw^[5], e^[5]); (*{/*02bb*/}*)
|
|
|
| 102:
|
|
|
- GetAttr(e^[5], nw^[5]); (*{/*02cc*/}*)
|
|
|
- GetAttr(e^[6], nw^[6]);
|
|
|
+ GetAttr(nw^[5], e^[5]); (*{/*02cc*/}*)
|
|
|
+ GetAttr(nw^[6], e^[6]);
|
|
|
nw^[7] := e^[7];
|
|
|
ELSE (* 92..98: nothing beyond words 1..4 *)
|
|
|
END;
|
|
|
@@ -300,7 +300,7 @@ END GetAttr;
|
|
|
(* NOTE (group B): the brief asked for AllocSym(nodeKind): T1, but the MCode
|
|
|
(proc14 @01d7, ProcLeave(2), uses param1+param2) is a 2-param PROCEDURE
|
|
|
chaining a 14-byte entry onto scope and filling it from node. *)
|
|
|
-PROCEDURE AllocSym(node: T1; scope: ADDRESS);
|
|
|
+PROCEDURE AllocSym(scope: ADDRESS; node: T1);
|
|
|
(* proc14 @01d7 — chain-allocate a 14-byte symbol-table entry from node *)
|
|
|
VAR s: Words; n: T1; nw: Words; sw: Words;
|
|
|
BEGIN
|
|
|
@@ -310,17 +310,17 @@ BEGIN
|
|
|
n := T1(s); nw := s; sw := Words(node);
|
|
|
s^[0] := Words(scope)^[0]; (*{/*01e9*/}*)
|
|
|
Words(scope)^[0] := symTop; (*{/*01ed*/}*)
|
|
|
- NewString(node^.link1, s^[1]); (*{/*01f0*/}*)
|
|
|
- PutAttr(node^.link2, s^[2]); (*{/*01f7*/}*)
|
|
|
+ NewString(s^[1], node^.link1); (*{/*01f0*/}*)
|
|
|
+ PutAttr(s^[2], node^.link2); (*{/*01f7*/}*)
|
|
|
n^.word3 := node^.word3; (*{/*01fe*/}*)
|
|
|
nw^[5] := sw^[5]; nw^[6] := sw^[6]; (* dword {/*0202*/} *)
|
|
|
n^.word4 := node^.word4; (* kind {/*0208*/} *)
|
|
|
IF node^.link2 = Compiler.charArrayDesc THEN (* COMPILER.word12 {/*020c*/} *)
|
|
|
- NewString(ADDRESS(sw^[5]), nw^[5]); (*{/*0213*/}*)
|
|
|
+ NewString(nw^[5], ADDRESS(sw^[5])); (*{/*0213*/}*)
|
|
|
ELSIF nw^[4] >= 5 THEN (*{/*021c*/}*)
|
|
|
CheckNode(T1(sw^[6])); (*{/*0222*/}*)
|
|
|
nw^[6] := 0; (*{/*0226*/}*)
|
|
|
- EnterChained(T1(sw^[6]), ADR(nw^[6])); (*{/*0229*/}*)
|
|
|
+ EnterChained(ADR(nw^[6]), T1(sw^[6])); (*{/*0229*/}*)
|
|
|
ELSIF (nw^[4] = 1) AND (node^.link2 = Compiler.LongrealType) THEN
|
|
|
(* COMPILER.word11: 8-byte real constant {/*0231*/} *)
|
|
|
SymbolAssert(strTop + 8 <= strCap, 85); (*{/*023e*/}*)
|
|
|
@@ -329,16 +329,16 @@ BEGIN
|
|
|
END;
|
|
|
END AllocSym;
|
|
|
|
|
|
-PROCEDURE EnterChained(node: T1; scope: ADDRESS);
|
|
|
+PROCEDURE EnterChained(scope: ADDRESS; node: T1);
|
|
|
(* proc13 @0259 — append a link0 node chain to scope (oldest first) *)
|
|
|
BEGIN
|
|
|
IF node <> NIL THEN (*{/*025b*/}*)
|
|
|
- EnterChained(node^.link0, scope); (*{/*025f*/}*)
|
|
|
- AllocSym(node, scope); (*{/*0263*/}*)
|
|
|
+ EnterChained(scope, node^.link0); (*{/*025f*/}*)
|
|
|
+ AllocSym(scope, node); (*{/*0263*/}*)
|
|
|
END;
|
|
|
END EnterChained;
|
|
|
|
|
|
-PROCEDURE EnterIdent(idx: CARDINAL; scope: ADDRESS);
|
|
|
+PROCEDURE EnterIdent(scope: ADDRESS; idx: CARDINAL);
|
|
|
(* proc20 @0305 — declare symbol-table entry idx into scope (dup check + attrs) *)
|
|
|
VAR sentry: Words; (* symHeapBase + idx*14 *)
|
|
|
new: T1; nw: Words;
|
|
|
@@ -351,7 +351,7 @@ BEGIN
|
|
|
new := Scanner.NewNode(sentry^[4]); (* kind; always 14 bytes {/*030d*/} *)
|
|
|
nw := Words(new);
|
|
|
nw^[0] := Words(scope)^[0]; (* chain at head {/*0312*/} *)
|
|
|
- GetName(sentry^[1], nm); (* heap copy of name {/*0316*/} *)
|
|
|
+ GetName(nm, sentry^[1]); (* heap copy of name {/*0316*/} *)
|
|
|
nw^[1] := CARDINAL(nm);
|
|
|
nmt := nm;
|
|
|
existing := Scanner.FindIdent(Scanner.List(scope), nm, 9 IN Scanner.scanOptions);
|
|
|
@@ -362,7 +362,7 @@ BEGIN
|
|
|
Errors.ReportErrorWithText(1, nmt^); (*{/*033a*/}*)
|
|
|
END;
|
|
|
Words(scope)^[0] := CARDINAL(new); (*{/*0341*/}*)
|
|
|
- GetAttr(sentry^[2], new^.link2); (*{/*0344*/}*)
|
|
|
+ GetAttr(new^.link2, sentry^[2]); (*{/*0344*/}*)
|
|
|
new^.word3 := BITSET(sentry^[3]); (*{/*034b*/}*)
|
|
|
new^.word4 := sentry^[4]; (*{/*034f*/}*)
|
|
|
IF sentry^[4] = 3 THEN (* constant: back-link value node {/*0353*/} *)
|
|
|
@@ -370,13 +370,13 @@ BEGIN
|
|
|
Words(new^.link2)^[0] := CARDINAL(new); (*{/*035f*/}*)
|
|
|
END;
|
|
|
ELSIF new^.link2 = Compiler.charArrayDesc THEN (* COMPILER.word12 {/*0365*/} *)
|
|
|
- GetName(sentry^[5], nm2); (*{/*0372*/}*)
|
|
|
+ GetName(nm2, sentry^[5]); (*{/*0372*/}*)
|
|
|
nw^[5] := CARDINAL(nm2);
|
|
|
ELSIF sentry^[4] >= 5 THEN (*{/*037b*/}*)
|
|
|
IF existing = NIL THEN (*{/*0381*/}*)
|
|
|
Scanner.GetStackMark(mark); (*{/*0385*/}*)
|
|
|
nw^[6] := 0; (*{/*0389*/}*)
|
|
|
- UnlinkScope(sentry^[6], ADR(nw^[6])); (*{/*038c*/}*)
|
|
|
+ UnlinkScope(ADR(nw^[6]), sentry^[6]); (*{/*038c*/}*)
|
|
|
IF (sentry^[4] = 5) AND (stageFlag <> 0) THEN (*{/*0393*/} global25 *)
|
|
|
Compiler.allocateSignature(new, mark); (* COMPILER.dword27 gate {/*039d*/} *)
|
|
|
END;
|
|
|
@@ -390,14 +390,14 @@ BEGIN
|
|
|
END;
|
|
|
END EnterIdent;
|
|
|
|
|
|
-PROCEDURE UnlinkScope(idx: CARDINAL; scope: ADDRESS);
|
|
|
+PROCEDURE UnlinkScope(scope: ADDRESS; idx: CARDINAL);
|
|
|
(* proc19 @03c9 — re-declare a link0 index chain into scope (oldest first) *)
|
|
|
VAR e: Words;
|
|
|
BEGIN
|
|
|
IF idx <> 0 THEN (*{/*03cb*/}*)
|
|
|
e := Words(symHeapBase + 14 * idx);
|
|
|
- UnlinkScope(e^[0], scope); (*{/*03cf*/}*)
|
|
|
- EnterIdent(idx, scope); (*{/*03d8*/}*)
|
|
|
+ UnlinkScope(scope, e^[0]); (*{/*03cf*/}*)
|
|
|
+ EnterIdent(scope, idx); (*{/*03d8*/}*)
|
|
|
END;
|
|
|
END UnlinkScope;
|
|
|
|
|
|
@@ -551,7 +551,7 @@ VAR
|
|
|
END ListExports;
|
|
|
|
|
|
PROCEDURE ImportOne(anchor: ADDRESS; symIdx: CARDINAL);
|
|
|
- (* proc31 @05be, nested. NOTE arg order flipped to B's EnterIdent(idx, scope);
|
|
|
+ (* proc31 @05be, nested. EnterIdent(scope, idx) per audit (pushes (scope,idx));
|
|
|
original call order was (anchor, symIdx) — MCD diff decides. *)
|
|
|
VAR e: SymEntryPtr;
|
|
|
BEGIN
|
|
|
@@ -559,7 +559,7 @@ VAR
|
|
|
e := symHeapBase + symIdx * 14; (*{/*05c4*/}*)
|
|
|
ImportOne(anchor, e^.link); (*{/*05ca*/}*)
|
|
|
IF 0 IN e^.flags THEN (*{/*05d0*/}*)
|
|
|
- EnterIdent(symIdx, anchor); (*{/*05d6*/}*)
|
|
|
+ EnterIdent(anchor, symIdx); (*{/*05d6*/}*)
|
|
|
END;
|
|
|
END;
|
|
|
END ImportOne;
|
|
|
@@ -642,11 +642,11 @@ BEGIN
|
|
|
WHILE sib # 0 DO
|
|
|
e2 := symHeapBase + sib * 14;
|
|
|
IF (e2^.ref # e^.ref) OR NOT (9 IN e2^.flags) THEN EXIT END; (*{/*072d*/}*)
|
|
|
- EnterIdent(sib, ADR(currentScope^.link1)); (*{/*0747*/}*)
|
|
|
+ EnterIdent(ADR(currentScope^.link1), sib); (*{/*0747*/}*)
|
|
|
sib := e2^.link;
|
|
|
END;
|
|
|
END;
|
|
|
- EnterIdent(findIdx, ADR(currentScope^.link1)); (*{/*0756*/}*)
|
|
|
+ EnterIdent(ADR(currentScope^.link1), findIdx); (*{/*0756*/}*)
|
|
|
Scanner.GetSym; (*{/*075c*/}*)
|
|
|
Scanner.TestSymbolInSet(BITSET{1,9}); (*{/*075e*/}*)
|
|
|
UNTIL NOT Scanner.AcceptSymbol(1); (* "," {/*0763*/} *)
|
|
|
@@ -745,7 +745,7 @@ BEGIN
|
|
|
i.e. list/name swapped; order TBD from @088a. *)
|
|
|
END BuildBitsetConst;
|
|
|
|
|
|
-PROCEDURE DefineProgramModule(fromSeen: CARDINAL);
|
|
|
+PROCEDURE DefineProgramModule(setAddr: ADDRESS; tag: CARDINAL); (*FIXME: audit UNKNOWN — body uses param2 as INCL target, never param1; fromSeen is local-3; 2nd formal role unknown*)
|
|
|
(* proc3 @089a. FIXME: heavy FIXME — group D's reading of @089a-0914 tangles
|
|
|
moduleTable^[16] (a Symbol slot) with T1 chain operations; treat as
|
|
|
first-draft sketch, not ground truth. *)
|
|
|
@@ -800,7 +800,7 @@ BEGIN
|
|
|
END;
|
|
|
Scanner.GetStackMark(mark);
|
|
|
Scanner.CheckStackMark(mark); (* FIXME: group passed symOptions; mark form kept *)
|
|
|
- UnlinkScope(CARDINAL(modName), modName); (* FIXME: args TBD; proc19 *)
|
|
|
+ UnlinkScope(modName, CARDINAL(modName)); (* FIXME: arg roles TBD; proc19 *)
|
|
|
END InitSymbolTables;
|
|
|
|
|
|
PROCEDURE NoteImported;
|
|
|
@@ -889,7 +889,7 @@ BEGIN
|
|
|
IF base^.word4 = 5 THEN INCL(base^.word3, 5) END;
|
|
|
INC(i);
|
|
|
END;
|
|
|
- UnlinkScope(CARDINAL(currentScope^.link1), currentScope^.link1); (* FIXME args *)
|
|
|
+ UnlinkScope(currentScope^.link1, CARDINAL(currentScope^.link1)); (* FIXME arg roles TBD *)
|
|
|
i := 15;
|
|
|
WHILE i <= scopeTop DO (*{/*0ae8*/}*)
|
|
|
base := T1(scopeHeapBase + i * 16);
|
