|
|
@@ -179,7 +179,7 @@ BEGIN
|
|
|
cursor := Words(cursor)^[0]; (*{00bd-00bf} next link *)
|
|
|
IF cursor = NIL THEN EXIT END; (*{00c0-00c2}*)
|
|
|
END;
|
|
|
- Scanner.CheckStackMark(ADDRESS(limit)); (*{00c4-00c5} FIXME: limit punned as mark *)
|
|
|
+ Scanner.CheckStk(ADDRESS(limit)); (*{00c4-00c5} FIXME: limit punned as mark *)
|
|
|
allocSize := ((count + 15) DIV 16) * 2; (*{00c7-00cc} *)
|
|
|
Scanner.Allocate(heapStr, allocSize + count * 2 + 2); (*{00cf-00d8} *)
|
|
|
Words(heapStr)^[0] := count; (*{00da-00dc}*)
|
|
|
@@ -273,9 +273,9 @@ END TypeSizeRec;
|
|
|
PROCEDURE GetIdent(): ADDRESS; (*{0201} FIXME: name says ident, returns a TYPE *)
|
|
|
VAR typ: ADDRESS;
|
|
|
BEGIN
|
|
|
- Scanner.PushWithScope; (*{0203} *)
|
|
|
- Scanner.ExpectIdentKind(3); (*{0205-0206} *)
|
|
|
- typ := Scanner.literalType; (*{0208-020a} pre-GetSym *)
|
|
|
+ Scanner.PushWith; (*{0203} *)
|
|
|
+ Scanner.ExpectKd(3); (*{0205-0206} *)
|
|
|
+ typ := Scanner.litType; (*{0208-020a} pre-GetSym *)
|
|
|
Scanner.GetSym; (*{020b}*)
|
|
|
RETURN typ; (*{020d-020e}*)
|
|
|
END GetIdent;
|
|
|
@@ -286,12 +286,12 @@ VAR
|
|
|
item: ADDRESS;
|
|
|
node: ADDRESS;
|
|
|
BEGIN
|
|
|
- Scanner.ExpectSymbol(42); (*{0213-0216} FROM *)
|
|
|
- node := Scanner.NewSizedNode(5); (*{0217-021a}*)
|
|
|
+ Scanner.ExpectSy(42); (*{0213-0216} FROM *)
|
|
|
+ node := Scanner.NewSized(5); (*{0217-021a}*)
|
|
|
Words(node)^[3] := 2; (*{021b-021e}*)
|
|
|
- IF (first # 0) AND (Scanner.identKind = 0)
|
|
|
- AND (Scanner.scopeCursor = NIL) THEN (*{021e-0229} *)
|
|
|
- item := Scanner.DeclareIdentifier(0); (*{022b-022f} plain item *)
|
|
|
+ IF (first # 0) AND (Scanner.identKd = 0)
|
|
|
+ AND (Scanner.scopeCur = NIL) THEN (*{021e-0229} *)
|
|
|
+ item := Scanner.DeclIden(0); (*{022b-022f} plain item *)
|
|
|
Words(item)^[2] := node; (*{0230-0232} *)
|
|
|
ELSE
|
|
|
Words(node)^[2] := ParseType(); (*{0235-0239} FIXME: 0-arg vs 3-param def *)
|
|
|
@@ -308,14 +308,14 @@ VAR
|
|
|
idxDesc: ADDRESS;
|
|
|
elemDesc: ADDRESS;
|
|
|
BEGIN
|
|
|
- arrDesc := Scanner.NewSizedNode(11); (*{0240-0243}*)
|
|
|
+ arrDesc := Scanner.NewSized(11); (*{0240-0243}*)
|
|
|
idxDesc := ParseType(); (*{0244-0248} FIXME arity *)
|
|
|
Words(Express.curDesc.raw[0])^[0] := idxDesc; (*{024c-0250} *)
|
|
|
Express.MatchOpClass(BITSET{3}, 47); (*{0251-0253} index ordinal *)
|
|
|
- IF Scanner.AcceptSymbol(1) THEN (*{0255-0256} *)
|
|
|
+ IF Scanner.AcceptSy(1) THEN (*{0255-0256} *)
|
|
|
elemDesc := ParseConstDecl(); (*{025a-025d} recurse *)
|
|
|
ELSE
|
|
|
- Scanner.ExpectSymbol(41); (*{0260-0262} OF *)
|
|
|
+ Scanner.ExpectSy(41); (*{0260-0262} OF *)
|
|
|
elemDesc := ParseType(); (*{0264-0268} FIXME arity *)
|
|
|
END;
|
|
|
Words(arrDesc)^[5] := elemDesc; (*{0269-026b} *)
|
|
|
@@ -329,7 +329,7 @@ END ParseConstDecl;
|
|
|
PROCEDURE ParseVarDecl(first: WORD); (*{027b} FIXME punned ADDRESS/value *)
|
|
|
VAR desc: ADDRESS;
|
|
|
BEGIN
|
|
|
- desc := Scanner.NewSizedNode(1); (*{027d-0280} subrange desc *)
|
|
|
+ desc := Scanner.NewSized(1); (*{027d-0280} subrange desc *)
|
|
|
Express.GetConstVal; (*{0281} lower bound *)
|
|
|
IF first = 0 THEN (*{0283-0285} anonymous *)
|
|
|
Words(desc)^[2] := Words(Express.curDesc.raw[0])^[0]; (*{0287-028c} *)
|
|
|
@@ -340,7 +340,7 @@ BEGIN
|
|
|
END;
|
|
|
Express.MatchOpClass(BITSET{5}, 0); (*{029e-02a0} FIXME errCode 0 *)
|
|
|
Words(desc)^[5] := Words(Express.curDesc.raw[0])^[2]; (*{02a2-02a6} lo value *)
|
|
|
- Scanner.ExpectSymbol(4); (*{02a7-02a8} `..` *)
|
|
|
+ Scanner.ExpectSy(4); (*{02a7-02a8} `..` *)
|
|
|
Express.GetConstVal; (*{02aa} upper bound *)
|
|
|
Express.ConstToCard(Words(desc)^[2], 0); (*{02ac-02af} FIXME order *)
|
|
|
Words(desc)^[6] := Words(Express.curDesc.raw[0])^[2]; (*{02b1-02b5} hi value *)
|
|
|
@@ -349,7 +349,7 @@ BEGIN
|
|
|
ELSE
|
|
|
Express.CentralError(Words(desc)^[6] >= Words(desc)^[5], 46); (*{02c8-02cf} *)
|
|
|
END;
|
|
|
- Scanner.ExpectSymbol(6); (*{02d1-02d2} `]` *)
|
|
|
+ Scanner.ExpectSy(6); (*{02d1-02d2} `]` *)
|
|
|
Words(desc)^[3] := ORD((Words(desc)^[5] > 32767) OR (Words(desc)^[6] > 255)) + 1; (*{02d4-02e2} *)
|
|
|
RETURN desc; (*{02e2-02e3}*)
|
|
|
END ParseVarDecl;
|
|
|
@@ -366,27 +366,27 @@ VAR t, u: ADDRESS;
|
|
|
enumBase: ADDRESS;
|
|
|
tmp: CARDINAL;
|
|
|
BEGIN
|
|
|
- WHILE Scanner.curSymbol IN BITSET{9984H} DO (*{02eb} FIXME: set TBD *)
|
|
|
- IF Scanner.AcceptSymbol(40) THEN (*{02f5} *)
|
|
|
- IF Scanner.AcceptSymbol(2) THEN (*{02fb} *)
|
|
|
+ WHILE Scanner.curSym IN BITSET{9984H} DO (*{02eb} FIXME: set TBD *)
|
|
|
+ IF Scanner.AcceptSy(40) THEN (*{02f5} *)
|
|
|
+ IF Scanner.AcceptSy(2) THEN (*{02fb} *)
|
|
|
elemT := CARDINAL(GetIdent()); (*{0300} FIXME pun *)
|
|
|
ELSE
|
|
|
- Scanner.DeclareIdentifier(4); (*{0308} *)
|
|
|
+ Scanner.DeclIden(4); (*{0308} *)
|
|
|
typ := owner; (*{030d-0327} FIXME: stack shuffles idealized *)
|
|
|
elemT := CARDINAL(GetIdent());
|
|
|
END;
|
|
|
Express.MatchOpClass(BITSET{7}, 40); (*{032c} *)
|
|
|
- Scanner.ExpectSymbol(41); (*{0331} *)
|
|
|
+ Scanner.ExpectSy(41); (*{0331} *)
|
|
|
enumBase := typ; (*{0335} *)
|
|
|
cnt := 0; (*{0338} *)
|
|
|
- WHILE NOT (Scanner.curSymbol IN BITSET{9472H}) DO (*{033a-03b1} enum loop *)
|
|
|
+ WHILE NOT (Scanner.curSym IN BITSET{9472H}) DO (*{033a-03b1} enum loop *)
|
|
|
tmp := cnt; t := elemT; (*{0343-0344}*)
|
|
|
Express.GetTypeDesc(loA, hiA, NIL); (*{0346} FIXME: (dest,mode,src) roles *)
|
|
|
lo := CARDINAL(loA); hi := CARDINAL(hiA); (*{034c-034f} FIXME pun *)
|
|
|
IF lo <= hi THEN (*{0350} *)
|
|
|
t := cnt;
|
|
|
REPEAT
|
|
|
- t := Scanner.NewSizedNode(12); (*{0357} *)
|
|
|
+ t := Scanner.NewSized(12); (*{0357} *)
|
|
|
Words(t)^[6] := u; Words(t)^[2] := elemT; (*{035b-0366} FIXME pun *)
|
|
|
Words(t)^[3] := enumBase; Words(t)^[7] := lo; (*{0361-0366}*)
|
|
|
IF u # NIL THEN (*{0367} *)
|
|
|
@@ -396,30 +396,30 @@ BEGIN
|
|
|
INC(lo); (*{0378-037a} *)
|
|
|
UNTIL lo > hi;
|
|
|
END;
|
|
|
- IF NOT (Scanner.TestSymbolInSet(6) AND Scanner.AcceptSymbol(1)) THEN EXIT END; (*{037c-0384} FIXME: TestSymbolInSet is VOID assert *)
|
|
|
+ IF NOT (Scanner.TestSet(6) AND Scanner.AcceptSy(1)) THEN EXIT END; (*{037c-0384} FIXME: TestSymbolInSet is VOID assert *)
|
|
|
Scanner.GetSym; (*{0386} *)
|
|
|
t := cnt;
|
|
|
typ := ParseType(owner, t, limit); (*{0388-0390} recursive FIXME arity *)
|
|
|
u := typ;
|
|
|
IF Words(t)^[3] > limit THEN limit := Words(t)^[3]; END; (*{03a6-03b0} *)
|
|
|
END;
|
|
|
- WHILE NOT (Scanner.TestSymbolInSet(8) AND Scanner.AcceptSymbol(1)) DO END; (*{03b6-03ba} FIXME shape *)
|
|
|
- IF Scanner.AcceptSymbol(10) THEN (*{03bc-03bf} *)
|
|
|
+ WHILE NOT (Scanner.TestSet(8) AND Scanner.AcceptSy(1)) DO END; (*{03b6-03ba} FIXME shape *)
|
|
|
+ IF Scanner.AcceptSy(10) THEN (*{03bc-03bf} *)
|
|
|
tmp := CARDINAL(ParseType(owner, tmp, limit)); (*{03c1-03c7} FIXME pun *)
|
|
|
IF CARDINAL(enumBase) > limit THEN limit := CARDINAL(enumBase); END; (*{03c9-03d1} FIXME *)
|
|
|
END;
|
|
|
- Scanner.ExpectSymbol(13); (*{03d2} *)
|
|
|
+ Scanner.ExpectSy(13); (*{03d2} *)
|
|
|
typ := ADDRESS(cnt); (*{03d5-03d7} FIXME pun *)
|
|
|
ELSE
|
|
|
- Scanner.DeclareIdentifier(4); (*{03da} *)
|
|
|
+ Scanner.DeclIden(4); (*{03da} *)
|
|
|
tmp := Scanner.curNode; (*{03de} FIXME: ADDRESS := RecordPtr pun *)
|
|
|
- WHILE NOT (Scanner.TestSymbolInSet(6) AND Scanner.AcceptSymbol(1)) DO END; (*{03e2-03e9} FIXME shape *)
|
|
|
+ WHILE NOT (Scanner.TestSet(6) AND Scanner.AcceptSy(1)) DO END; (*{03e2-03e9} FIXME shape *)
|
|
|
Scanner.GetSym; (*{03eb} *)
|
|
|
elemT := CARDINAL(ParseFormalParams()); (*{03ed} FIXME pun *)
|
|
|
typ := owner; (*{03f2-0406} FIXME: TypeSizeRec + word9 wiring *)
|
|
|
tmp := TypeSizeRec(owner, elemT, elemT, elemT, elemT); (*{03f7-0400} FIXME: 5-arg shape TBD *)
|
|
|
END;
|
|
|
- IF NOT Scanner.AcceptSymbol(9) THEN EXIT END; (*{0407-040b} *)
|
|
|
+ IF NOT Scanner.AcceptSy(9) THEN EXIT END; (*{0407-040b} *)
|
|
|
END;
|
|
|
RETURN typ; (*{040e} *)
|
|
|
END ParseType;
|
|
|
@@ -429,42 +429,42 @@ PROCEDURE ParseFormalParams(): ADDRESS;
|
|
|
VAR head, n, kind: CARDINAL;
|
|
|
tail, cur: ADDRESS;
|
|
|
BEGIN
|
|
|
- IF Scanner.AcceptSymbol(43) THEN (*{0413} *)
|
|
|
- head := CARDINAL(Scanner.NewSizedNode(0)); n := 0; (*{0419-041e} FIXME pun *)
|
|
|
- Scanner.DeclareIdentifier(1); kind := CARDINAL(Scanner.curNode); (*{041f-0423} FIXME *)
|
|
|
+ IF Scanner.AcceptSy(43) THEN (*{0413} *)
|
|
|
+ head := CARDINAL(Scanner.NewSized(0)); n := 0; (*{0419-041e} FIXME pun *)
|
|
|
+ Scanner.DeclIden(1); kind := CARDINAL(Scanner.curNode); (*{041f-0423} FIXME *)
|
|
|
INC(n);
|
|
|
- WHILE Scanner.TestSymbolInSet(34) AND Scanner.AcceptSymbol(1) DO (*{0432-0439} FIXME shape *)
|
|
|
- Scanner.DeclareIdentifier(1);
|
|
|
+ WHILE Scanner.TestSet(34) AND Scanner.AcceptSy(1) DO (*{0432-0439} FIXME shape *)
|
|
|
+ Scanner.DeclIden(1);
|
|
|
END;
|
|
|
Scanner.GetSym; (*{043c} *)
|
|
|
- ELSIF Scanner.AcceptSymbol(44) THEN (*{044c-044e} *)
|
|
|
+ ELSIF Scanner.AcceptSy(44) THEN (*{044c-044e} *)
|
|
|
head := CARDINAL(ParseVarDecl(0)); (* nested proc18 FIXME *)
|
|
|
- ELSIF Scanner.AcceptSymbol(50) THEN (*{0458-045b} *)
|
|
|
- Scanner.ExpectSymbol(41); (*{045e} *)
|
|
|
- head := CARDINAL(Scanner.NewSizedNode(4)); (*{0462} FIXME *)
|
|
|
+ ELSIF Scanner.AcceptSy(50) THEN (*{0458-045b} *)
|
|
|
+ Scanner.ExpectSy(41); (*{045e} *)
|
|
|
+ head := CARDINAL(Scanner.NewSized(4)); (*{0462} FIXME *)
|
|
|
Words(ADDRESS(head))^[3] := 2; (*{0466-0468} FIXME *)
|
|
|
tail := ParseFormalParams(); (*{0469} FIXME: recursion? *)
|
|
|
Words(ADDRESS(head))^[2] := tail; (*{046d-046f} FIXME *)
|
|
|
Express.MatchOpClass(BITSET{3}, 50); (*{0470-0477} *)
|
|
|
IF Words(tail)^[6] > 15 THEN Express.CentralError(TRUE, 41); END; (*{0479} FIXME cond *)
|
|
|
- ELSIF Scanner.AcceptSymbol(48) THEN (*{0483-0486} *)
|
|
|
+ ELSIF Scanner.AcceptSy(48) THEN (*{0483-0486} *)
|
|
|
head := CARDINAL(ParseImportItem(0)); (*{0489} FIXME *)
|
|
|
- ELSIF Scanner.AcceptSymbol(21) THEN (*{0490-0493} *)
|
|
|
- head := CARDINAL(Scanner.NewSizedNode(9)); (*{0496} FIXME *)
|
|
|
+ ELSIF Scanner.AcceptSy(21) THEN (*{0490-0493} *)
|
|
|
+ head := CARDINAL(Scanner.NewSized(9)); (*{0496} FIXME *)
|
|
|
Words(ADDRESS(head))^[3] := 4; (*{049a-049c} FIXME *)
|
|
|
ParseRecordType(ADDRESS(head), sizeTmp, 1); (*{049d-04a5} FIXME: VAR/size shape TBD *)
|
|
|
- ELSIF Scanner.AcceptSymbol(47) THEN (*{04a9-04ac} *)
|
|
|
+ ELSIF Scanner.AcceptSy(47) THEN (*{04a9-04ac} *)
|
|
|
head := CARDINAL(ParseConstDecl()); (* nested proc17 *)
|
|
|
- ELSIF Scanner.AcceptSymbol(49) THEN (*{04b4-04b7} *)
|
|
|
- head := CARDINAL(Scanner.NewSizedNode(10)); (*{04ba} FIXME *)
|
|
|
- Scanner.OpenScope(SymTab.currentScope, NIL); (*{04bd-04bf} FIXME args *)
|
|
|
+ ELSIF Scanner.AcceptSy(49) THEN (*{04b4-04b7} *)
|
|
|
+ head := CARDINAL(Scanner.NewSized(10)); (*{04ba} FIXME *)
|
|
|
+ Scanner.OpenScop(SymTab.currentScope, NIL); (*{04bd-04bf} FIXME args *)
|
|
|
ParseType(ADDRESS(head), typeTmp, typeLim); (*{04c1-04cd} FIXME args *)
|
|
|
- Scanner.ExpectSymbol(13); (*{04cf} *)
|
|
|
+ Scanner.ExpectSy(13); (*{04cf} *)
|
|
|
SymTab.currentScope := Scanner.curNode; (*{04d2-04d5} FIXME: T1 := RecordPtr pun *)
|
|
|
IF Words(ADDRESS(head))^[3] < 2 THEN Words(ADDRESS(head))^[3] := 2; END; (*{04d7-04df} *)
|
|
|
ELSE
|
|
|
head := CARDINAL(GetIdent()); (*{04e2} FIXME pun *)
|
|
|
- IF Scanner.AcceptSymbol(44) THEN head := CARDINAL(ParseVarDecl(0)); END; (*{04e6-04ef} *)
|
|
|
+ IF Scanner.AcceptSy(44) THEN head := CARDINAL(ParseVarDecl(0)); END; (*{04e6-04ef} *)
|
|
|
END;
|
|
|
RETURN ADDRESS(head); (*{04f0} FIXME pun *)
|
|
|
END ParseFormalParams;
|
|
|
@@ -473,7 +473,7 @@ END ParseFormalParams;
|
|
|
PROCEDURE ParseValParam(): ADDRESS;
|
|
|
VAR t: ADDRESS;
|
|
|
BEGIN
|
|
|
- IF Scanner.AcceptSymbol(48) THEN (*{04f6} *)
|
|
|
+ IF Scanner.AcceptSy(48) THEN (*{04f6} *)
|
|
|
t := ParseImportItem(0); (*{04fc-04fe} FIXME arg *)
|
|
|
ELSE
|
|
|
t := ParseFormalParams(); (*{0503-0504} *)
|
|
|
@@ -485,9 +485,9 @@ END ParseValParam;
|
|
|
PROCEDURE ParseVarParam;
|
|
|
VAR t: ADDRESS;
|
|
|
BEGIN
|
|
|
- WHILE Scanner.curSymbol = 0 DO (*{050d-0543} *)
|
|
|
- t := Scanner.MakeIdentifierNode(1); (*{0512-0514} FIXME: ADDRESS := ADDRESS ok *)
|
|
|
- Scanner.ExpectSymbol(52); (*{0516-0518} *)
|
|
|
+ WHILE Scanner.curSym = 0 DO (*{050d-0543} *)
|
|
|
+ t := Scanner.MakeIden(1); (*{0512-0514} FIXME: ADDRESS := ADDRESS ok *)
|
|
|
+ Scanner.ExpectSy(52); (*{0516-0518} *)
|
|
|
Express.GetConstVal; (*{051b} *)
|
|
|
Words(t)^[2] := Express.curDesc.raw[0]; (*{051d-0521} FIXME pun *)
|
|
|
Words(t)^[6] := Express.curDesc.raw[2]; (*{0522-0528} dword spill idealized *)
|
|
|
@@ -495,8 +495,8 @@ BEGIN
|
|
|
AND (Words(t)^[6] = 0) THEN (*{0529-0537} FIXME: compilationActive BOOLEAN vs 0 *)
|
|
|
OpenScopeEmit(t); (*{053a} *)
|
|
|
END;
|
|
|
- Scanner.InsertSymbol(t); (*{053c-0541} FIXME: T1 pun *)
|
|
|
- Scanner.ExpectSymbol(9); (*{0542} *)
|
|
|
+ Scanner.InsertSy(t); (*{053c-0541} FIXME: T1 pun *)
|
|
|
+ Scanner.ExpectSy(9); (*{0542} *)
|
|
|
END;
|
|
|
END ParseVarParam;
|
|
|
|
|
|
@@ -506,29 +506,29 @@ VAR saveScope: ADDRESS; tag, fld: CARDINAL;
|
|
|
node: ADDRESS;
|
|
|
BEGIN
|
|
|
saveScope := ADDRESS(SymTab.currentScope); (*{054a-0550} FIXME pun *)
|
|
|
- IF Scanner.curSymbol = 0 THEN (*{054e-0551} *)
|
|
|
- Scanner.NeedIdentifier; tag := CARDINAL(Scanner.curNode); (*{0553-0556} FIXME *)
|
|
|
- IF Scanner.TestSymbolInSet(6) THEN (*{0558?} FIXME: group wove word13/identKind guards; shape TBD *)
|
|
|
+ IF Scanner.curSym = 0 THEN (*{054e-0551} *)
|
|
|
+ Scanner.NeedID; tag := CARDINAL(Scanner.curNode); (*{0553-0556} FIXME *)
|
|
|
+ IF Scanner.TestSet(6) THEN (*{0558?} FIXME: group wove word13/identKind guards; shape TBD *)
|
|
|
Scanner.GetSym;
|
|
|
- Scanner.ExpectSymbol(52);
|
|
|
+ Scanner.ExpectSy(52);
|
|
|
fld := CARDINAL(ParseValParam()); (*{056d-0570} FIXME *)
|
|
|
Words(ADDRESS(tag))^[2] := fld; (*{0571-0579} FIXME *)
|
|
|
ELSE
|
|
|
- tag := CARDINAL(Scanner.MakeIdentifierNode(3)); (*{05b9-05bd} FIXME *)
|
|
|
- IF Compiler.compilationActive AND (Scanner.curSymbol = 9) THEN (*{05be-05c6} *)
|
|
|
- fld := CARDINAL(Scanner.NewSizedNode(6)); Words(ADDRESS(fld))^[3] := 2; (*{05c8-05ce} FIXME *)
|
|
|
+ tag := CARDINAL(Scanner.MakeIden(3)); (*{05b9-05bd} FIXME *)
|
|
|
+ IF Compiler.compilationActive AND (Scanner.curSym = 9) THEN (*{05be-05c6} *)
|
|
|
+ fld := CARDINAL(Scanner.NewSized(6)); Words(ADDRESS(fld))^[3] := 2; (*{05c8-05ce} FIXME *)
|
|
|
ELSE
|
|
|
- Scanner.ExpectSymbol(52); (*{05d1-05d3} *)
|
|
|
+ Scanner.ExpectSy(52); (*{05d1-05d3} *)
|
|
|
fld := CARDINAL(ParseValParam()); (*{05d5-05d8} *)
|
|
|
END;
|
|
|
Words(ADDRESS(tag))^[2] := fld; (*{05d9-05db} FIXME *)
|
|
|
- Scanner.InsertSymbol(ADDRESS(tag)); (*{05dc-05dd} FIXME T1 pun *)
|
|
|
+ Scanner.InsertSy(ADDRESS(tag)); (*{05dc-05dd} FIXME T1 pun *)
|
|
|
END;
|
|
|
- Scanner.ExpectSymbol(9); (*{05e0} *)
|
|
|
+ Scanner.ExpectSy(9); (*{05e0} *)
|
|
|
ELSE
|
|
|
tag := CARDINAL(SymTab.currentScope); node := saveScope; (*{05ed-05f1} FIXME *)
|
|
|
WHILE ADDRESS(tag) # node DO (*{05f1-0605} FIXME *)
|
|
|
- IF ADDRESS(tag) = NIL THEN Errors.ReportErrorWithText(5, Scanner.tokenBuffer); END; (*{05f9-0600} *)
|
|
|
+ IF ADDRESS(tag) = NIL THEN Errors.ReportErrorWithText(5, Scanner.tokBuf); END; (*{05f9-0600} *)
|
|
|
tag := CARDINAL(Words(ADDRESS(tag))^[0]); (*{0602-0604} FIXME *)
|
|
|
END;
|
|
|
END;
|
|
|
@@ -539,23 +539,23 @@ PROCEDURE EvalConstExpr;
|
|
|
VAR t, u, v: CARDINAL;
|
|
|
n: CARDINAL;
|
|
|
BEGIN
|
|
|
- WHILE Scanner.curSymbol = 0 DO (*{060c-0682} *)
|
|
|
+ WHILE Scanner.curSym = 0 DO (*{060c-0682} *)
|
|
|
t := CARDINAL(SymTab.currentScope); (*{0611-0613} FIXME *)
|
|
|
- Scanner.DeclareIdentifier(4); u := CARDINAL(Scanner.curNode); (*{0615-0619} FIXME *)
|
|
|
+ Scanner.DeclIden(4); u := CARDINAL(Scanner.curNode); (*{0615-0619} FIXME *)
|
|
|
Words(ADDRESS(u))^[4] := Express.spillFlag; (*{061b-061d} FIXME *)
|
|
|
- IF Scanner.AcceptSymbol(44) THEN (*{061e-0622} *)
|
|
|
+ IF Scanner.AcceptSy(44) THEN (*{061e-0622} *)
|
|
|
Express.GetConstVal; (*{0624} *)
|
|
|
Express.ConstToCard(Compiler.CardType, 44); (*{0626-062a} FIXME: (type,code) vs DEF order *)
|
|
|
Words(ADDRESS(u))^[2] := Express.curDesc.raw[2]; (*{062b-062f} FIXME *)
|
|
|
Words(ADDRESS(u))^[3] := 256; (*{0631-0637} *)
|
|
|
- Scanner.ExpectSymbol(6); (*{0638} *)
|
|
|
+ Scanner.ExpectSy(6); (*{0638} *)
|
|
|
END;
|
|
|
- IF NOT (Scanner.TestSymbolInSet(6) AND Scanner.AcceptSymbol(1)) THEN EXIT END; (*{0639-0640} FIXME shape *)
|
|
|
+ IF NOT (Scanner.TestSet(6) AND Scanner.AcceptSy(1)) THEN EXIT END; (*{0639-0640} FIXME shape *)
|
|
|
Scanner.GetSym; (*{0642} *)
|
|
|
v := CARDINAL(ParseFormalParams()); (*{0644-0647} FIXME *)
|
|
|
IF Words(ADDRESS(v))^[4] > 9 THEN n := 2; ELSE n := (Words(ADDRESS(v))^[3] + 1) DIV 2; END; (*{0648-0659} FIXME *)
|
|
|
TypeSizeRec(ADDRESS(t), ADDRESS(u), ADR(SymTab.stringPoolPtr), ADDRESS(v), n); (*{065a-0662} FIXME: 5-arg punned shape *)
|
|
|
- Scanner.ExpectSymbol(9); (*{0664} *)
|
|
|
+ Scanner.ExpectSy(9); (*{0664} *)
|
|
|
IF Express.spillFlag = 0 THEN (*{0667-066d} *)
|
|
|
IF SymTab.stringPoolPtr <= 510 THEN Express.CentralError(TRUE, 83); END; (*{066c-0674} FIXME cond *)
|
|
|
ELSE
|
|
|
@@ -568,9 +568,9 @@ END EvalConstExpr;
|
|
|
PROCEDURE CheckConformant(): ADDRESS;
|
|
|
VAR t: ADDRESS;
|
|
|
BEGIN
|
|
|
- IF Scanner.AcceptSymbol(47) THEN (*{0689-068d} *)
|
|
|
- Scanner.ExpectSymbol(41); (*{068f-0691} *)
|
|
|
- t := Scanner.NewSizedNode(11); (*{0693-0695} *)
|
|
|
+ IF Scanner.AcceptSy(47) THEN (*{0689-068d} *)
|
|
|
+ Scanner.ExpectSy(41); (*{068f-0691} *)
|
|
|
+ t := Scanner.NewSized(11); (*{0693-0695} *)
|
|
|
CheckConformantTail(t); (*{0697-0699} FIXME: self/nested-variant TBD *)
|
|
|
ELSE
|
|
|
t := GetIdent(); (*{069e-06a0} *)
|
|
|
@@ -586,19 +586,19 @@ VAR total: CARDINAL;
|
|
|
lo, hi: CARDINAL;
|
|
|
BEGIN
|
|
|
total := 6; size := 0; (*{06a9-06b0} *)
|
|
|
- IF Scanner.curSymbol # 9 THEN (*{06b1-06b5} *)
|
|
|
- Scanner.ExpectSymbol(43); (*{06b7-06b9} *)
|
|
|
- IF NOT Scanner.AcceptSymbol(5) THEN GOTO noFixed END; (*{06bb-06bf} *)
|
|
|
- Scanner.OpenScope(SymTab.currentScope, NIL); (*{06c1-06c4} FIXME args *)
|
|
|
- IF Scanner.AcceptSymbol(20) THEN code := 24; ELSE code := 8; END; (*{06c7-06d3} *)
|
|
|
+ IF Scanner.curSym # 9 THEN (*{06b1-06b5} *)
|
|
|
+ Scanner.ExpectSy(43); (*{06b7-06b9} *)
|
|
|
+ IF NOT Scanner.AcceptSy(5) THEN GOTO noFixed END; (*{06bb-06bf} *)
|
|
|
+ Scanner.OpenScop(SymTab.currentScope, NIL); (*{06c1-06c4} FIXME args *)
|
|
|
+ IF Scanner.AcceptSy(20) THEN code := 24; ELSE code := 8; END; (*{06c7-06d3} *)
|
|
|
IF tag # 0 THEN (*{06d4} *)
|
|
|
fld := Scanner.NewNode(4); (*{06d7-06d9} *)
|
|
|
Words(fld)^[1] := SymTab.currentScope; Words(fld)^[0] := SymTab.currentScope; (*{06db-06e3} FIXME T1 pun *)
|
|
|
Words(fld)^[3] := code; disc := 1; hi := 34; (*{06e4-06eb} *)
|
|
|
ELSE
|
|
|
- Scanner.DeclareIdentifier(4); fld := Scanner.curNode; (*{06ee-06f2} FIXME T1 pun *)
|
|
|
+ Scanner.DeclIden(4); fld := Scanner.curNode; (*{06ee-06f2} FIXME T1 pun *)
|
|
|
Words(fld)^[3] := code; Words(fld)^[6] := Express.spillFlag + 1; (*{06f3-06fb} FIXME *)
|
|
|
- IF NOT (Scanner.TestSymbolInSet(6) AND Scanner.AcceptSymbol(1)) THEN EXIT END; (* FIXME shape *)
|
|
|
+ IF NOT (Scanner.TestSet(6) AND Scanner.AcceptSy(1)) THEN EXIT END; (* FIXME shape *)
|
|
|
Scanner.GetSym; disc := 9; hi := 544; (*{0704-070b} *)
|
|
|
END;
|
|
|
fixedLoop:
|
|
|
@@ -606,7 +606,7 @@ BEGIN
|
|
|
cur := fld;
|
|
|
WHILE cur # rec DO cur := Words(cur)^[0]; END; (*{0711-071b} *)
|
|
|
rec := fld; (*{071d-071f} *)
|
|
|
- IF NOT Scanner.TestSymbolInSet(hi) THEN GOTO doneVariants END; (*{0720-0726} FIXME set TBD *)
|
|
|
+ IF NOT Scanner.TestSet(hi) THEN GOTO doneVariants END; (*{0720-0726} FIXME set TBD *)
|
|
|
Scanner.GetSym; (*{0729} *)
|
|
|
IF fld # NIL THEN (*{072b-072d} *)
|
|
|
fld := Words(fld)^[2]; head := fld; (*{072f-0733} *)
|
|
|
@@ -621,7 +621,7 @@ BEGIN
|
|
|
END;
|
|
|
SymTab.currentScope := SymTab.currentScope; (*{0765-0768} self-store? slot shuffle FIXME *)
|
|
|
noFixed:
|
|
|
- IF Scanner.AcceptSymbol(2) THEN (*{076a-076d} *)
|
|
|
+ IF Scanner.AcceptSy(2) THEN (*{076a-076d} *)
|
|
|
disc := CARDINAL(GetIdent()); (*{076f-0772} FIXME *)
|
|
|
Express.MatchOpClass(BITSET{511}, 2); (*{0773-077b} *)
|
|
|
size := disc; (*{077d-077f} *)
|
|
|
@@ -632,9 +632,9 @@ END ParseRecordType;
|
|
|
(* proc25 @0783 — ~CloseScopeFixup. 0 formals. *)
|
|
|
PROCEDURE CloseScopeFixup;
|
|
|
BEGIN
|
|
|
- IF 0 IN Scanner.curSymbol THEN (*{0785-078a} FIXME: CARDINAL set test *)
|
|
|
+ IF 0 IN Scanner.curSym THEN (*{0785-078a} FIXME: CARDINAL set test *)
|
|
|
Texts.WriteString(3, ""); (*{078c-0791} FIXME: proc21 args TBD *)
|
|
|
- Texts.WriteString(3, Scanner.tokenBuffer); (*{0793-0798} FIXME *)
|
|
|
+ Texts.WriteString(3, Scanner.tokBuf); (*{0793-0798} FIXME *)
|
|
|
Texts.WriteLn(3); (*{079a-079c} FIXME *)
|
|
|
END;
|
|
|
INC(nestDepth); (*{079d-079f} FIXME: group used Pass1.tempDepth *)
|
|
|
@@ -656,20 +656,20 @@ PROCEDURE ParseProcedureDecl;
|
|
|
VAR l2, l3, l4, l5: ADDRESS; s0, s1, s2, s3, s5, s6: WORD;
|
|
|
BEGIN
|
|
|
CloseScopeFixup; (*{07aa} proc25 *)
|
|
|
- Scanner.NeedIdentifier; (*{07ad} *)
|
|
|
- IF (Scanner.word13 = SymTab.currentScope) & (Compiler.scopeSpare3 = NIL) & (5 IN Scanner.followSet) THEN (*{07af-07bf} FIXME codes *)
|
|
|
+ Scanner.NeedID; (*{07ad} *)
|
|
|
+ IF (Scanner.word13 = SymTab.currentScope) & (Compiler.scopeSpare3 = NIL) & (5 IN Scanner.follSet) THEN (*{07af-07bf} FIXME codes *)
|
|
|
l3 := Scanner.curNode; (*{07c1-07c3} FIXME pun *)
|
|
|
Scanner.Allocate(ADR(l2), 14); (*{07c4-07c7} FIXME: group wrote Proc7 *)
|
|
|
MOVE(l3, l2, 14); (*{07c9-07cc} FIXME dst/src order *)
|
|
|
Scanner.GetSym; (*{07d6} *)
|
|
|
ELSE
|
|
|
- l2 := Scanner.DeclareIdentifier(5); (*{07da-07de} *)
|
|
|
+ l2 := Scanner.DeclIden(5); (*{07da-07de} *)
|
|
|
Words(l2)^[5] := PushTempMark(); (*{07df-07e4} FIXME pun *)
|
|
|
Words(l2 + 1)^[5] := Express.spillFlag; (*{07e5-07eb} FIXME cell *)
|
|
|
END;
|
|
|
- Scanner.GetStackMark(ADR(l6)); (*{07ec-07ee} FIXME slot *)
|
|
|
+ Scanner.GetStack(ADR(l6)); (*{07ec-07ee} FIXME slot *)
|
|
|
ParseRecordType(l2 + 6, l2 + 2, 0); (*{07f0-07f8} FIXME: ADDRESS arith + (rec,size,tag) roles *)
|
|
|
- Scanner.ExpectSymbol(9); (*{07fa-07fb} *)
|
|
|
+ Scanner.ExpectSy(9); (*{07fa-07fb} *)
|
|
|
IF 5 IN Words(l2)^[3] THEN (*{07fd-0801} FIXME: group ternary w/ s3 TBD *)
|
|
|
Express.CentralError(TRUE, 68); (*{080f-0814} FIXME: Proc21 8-cell call TBD *)
|
|
|
WHILE l4 # NIL DO (*{0816-082f} formal walk FIXME *)
|
|
|
@@ -677,13 +677,13 @@ BEGIN
|
|
|
l4 := Words(l4)^[0];
|
|
|
END;
|
|
|
Words(l2)^[3] := Words(l2)^[3] - BITSET{5}; (*{0831-0838} *)
|
|
|
- Scanner.CheckStackMark(l2 + 14); (*{0839-083c} FIXME arith *)
|
|
|
+ Scanner.CheckStk(l2 + 14); (*{0839-083c} FIXME arith *)
|
|
|
ParseProcBody(l2); (*{0843} `f9 proc9` *)
|
|
|
ELSE
|
|
|
IF Compiler.scopeSpare3 = NIL THEN (*{0846-0849} *)
|
|
|
- IF Scanner.AcceptSymbol(67) THEN (*{084b-084e} FIXME: 67=END? *)
|
|
|
+ IF Scanner.AcceptSy(67) THEN (*{084b-084e} FIXME: 67=END? *)
|
|
|
s3 := 32; (*{0851-0856} FIXME *)
|
|
|
- Scanner.ExpectSymbol(9); (*{0856} *)
|
|
|
+ Scanner.ExpectSy(9); (*{0856} *)
|
|
|
ELSE
|
|
|
ParseProcBody(l2); (*{085a-085b} *)
|
|
|
InsertSetConst(NIL, 0); (*{085c-085e} FIXME args *)
|
|
|
@@ -699,13 +699,13 @@ VAR l2, l3: ADDRESS;
|
|
|
BEGIN
|
|
|
CloseScopeFixup; (*{087d} *)
|
|
|
l3 := ADDRESS(Statemen.withPending); (*{087e-087f} FIXME pun *)
|
|
|
- l2 := Scanner.DeclareIdentifier(6); (*{0880-0884} *)
|
|
|
- IF Scanner.AcceptSymbol(44) THEN (*{0885-0887} FIXME: 44 here? *)
|
|
|
+ l2 := Scanner.DeclIden(6); (*{0880-0884} *)
|
|
|
+ IF Scanner.AcceptSy(44) THEN (*{0885-0887} FIXME: 44 here? *)
|
|
|
Statemen.withPending := 1; (*{088b-088c} *)
|
|
|
Express.EvalConstExpr; (*{088d} FIXME: group saw proc13=GetConstVal *)
|
|
|
- Scanner.ExpectSymbol(6); (*{088f-0891} *)
|
|
|
+ Scanner.ExpectSy(6); (*{088f-0891} *)
|
|
|
END;
|
|
|
- Scanner.ExpectSymbol(9); (*{0893-0894} *)
|
|
|
+ Scanner.ExpectSy(9); (*{0893-0894} *)
|
|
|
EmitModuleProlog(l2); (*{0896-0897} FIXME-NYC *)
|
|
|
Statemen.withPending := CARDINAL(l3); (*{0898-0899} FIXME *)
|
|
|
DEC(nestDepth); (*{089b-089d} *)
|
|
|
@@ -715,7 +715,7 @@ END ParseModuleHead;
|
|
|
PROCEDURE ParseExportList;
|
|
|
VAR l2: ADDRESS; l3: WORD;
|
|
|
BEGIN
|
|
|
- l2 := Scanner.DeclareIdentifier(2); (*{08b4-08b8} *)
|
|
|
+ l2 := Scanner.DeclIden(2); (*{08b4-08b8} *)
|
|
|
l3 := PushTempMark(); (*{08b9-08ba} FIXME: WORD := CARDINAL pun *)
|
|
|
IF Compiler.scopeSpare3 = NIL THEN (*{08be-08c1} *)
|
|
|
CodeGen.OpenFixup(1, l3, 0); (*{08c3-08c6} FIXME: (pos?,...) arity *)
|
|
|
@@ -724,8 +724,8 @@ BEGIN
|
|
|
CodeGen.EmitConst(l2); (*{08d5} FIXME-NYC *)
|
|
|
CodeGen.EmitConst2(l2, s1); (*{08d7-08d9} FIXME-NYC *)
|
|
|
END;
|
|
|
- Scanner.TestSymbolInSet(514); (*{08dc-08df} FIXME: CARDINAL set pun *)
|
|
|
- WHILE NOT Scanner.AcceptSymbol(1) DO (*{08e1-08e5} FIXME loop shape *)
|
|
|
+ Scanner.TestSet(514); (*{08dc-08df} FIXME: CARDINAL set pun *)
|
|
|
+ WHILE NOT Scanner.AcceptSy(1) DO (*{08e1-08e5} FIXME loop shape *)
|
|
|
Scanner.GetSym; (*{08e7} *)
|
|
|
END;
|
|
|
END ParseExportList;
|
|
|
@@ -736,7 +736,7 @@ VAR l2: CARDINAL; l3: ADDRESS; l4: WORD;
|
|
|
BEGIN
|
|
|
l4 := Express.spillFlag; (*{08f3-08f5} FIXME: group wrote word4 *)
|
|
|
l3 := SymTab.currentScope; (*{08f6-08f8} FIXME T1 pun *)
|
|
|
- l2 := Scanner.curSymbol; (*{08f9-08fc} *)
|
|
|
+ l2 := Scanner.curSym; (*{08f9-08fc} *)
|
|
|
Scanner.GetSym; (*{08fd} *)
|
|
|
CASE l2 OF (*{08fe-0913} callswitch 104..112 *)
|
|
|
104: ParseExportList(); (*{0901} *)
|
|
|
@@ -755,16 +755,16 @@ PROCEDURE ParseDeclarations(follow: BITSET): BOOLEAN;
|
|
|
VAR l2: CARDINAL; l3: CARDINAL; l4: CARDINAL; l5: CARDINAL;
|
|
|
l6: ADDRESS; l7: ADDRESS;
|
|
|
BEGIN
|
|
|
- l2 := CARDINAL(Scanner.scanOptions); (*{0945-0947} FIXME pun *)
|
|
|
- l3 := Scanner.tokenPos; (*{0948-094b} FIXME: group wrote word25 *)
|
|
|
- Scanner.GetStackMark(ADR(l6)); (*{094c-094e} *)
|
|
|
+ l2 := CARDINAL(Scanner.scanOpt); (*{0945-0947} FIXME pun *)
|
|
|
+ l3 := Scanner.tokPos; (*{0948-094b} FIXME: group wrote word25 *)
|
|
|
+ Scanner.GetStack(ADR(l6)); (*{094c-094e} *)
|
|
|
l5 := CodeGen.nextEmitPos; (*{0950-0952} FIXME: group wrote word2 *)
|
|
|
l7 := SymTab.currentScope; (*{0953-0956} FIXME pun *)
|
|
|
l4 := SymTab.moduleCount + SymTab.stringPoolPtr * 128; (*{0957-095e} FIXME: group packed word4+word5 *)
|
|
|
- IF (Scanner.curSymbol = 13) OR (Scanner.curSymbol = 23) THEN (*{095f-096a} FIXME codes *)
|
|
|
+ IF (Scanner.curSym = 13) OR (Scanner.curSym = 23) THEN (*{095f-096a} FIXME codes *)
|
|
|
Statemen.GuardedStatSeq(follow); (*{096c-096d} *)
|
|
|
ELSE
|
|
|
- Scanner.TestSymbolInSet(2018); (*{0971-0974} FIXME: CARDINAL set pun *)
|
|
|
+ Scanner.TestSet(2018); (*{0971-0974} FIXME: CARDINAL set pun *)
|
|
|
ParseDeclSync(); (*{0976} *)
|
|
|
WHILE NOT TryParseDecl(follow) DO END; (*{0977-097a} FIXME polarity *)
|
|
|
END;
|
|
|
@@ -773,10 +773,10 @@ BEGIN
|
|
|
SymTab.moduleCount := l4 MOD 256; (*{097f-0983} FIXME *)
|
|
|
AllocSymEntry((l4 DIV 256) * 2); (*{0984-098a} FIXME role *)
|
|
|
IF Errors.savedEditPos > l3 THEN (*{098d-0993} FIXME: group wrote word2 *)
|
|
|
- Scanner.tokenPos := l3; (*{0995-0996} *)
|
|
|
- Scanner.scanOptions := BITSET(l2); (*{0999-099a} FIXME *)
|
|
|
+ Scanner.tokPos := l3; (*{0995-0996} *)
|
|
|
+ Scanner.scanOpt := BITSET(l2); (*{0999-099a} FIXME *)
|
|
|
CodeGen.nextEmitPos := l5; (*{099c-099d} FIXME: assignable? *)
|
|
|
- Scanner.CheckStackMark(l6); (*{099f-09a0} *)
|
|
|
+ Scanner.CheckStk(l6); (*{099f-09a0} *)
|
|
|
Errors.RollbackToMark; (*{09a2} *)
|
|
|
CodeGen.OpenEmitter; (*{09a4} *)
|
|
|
RETURN FALSE; (*{09a7-09a8} *)
|
|
|
@@ -786,14 +786,14 @@ END ParseDeclarations;
|
|
|
(*{09b9} IMEXDC — ParseImportFrom. 0 params. *)
|
|
|
PROCEDURE ParseImportFrom;
|
|
|
BEGIN
|
|
|
- IF (Scanner.curSymbol = 15) OR (Scanner.curSymbol = 16) THEN (*{09bb-09c6} FIXME codes *)
|
|
|
+ IF (Scanner.curSym = 15) OR (Scanner.curSym = 16) THEN (*{09bb-09c6} FIXME codes *)
|
|
|
SymTab.DefineDefinitionModule(0); (*{09c8-09cc} FIXME: 2 pushes vs 1 formal *)
|
|
|
ParseImportScope(); (*{09ce-09cf} FIXME-NYC *)
|
|
|
- ELSIF (Scanner.curSymbol = 23) OR (Scanner.curSymbol = 13) THEN (*{09d3-09de} *)
|
|
|
+ ELSIF (Scanner.curSym = 23) OR (Scanner.curSym = 13) THEN (*{09d3-09de} *)
|
|
|
Statemen.GuardedStatSeq(BITSET{}); (*{09e0-09e2} FIXME: extra push TBD *)
|
|
|
ELSE
|
|
|
- Scanner.TestSymbolInSet(2046); (*{09e6-09e9} FIXME pun *)
|
|
|
- IF Scanner.curSymbol = 17 THEN (*{09eb-09ef} *)
|
|
|
+ Scanner.TestSet(2046); (*{09e6-09e9} FIXME pun *)
|
|
|
+ IF Scanner.curSym = 17 THEN (*{09eb-09ef} *)
|
|
|
SymTab.DefineProgramModule(0); (*{09f2-09f9} FIXME: 6 pushes vs 1 formal *)
|
|
|
ELSE
|
|
|
ParseDeclSync(); (*{09fd} *)
|
|
|
@@ -810,8 +810,8 @@ BEGIN
|
|
|
l2 := SymTab.currentScope; (*{0a0e-0a10} FIXME pun *)
|
|
|
l3 := SymTab.ownNamePtr; (*{0a11-0a13} FIXME: group wrote word11 *)
|
|
|
SymTab.ownNamePtr := NIL; (*{0a14-0a15} FIXME *)
|
|
|
- Scanner.OpenScope(SymTab.currentScope, NIL); (*{0a17-0a1a} FIXME args *)
|
|
|
- Scanner.GetStackMark(ADR(l5)); (*{0a1d-0a1f} FIXME slot *)
|
|
|
+ Scanner.OpenScop(SymTab.currentScope, NIL); (*{0a17-0a1a} FIXME args *)
|
|
|
+ Scanner.GetStack(ADR(l5)); (*{0a1d-0a1f} FIXME slot *)
|
|
|
ParseImportScope(); (*{0a21} *)
|
|
|
Scanner.GetSym; (*{0a23} *)
|
|
|
l4 := SymTab.ownNamePtr; (*{0a25-0a27} FIXME *)
|
|
|
@@ -829,13 +829,13 @@ END ParseModuleBlock;
|
|
|
PROCEDURE ParseProcBody(procNode: ADDRESS);
|
|
|
VAR l2: CARDINAL; l3: ADDRESS; l4: CARDINAL;
|
|
|
BEGIN
|
|
|
- Scanner.GetStackMark(ADR(l3)); (*{0a58-0a5a} *)
|
|
|
+ Scanner.GetStack(ADR(l3)); (*{0a58-0a5a} *)
|
|
|
l2 := SymTab.stringPoolPtr; (*{0a5c-0a5e} FIXME: group wrote word5 *)
|
|
|
SymTab.stringPoolPtr := 510; (*{0a5f-0a62} FIXME pun *)
|
|
|
- Scanner.OpenScope(SymTab.currentScope, procNode); (*{0a64-0a68} FIXME: 3rd push TBD *)
|
|
|
+ Scanner.OpenScop(SymTab.currentScope, procNode); (*{0a64-0a68} FIXME: 3rd push TBD *)
|
|
|
Express.spillFlag := Express.spillFlag + 1; (*{0a6b-0a6d} FIXME: group wrote word4 *)
|
|
|
- Scanner.PushWithScope; (*{0a70} *)
|
|
|
- IF Scanner.curSymbol = 0 THEN (*{0a72?} FIXME: group wove word10/9/8 guard; shape TBD *)
|
|
|
+ Scanner.PushWith; (*{0a70} *)
|
|
|
+ IF Scanner.curSym = 0 THEN (*{0a72?} FIXME: group wove word10/9/8 guard; shape TBD *)
|
|
|
Statemen.GuardedStatSeq(BITSET{}); (*{0a85-0a86} FIXME arg *)
|
|
|
ELSE
|
|
|
l4 := 0; (*{0a8f-0a90} *)
|
|
|
@@ -846,7 +846,7 @@ BEGIN
|
|
|
Scanner.GetSym; (*{0ac2} *)
|
|
|
Express.spillFlag := Express.spillFlag - 1; (*{0ac9-0acc} FIXME *)
|
|
|
SymTab.stringPoolPtr := l2; (*{0ace-0acf} FIXME *)
|
|
|
- Scanner.CheckStackMark(l3); (*{0ad1-0ad2} *)
|
|
|
+ Scanner.CheckStk(l3); (*{0ad1-0ad2} *)
|
|
|
Words(emitBase)^[0] := Scanner.codeSize; (*{0ad4-0ade} FIXME: indexed-emit shape *)
|
|
|
END ParseProcBody;
|
|
|
|
|
|
@@ -857,21 +857,21 @@ VAR l2: ADDRESS; l3: ADDRESS;
|
|
|
l6: CARDINAL; l7: CARDINAL;
|
|
|
l8, l10: CARDINAL; l9: ADDRESS;
|
|
|
BEGIN
|
|
|
- Scanner.GetStackMark(ADR(l9)); (*{0af1-0af3} *)
|
|
|
- Scanner.AcceptSymbol(25); (*{0af5-0af7} *)
|
|
|
- l6 := ORD(NOT Compiler.scopeSpare3) AND ORD(Scanner.AcceptSymbol(24)); (*{0af9-0b0d} FIXME shape *)
|
|
|
- Scanner.ExpectSymbol(22); (*{0b0e-0b10} *)
|
|
|
+ Scanner.GetStack(ADR(l9)); (*{0af1-0af3} *)
|
|
|
+ Scanner.AcceptSy(25); (*{0af5-0af7} *)
|
|
|
+ l6 := ORD(NOT Compiler.scopeSpare3) AND ORD(Scanner.AcceptSy(24)); (*{0af9-0b0d} FIXME shape *)
|
|
|
+ Scanner.ExpectSy(22); (*{0b0e-0b10} *)
|
|
|
l7 := 0; (*{0b12-0b13} *)
|
|
|
- l3 := Scanner.MakeIdentifierNode(5); (*{0b4e-0b52} *)
|
|
|
- IF Scanner.AcceptSymbol(44) THEN (*{0b53-0b55} FIXME: 44 here? *)
|
|
|
+ l3 := Scanner.MakeIden(5); (*{0b4e-0b52} *)
|
|
|
+ IF Scanner.AcceptSy(44) THEN (*{0b53-0b55} FIXME: 44 here? *)
|
|
|
IF Statemen.withPending # 0 THEN (*{0b59-0b5b} *)
|
|
|
- Scanner.ExpectIdentKind(1); Scanner.GetSym; (*{0b5d-0b60} *)
|
|
|
- Scanner.ExpectSymbol(6); (*{0b62-0b63} *)
|
|
|
+ Scanner.ExpectKd(1); Scanner.GetSym; (*{0b5d-0b60} *)
|
|
|
+ Scanner.ExpectSy(6); (*{0b62-0b63} *)
|
|
|
END;
|
|
|
END;
|
|
|
- Scanner.ExpectSymbol(9); (*{0b65-0b66} *)
|
|
|
- Scanner.TestSymbolInSet(2031); (*{0b68-0b6b} FIXME pun *)
|
|
|
- IF Compiler.scopeSpare3 OR (l6 # 0) OR (Scanner.curSymbol - 13 IN BITSET{0..12}) THEN (*{0b6d-0b7a} FIXME *)
|
|
|
+ Scanner.ExpectSy(9); (*{0b65-0b66} *)
|
|
|
+ Scanner.TestSet(2031); (*{0b68-0b6b} FIXME pun *)
|
|
|
+ IF Compiler.scopeSpare3 OR (l6 # 0) OR (Scanner.curSym - 13 IN BITSET{0..12}) THEN (*{0b6d-0b7a} FIXME *)
|
|
|
CASE CARDINAL(0) OF (*{0ba1} FIXME: Loader.Proc5()+1 DIV 2 dispatch, codes 92/93/94 *)
|
|
|
92: SymTab.CompileDispatch(l2, TRUE, l6 # 0); (*{0b83-0b8c} FIXME: 5 pushes vs 3 formals *)
|
|
|
| 93: SymTab.CompileDispatch(l2, TRUE, l6 # 0); (*{0b8d-0b96} FIXME *)
|
|
|
@@ -900,7 +900,7 @@ BEGIN
|
|
|
END;
|
|
|
l4 := Words(l4)^[0]; (*{0c40-0c42} *)
|
|
|
END;
|
|
|
- IF (Scanner.curSymbol # 23) AND (Scanner.curSymbol # 13) THEN (*{0c45-0c50} *)
|
|
|
+ IF (Scanner.curSym # 23) AND (Scanner.curSym # 13) THEN (*{0c45-0c50} *)
|
|
|
WHILE NOT TryParseDecl(0) DO END; (*{0c52-0c55} FIXME arg *)
|
|
|
ELSE
|
|
|
Statemen.GuardedStatSeq(BITSET{}); (*{0c59-0c5a} FIXME arg *)
|
|
|
@@ -910,8 +910,8 @@ BEGIN
|
|
|
RETURN TRUE; (*{0c62-0c63} *)
|
|
|
(* guarded-recovery handler: *)
|
|
|
IF Errors.savedEditPos > l10 THEN (*{0c65-0c69} FIXME: group wrote word2; l10 uninit here TBD *)
|
|
|
- Scanner.tokenPos := l10; Scanner.scanOptions := BITSET(l8); (*{0c6b-0c70} FIXME *)
|
|
|
- Scanner.CheckStackMark(l9); (*{0c72} *)
|
|
|
+ Scanner.tokPos := l10; Scanner.scanOpt := BITSET(l8); (*{0c6b-0c70} FIXME *)
|
|
|
+ Scanner.CheckStk(l9); (*{0c72} *)
|
|
|
Errors.RollbackToMark; (*{0c75} *)
|
|
|
CodeGen.OpenEmitter; (*{0c77} *)
|
|
|
RETURN FALSE; (*{0c7a-0c7b} *)
|
|
|
@@ -930,7 +930,7 @@ BEGIN
|
|
|
CodeGen.CloseFixup(Words(emitBase)^[l2], 0); (*{0ca4-0ca8} FIXME pun *)
|
|
|
END;
|
|
|
IF CodeGen.windowBase = 0 THEN (*{0cd2-0cd5} FIXME: group wrote word3 *)
|
|
|
- MOVE(Scanner.codeBuffer, l3, 16); (*{0cd7-0cdc} FIXME dst/src order *)
|
|
|
+ MOVE(Scanner.codeBuf, l3, 16); (*{0cd7-0cdc} FIXME dst/src order *)
|
|
|
END;
|
|
|
IF Compiler.rangeCheckEnabled = FALSE THEN (*{0cef-0cf1} FIXME: group wrote word2 *)
|
|
|
Texts.WriteString(3, "Compiled bytes:"); (* FIXME *)
|
|
|
@@ -989,29 +989,29 @@ PROCEDURE InitPass1; FORWARD;
|
|
|
skips input). Compiler.scopeSpare3/word2 flag roles TBD (no DEF slots). *)
|
|
|
PROCEDURE WriteOutputFiles;
|
|
|
BEGIN
|
|
|
- WHILE Scanner.curChar # CHR(255) DO (*{0db4-0db9} *)
|
|
|
- Scanner.NextChar; (*{0dbb} *)
|
|
|
- Express.CentralError((Scanner.curChar = CHR(255))
|
|
|
- OR (Scanner.curChar <= CHR(32)), 32); (*{0dbd-0dcb} *)
|
|
|
+ WHILE Scanner.curCh # CHR(255) DO (*{0db4-0db9} *)
|
|
|
+ Scanner.NextCh; (*{0dbb} *)
|
|
|
+ Express.CentralError((Scanner.curCh = CHR(255))
|
|
|
+ OR (Scanner.curCh <= CHR(32)), 32); (*{0dbd-0dcb} *)
|
|
|
END;
|
|
|
- IF 0 IN Scanner.scanOptions THEN (*{0dcf-0dd3} *)
|
|
|
+ IF 0 IN Scanner.scanOpt THEN (*{0dcf-0dd3} *)
|
|
|
Texts.WriteLn(3); (*{0dd5-0dd6} FIXME channel roles TBD *)
|
|
|
Texts.WriteString(3, "End of source reached."); (*{0dd8-0df3} *)
|
|
|
Texts.WriteLn(3);
|
|
|
END;
|
|
|
- Files.Close(Scanner.sourceFile); (*{0df8-0dfb} FIXME proc identity *)
|
|
|
+ Files.Close(Scanner.srcFile); (*{0df8-0dfb} FIXME proc identity *)
|
|
|
Texts.WriteLn(3);
|
|
|
IF Compiler.scopeSpare3 THEN (*{0e00-0e02} FIXME: group read word3; TRUE = .SYM path *)
|
|
|
SymTab.SaveSymbolFile; (*{0e04} *)
|
|
|
Texts.WriteString(3, "Symbol"); (*{0e06-0e10} *)
|
|
|
- Scanner.ChangeFileExtension(ComLine.outName, "SYM", TRUE); (*{0e12-0e1c} FIXME ComLine slot *)
|
|
|
+ Scanner.ChangeEx(ComLine.outName, "SYM", TRUE); (*{0e12-0e1c} FIXME ComLine slot *)
|
|
|
ELSE
|
|
|
WriteMcdHeader; (*{0e21} *)
|
|
|
EmitTypeDesc; (*{0e23} *)
|
|
|
- Scanner.ChangeFileExtension(ComLine.outName, "MCD", TRUE); (*{0e25-0e2f} *)
|
|
|
+ Scanner.ChangeEx(ComLine.outName, "MCD", TRUE); (*{0e25-0e2f} *)
|
|
|
IF NOT Compiler.rangeCheckEnabled THEN (*{0e32-0e35} FIXME: group read word2; polarity TBD *)
|
|
|
Files.SetPos(Scanner.codeFile, LONG(CodeGen.windowBase)); (*{0e37-0e3d} FIXME proc/arg order *)
|
|
|
- Files.WriteBytes(Scanner.codeFile, Scanner.codeBuffer,
|
|
|
+ Files.WriteBytes(Scanner.codeFile, Scanner.codeBuf,
|
|
|
CodeGen.nextEmitPos - CodeGen.windowBase); (*{0e40-0e4a} FIXME proc identity *)
|
|
|
Texts.WriteString(3, "M-code"); (*{0e4d-0e57} *)
|
|
|
END;
|
|
|
@@ -1020,7 +1020,7 @@ BEGIN
|
|
|
Texts.WriteString(3, " file "); (*{0e62-0e6b} *)
|
|
|
Texts.WriteString(3, ComLine.outName); (*{0e6e-0e73} FIXME slot *)
|
|
|
Texts.WriteString(3, " produced."); (*{0e75-0e83} *)
|
|
|
- Files.Close(Scanner.sourceFile); (*{0e85-0e8c} FIXME: finalizer identity TBD *)
|
|
|
+ Files.Close(Scanner.srcFile); (*{0e85-0e8c} FIXME: finalizer identity TBD *)
|
|
|
Texts.WriteLn(3);
|
|
|
END;
|
|
|
END WriteOutputFiles;
|
