lower L7: symbol scoping and chunked VAR/param name lists

Two more whole-session gaps fixed; the compiler-session divergence moved
from AST.AddTxt (line ~6961) to QbeGen.ArrBodyItems (line ~56294).

- Scoping.  Lower's symbol table is now scope-aware: the grammar's
  ScopeEnter/ScopeLeave push the enclosing procedure, NoteVar records
  the owning procedure, and FindSym searches the emitted procedure's
  chain (procSymBase/procSymTop/procParent) innermost-first before
  module-level symbols.  Common names (s, i, k) no longer collide
  across procedures, so HIGH(s) in AST.AddTxt resolves the right
  open-array parameter.  LowerMethods/LowerMethod set emitProc too.

- Chunked VAR lists.  VarDecl appended names with SetChild, silently
  dropping past AST.MaxChild (8); a VAR with >7 names (QbeGen's sav_*)
  lost the tail.  VarDecl now uses AstAppend, and LowerDecls,
  ReenterGlobals and MaterializeGlobals follow the NkBlock chunks.

Suite 204/204; FIXPOINT OK (3,734,147 bytes), session 0 errors.

Remaining: duplicate nested procedure names (e.g. Sep in QbeGen) still
resolve to the last entry, so the second one gets the wrong uid/mangle.

compiler/src/Lower.mod

@@ -40,6 +40,18 @@ VAR
      lookups over thousands of entries), so FindSym/FindProc hash. *)
   symHash  : ARRAY [0 .. HashSize - 1] OF INTEGER;
   procHash : ARRAY [0 .. HashSize - 1] OF INTEGER;
+  (* Scoping: each symbol records the procedure that owns it (-1 =
+     module level); FindSym searches the emitted procedure's chain
+     innermost-first so common names (s, i, k) do not collide across
+     procedures. *)
+  symOwner : ARRAY [0 .. MaxSym - 1] OF INTEGER;
+  procParent : ARRAY [0 .. MaxProc - 1] OF INTEGER;
+  procSymBase : ARRAY [0 .. MaxProc - 1] OF CARDINAL;
+  procSymTop : ARRAY [0 .. MaxProc - 1] OF CARDINAL;
+  scopeStack : ARRAY [0 .. MaxProc - 1] OF INTEGER;
+  scopeTop : CARDINAL;
+  curScopeProc : INTEGER;   (* owner while parsing: enclosing proc *)
+  emitProc : INTEGER;       (* owner while emitting: current proc *)
   withRec  : ARRAY [0 .. 15] OF SymTab.TypeIndex;
   withTop  : CARDINAL;
   curMethCls : SymTab.TypeIndex;   (* class bound by the last obj.Method *)
@@ -124,6 +136,7 @@ PROCEDURE Reset;
   VAR i: CARDINAL;
   BEGIN
     nSyms := 0; nProcs := 0;
+    scopeTop := 0; curScopeProc := -1; emitProc := -1;
     i := 0;
     WHILE i < HashSize DO symHash[i] := 0; procHash[i] := 0; INC(i) END
   END Reset;
@@ -133,6 +146,7 @@ PROCEDURE NoteVar (name: ARRAY OF CHAR; kind: INTEGER; t: SymTab.TypeIndex);
     IF nSyms >= MaxSym THEN RETURN END;
     CopySpan(name, symName, 0, nSyms * 64);
     symKind[nSyms] := kind; symTy[nSyms] := t;
+    symOwner[nSyms] := curScopeProc;
     HashPut(symHash, symName, name, nSyms);
     INC(nSyms)
   END NoteVar;
@@ -146,11 +160,22 @@ PROCEDURE NoteConstVal (val: ARRAY OF CHAR);
   END NoteConstVal;
 
 PROCEDURE ScopeEnter;
+(* Called at a procedure heading, before NoteProc.  Pushes the enclosing
+   procedure as the parent scope. *)
   BEGIN
+    IF scopeTop <= HIGH(scopeStack) THEN
+      scopeStack[scopeTop] := curScopeProc;
+      INC(scopeTop)
+    END
   END ScopeEnter;
 
 PROCEDURE ScopeLeave;
   BEGIN
+    IF curScopeProc >= 0 THEN procSymTop[curScopeProc] := nSyms END;
+    IF scopeTop > 0 THEN
+      DEC(scopeTop);
+      curScopeProc := scopeStack[scopeTop]
+    END
   END ScopeLeave;
 
 PROCEDURE NoteProc (name: ARRAY OF CHAR; uid: CARDINAL;
@@ -161,6 +186,9 @@ PROCEDURE NoteProc (name: ARRAY OF CHAR; uid: CARDINAL;
     procUid[nProcs] := uid; procRes[nProcs] := res;
     procDep[nProcs] := depth; procExt[nProcs] := ext;
     procNpar[nProcs] := 0;
+    procParent[nProcs] := curScopeProc;
+    procSymBase[nProcs] := nSyms;
+    curScopeProc := VAL(INTEGER, nProcs);
     HashPut(procHash, procName, name, nProcs);
     INC(nProcs)
   END NoteProc;
@@ -189,13 +217,65 @@ PROCEDURE NoteParam (name: ARRAY OF CHAR; t: SymTab.TypeIndex; isVar: BOOLEAN);
     procNpar[nProcs - 1] := j + 1
   END NoteParam;
 
+PROCEDURE NameEq (i: CARDINAL; name: ARRAY OF CHAR): BOOLEAN;
+  VAR j: CARDINAL;
+  BEGIN
+    j := 0;
+    WHILE (j < MaxName) AND (name[j] # CHR(0)) DO
+      IF symName[i * 64 + j] # name[j] THEN RETURN FALSE END;
+      INC(j)
+    END;
+    RETURN symName[i * 64 + j] = name[j]
+  END NameEq;
+
+PROCEDURE Visible (i: INTEGER): BOOLEAN;
+(* TRUE when symbol i belongs to the emitted procedure or one of its
+   enclosing procedures (or module level). *)
+  VAR owner: INTEGER;
+  BEGIN
+    owner := emitProc;
+    WHILE owner >= 0 DO
+      IF symOwner[i] = owner THEN RETURN TRUE END;
+      owner := procParent[owner]
+    END;
+    RETURN symOwner[i] = -1
+  END Visible;
+
 PROCEDURE FindSym (name: ARRAY OF CHAR; VAR kind: INTEGER;
                    VAR t: SymTab.TypeIndex): BOOLEAN;
-  VAR i: INTEGER;
+  VAR i: INTEGER; owner: INTEGER;
   BEGIN
+    (* Fast path: the hash's latest entry, when it is visible. *)
     i := HashGet(symHash, symName, name);
-    IF i < 0 THEN RETURN FALSE END;
-    kind := symKind[i]; t := symTy[i]; RETURN TRUE
+    IF (i >= 0) AND Visible(i) THEN
+      kind := symKind[i]; t := symTy[i]; RETURN TRUE
+    END;
+    (* Otherwise walk the emitted procedure's chain innermost-first. *)
+    owner := emitProc;
+    WHILE owner >= 0 DO
+      (* procSymTop is unset for headings that never ScopeLeave (class
+         method declarations); fall back to the whole table then. *)
+      IF procSymTop[owner] > 0 THEN
+        i := VAL(INTEGER, procSymTop[owner]) - 1
+      ELSE i := VAL(INTEGER, nSyms) - 1
+      END;
+      WHILE i >= VAL(INTEGER, procSymBase[owner]) DO
+        IF (symOwner[i] = owner) AND NameEq(VAL(CARDINAL, i), name) THEN
+          kind := symKind[i]; t := symTy[i]; RETURN TRUE
+        END;
+        DEC(i)
+      END;
+      owner := procParent[owner]
+    END;
+    (* Module-level symbols. *)
+    i := VAL(INTEGER, nSyms) - 1;
+    WHILE i >= 0 DO
+      IF (symOwner[i] = -1) AND NameEq(VAL(CARDINAL, i), name) THEN
+        kind := symKind[i]; t := symTy[i]; RETURN TRUE
+      END;
+      DEC(i)
+    END;
+    RETURN FALSE
   END FindSym;
 
 PROCEDURE GetConstVal (name: ARRAY OF CHAR; VAR v: ARRAY OF CHAR): BOOLEAN;
@@ -1069,13 +1149,23 @@ PROCEDURE LowerCall (n: AST.Node; VAR t: SymTab.TypeIndex;
           IF NOT QbeGen.CallArg(qa, "l") THEN END
         END
       ELSE
-        conv := (SymTab.ClassOf(ft) = SymTab.ClReal)
-                AND SymTab.IsIntFamily(at);
-        IF conv THEN
-          QbeGen.ConvIR(qe, qt);
-          IF NOT QbeGen.CallArg(qt, "d") THEN END
+        IF (SymTab.ClassOf(at) = SymTab.ClChar)
+           AND (SymTab.ClassOf(ft) = SymTab.ClArray)
+           AND (SymTab.ClassOf(SymTab.ArrayElem(ft)) = SymTab.ClChar)
+           AND QbeGen.IsImm(qe) THEN
+          (* 1-char string literal passed to ARRAY OF CHAR: pass its
+             static descriptor, not the char code *)
+          QbeGen.DeclCharStr(qe, qa);
+          IF NOT QbeGen.CallArg(qa, "l") THEN END
         ELSE
-          IF NOT QbeGen.CallArg(qe, QbeGen.ArgClass(ft)) THEN END
+          conv := (SymTab.ClassOf(ft) = SymTab.ClReal)
+                  AND SymTab.IsIntFamily(at);
+          IF conv THEN
+            QbeGen.ConvIR(qe, qt);
+            IF NOT QbeGen.CallArg(qt, "d") THEN END
+          ELSE
+            IF NOT QbeGen.CallArg(qe, QbeGen.ArgClass(ft)) THEN END
+          END
         END
       END;
       INC(i)
@@ -1267,6 +1357,7 @@ PROCEDURE LowerMethod (m: AST.Node; ct: SymTab.TypeIndex);
   VAR nm, txt: SymTab.Name; mg, thisQ: QbeGen.QVal;
       uid, depth, np: CARDINAL; res, pt: SymTab.TypeIndex;
       pv, ext: BOOLEAN; j: CARDINAL; saveCls: SymTab.TypeIndex;
+      savedProc: INTEGER;
   BEGIN
     IF (AST.Op(m) # 0) AND (AST.Op(m) # 3) THEN RETURN END;
     Name(AST.Child(m, 0), nm);
@@ -1287,8 +1378,11 @@ PROCEDURE LowerMethod (m: AST.Node; ct: SymTab.TypeIndex);
     curImplCls := ct;
     QbeGen.PushWith(thisQ);
     IF withTop <= HIGH(withRec) THEN withRec[withTop] := ct; INC(withTop) END;
+    savedProc := emitProc;
+    emitProc := FindProc(nm);
     LowerDecls(AST.Child(m, 2));
     LowerStmt(AST.Child(m, 1));
+    emitProc := savedProc;
     IF withTop > 0 THEN DEC(withTop) END;
     curImplCls := saveCls;
     QbeGen.PopWith;
@@ -1908,7 +2002,7 @@ PROCEDURE ReenterGlobals (seq: AST.Node);
 (* Re-registers a nested module's non-exported globals in the enclosing
    (still-open) module scope, so QbeGen.GlobalRef can resolve their
    "<outer>_<name>" symbols after the nested scope has been popped. *)
-  VAR i, j: CARDINAL; c: AST.Node; nm: SymTab.Name;
+  VAR i, j: CARDINAL; c: AST.Node; nm: SymTab.Name; chunk, vn: AST.Node;
   BEGIN
     IF seq = AST.NoNode THEN RETURN END;
     i := 0;
@@ -1917,13 +2011,24 @@ PROCEDURE ReenterGlobals (seq: AST.Node);
       IF i = AST.MaxChild - 1 THEN ReenterGlobals(c)
       ELSIF AST.Kind(c) = AST.NkDeclSeq THEN ReenterGlobals(c)
       ELSIF AST.Kind(c) = AST.NkVarDecl THEN
-        j := 0;
-        WHILE j < AST.NChild(c) DO
-          Name(AST.Child(c, j), nm);
-          IF SymTab.ReenterModGlobal(nm, SymTab.KindVar, curUnitName) THEN
-            SymTab.SetSymType(nm, AST.Ty(c))
+        chunk := c;
+        WHILE chunk # AST.NoNode DO
+          j := 0;
+          WHILE j < AST.NChild(chunk) DO
+            vn := AST.Child(chunk, j);
+            IF AST.Kind(vn) = AST.NkIdent THEN
+              Name(vn, nm);
+              IF SymTab.ReenterModGlobal(nm, SymTab.KindVar, curUnitName) THEN
+                SymTab.SetSymType(nm, AST.Ty(c))
+              END
+            END;
+            INC(j)
           END;
-          INC(j)
+          IF AST.NChild(chunk) > 0 THEN
+            vn := AST.Child(chunk, AST.NChild(chunk) - 1);
+            IF AST.Kind(vn) = AST.NkBlock THEN chunk := vn
+            ELSE chunk := AST.NoNode END
+          ELSE chunk := AST.NoNode END
         END
       END;
       INC(i)
@@ -1933,7 +2038,8 @@ PROCEDURE ReenterGlobals (seq: AST.Node);
 PROCEDURE LowerDecls (seq: AST.Node);
   VAR i, j: CARDINAL; c: AST.Node; nm, txt: SymTab.Name; qv: QbeGen.QVal;
       mg: QbeGen.QVal; uid, depth, np: CARDINAL; res, pt: SymTab.TypeIndex;
-      ext, pv: BOOLEAN; kk: INTEGER; ct: SymTab.TypeIndex;
+      ext, pv: BOOLEAN; kk: INTEGER; ct: SymTab.TypeIndex; savedProc: INTEGER;
+      chunk, vn: AST.Node;
   BEGIN
     IF seq = AST.NoNode THEN RETURN END;
     i := 0;
@@ -1967,11 +2073,24 @@ PROCEDURE LowerDecls (seq: AST.Node);
           QbeGen.EndInit
         END
       ELSIF AST.Kind(c) = AST.NkVarDecl THEN
-        j := 0;
-        WHILE j < AST.NChild(c) DO
-          Name(AST.Child(c, j), nm);
-          QbeGen.DeclVar(nm, AST.Ty(c));
-          INC(j)
+        (* names are a chunked sequence (AstAppend): follow NkBlock
+           continuations so a >MaxChild VAR list is not truncated *)
+        chunk := c;
+        WHILE chunk # AST.NoNode DO
+          j := 0;
+          WHILE j < AST.NChild(chunk) DO
+            vn := AST.Child(chunk, j);
+            IF AST.Kind(vn) = AST.NkIdent THEN
+              Name(vn, nm);
+              QbeGen.DeclVar(nm, AST.Ty(c))
+            END;
+            INC(j)
+          END;
+          IF AST.NChild(chunk) > 0 THEN
+            vn := AST.Child(chunk, AST.NChild(chunk) - 1);
+            IF AST.Kind(vn) = AST.NkBlock THEN chunk := vn
+            ELSE chunk := AST.NoNode END
+          ELSE chunk := AST.NoNode END
         END
       ELSIF AST.Kind(c) = AST.NkConstDecl THEN
         Name(AST.Child(c, 0), nm);
@@ -2000,8 +2119,11 @@ PROCEDURE LowerDecls (seq: AST.Node);
             QbeGen.AbortFunc
           ELSE
             QbeGen.EndFuncHeader;
+            savedProc := emitProc;
+            emitProc := FindProc(nm);
             LowerDecls(AST.Child(c, 2));
             LowerStmt(AST.Child(c, 1));
+            emitProc := savedProc;
             QbeGen.EndFunc(res)
           END
         END
@@ -2013,7 +2135,7 @@ PROCEDURE LowerDecls (seq: AST.Node);
 PROCEDURE MaterializeGlobals (unitName: ARRAY OF CHAR; decls: AST.Node);
 (* Make a unit's module-level VAR/CONST visible in the (global) scope
    Lower runs in at session end, so GlobalRef resolves "<unit>_<name>". *)
-  VAR i, j: CARDINAL; c: AST.Node; nm: SymTab.Name;
+  VAR i, j: CARDINAL; c: AST.Node; nm: SymTab.Name; chunk, vn: AST.Node;
   BEGIN
     IF decls = AST.NoNode THEN RETURN END;
     i := 0;
@@ -2022,13 +2144,22 @@ PROCEDURE MaterializeGlobals (unitName: ARRAY OF CHAR; decls: AST.Node);
       IF i = AST.MaxChild - 1 THEN MaterializeGlobals(unitName, c)
       ELSIF AST.Kind(c) = AST.NkDeclSeq THEN MaterializeGlobals(unitName, c)
       ELSIF (AST.Kind(c) = AST.NkVarDecl) OR (AST.Kind(c) = AST.NkConstDecl) THEN
-        j := 0;
-        WHILE j < AST.NChild(c) DO
-          IF AST.Kind(AST.Child(c, j)) = AST.NkIdent THEN
-            Name(AST.Child(c, j), nm);
-            IF NOT SymTab.Materialize(unitName, nm) THEN END
+        chunk := c;
+        WHILE chunk # AST.NoNode DO
+          j := 0;
+          WHILE j < AST.NChild(chunk) DO
+            vn := AST.Child(chunk, j);
+            IF AST.Kind(vn) = AST.NkIdent THEN
+              Name(vn, nm);
+              IF NOT SymTab.Materialize(unitName, nm) THEN END
+            END;
+            INC(j)
           END;
-          INC(j)
+          IF AST.NChild(chunk) > 0 THEN
+            vn := AST.Child(chunk, AST.NChild(chunk) - 1);
+            IF AST.Kind(vn) = AST.NkBlock THEN chunk := vn
+            ELSE chunk := AST.NoNode END
+          ELSE chunk := AST.NoNode END
         END
       ELSIF (AST.Kind(c) = AST.NkTypeDecl) OR (AST.Kind(c) = AST.NkClassDecl) THEN
         IF AST.NChild(c) >= 1 THEN
@@ -2093,6 +2224,7 @@ PROCEDURE BeginSession (progName: ARRAY OF CHAR);
   BEGIN
     withTop := 0;
     curImplCls := SymTab.InvalidType;
+    scopeTop := 0; curScopeProc := -1; emitProc := -1;
     QbeGen.OpenModule(progName);
     QbeGen.SetNoEmit(TRUE)
   END BeginSession;
@@ -2147,4 +2279,5 @@ PROCEDURE LowerUnit (unit: AST.Node);
   END LowerUnit;
 
 BEGIN
+  scopeTop := 0; curScopeProc := -1; emitProc := -1
 END Lower.

compiler/src/M2.atg

@@ -1061,15 +1061,18 @@ PRODUCTIONS
                                              t: SymTab.TypeIndex;
                                              i: CARDINAL;
                                              cls: INTEGER;
-                                             astNode: AST.Node; .)
+                                             astNode, astTail: AST.Node; .)
     = VarIdents ":"
       Type<t, FALSE> (. astNode := AST.MakeNode(AST.NkVarDecl);
+                                           astTail := astNode;
                                            i := 0;
                                            WHILE i < SymTab.PendCount() DO
                                              SymTab.PendName(i, nm);
                                              Lower.NoteVar(nm, SymTab.KindVar, t);
-                                             AST.SetChild(astNode,
-                                               AST.NChild(astNode),
+                                             (* chunked: a VAR list can
+                                                exceed AST.MaxChild *)
+                                             AstAppend(AST.NkBlock,
+                                               astNode, astTail,
                                                AST.MakeLeaf(AST.NkIdent, nm));
                                              INC(i)
                                            END;

compiler/src/M2.lst

@@ -1079,2797 +1079,2800 @@ Listing:
  1061                                               t: SymTab.TypeIndex;
  1062                                               i: CARDINAL;
  1063                                               cls: INTEGER;
- 1064                                               astNode: AST.Node; .)
+ 1064                                               astNode, astTail: AST.Node; .)
  1065      = VarIdents ":"
  1066        Type<t, FALSE> (. astNode := AST.MakeNode(AST.NkVarDecl);
- 1067                                             i := 0;
- 1068                                             WHILE i < SymTab.PendCount() DO
- 1069                                               SymTab.PendName(i, nm);
- 1070                                               Lower.NoteVar(nm, SymTab.KindVar, t);
- 1071                                               AST.SetChild(astNode,
- 1072                                                 AST.NChild(astNode),
- 1073                                                 AST.MakeLeaf(AST.NkIdent, nm));
- 1074                                               INC(i)
- 1075                                             END;
- 1076                                             AST.SetTy(astNode, t);
- 1077                                             astDecl := astNode;
- 1078                                             cls := SymTab.ClassOf(t);
- 1079                                             IF (t # SymTab.InvalidType)
- 1080   AND NOT SymTab.IsUnresolved(t)
- 1081   AND (cls # SymTab.ClInt)
- 1082   AND (cls # SymTab.ClBool)
- 1083   AND (cls # SymTab.ClChar)
- 1084   AND (cls # SymTab.ClReal)
- 1085   AND (cls # SymTab.ClArray)
- 1086   AND (cls # SymTab.ClSet)
- 1087   AND (cls # SymTab.ClRecord)
- 1088   AND (cls # SymTab.ClPtr)
- 1089   AND (cls # SymTab.ClLong)
- 1090   AND (cls # SymTab.ClProc)
- 1091   AND (cls # SymTab.ClUChar)
- 1092   AND (cls # SymTab.ClUStr)
- 1093   AND (cls # SymTab.ClEnum)
- 1094   AND (cls # SymTab.ClClass) THEN
- 1095                                               SemError(230) END;
- 1096                                             IF QbeGen.LocFull() THEN
- 1097                                               SemError(233) END;
- 1098                                             i := 0;
- 1099                                             IF SymTab.IsUnresolved(t)
- 1100                                                AND NOT SymTab.InProc() THEN
- 1101                                               (* a forward-typed global:
- 1102                                                  defer emission until the
- 1103                                                  TYPE block completes *)
- 1104                                               WHILE i < SymTab.PendCount() DO
- 1105                                                 SymTab.PendName(i, nm);
- 1106                                                 IF nPendVar <=
- 1107                                                    HIGH(pendVarName) THEN
- 1108                                                   pendVarName[nPendVar] := nm;
- 1109                                                   pendVarT[nPendVar] := t;
- 1110                                                   INC(nPendVar)
- 1111                                                 END;
- 1112                                                 INC(i)
- 1113                                               END
- 1114                                             ELSE
- 1115                                               WHILE i < SymTab.PendCount() DO
- 1116                                                 SymTab.PendName(i, nm);
- 1117                                                 QbeGen.DeclVar(nm, t);
- 1118                                                 INC(i)
- 1119                                               END
- 1120                                             END;
- 1121                                             (* a plain VAR list, not a
- 1122                                                heading: the signature
- 1123                                                result is discarded *)
- 1124                                             IF NOT SymTab.FixPending(t) THEN
- 1125                                             END; .) .
- 1126    VarIdents                             (. VAR n: SymTab.Name; .)
- 1127      = GetIdent<n>                       (. IF NOT SymTab.EnterPending(n,
- 1128                                               SymTab.KindVar) THEN
- 1129                                               SemError(200) END; .)
- 1130        { ","
- 1131          GetIdent<n>                     (. IF NOT SymTab.EnterPending(n,
- 1132                                               SymTab.KindVar) THEN
- 1133                                               SemError(200) END; .) } .
- 1134    ParIdents<isV: BOOLEAN>               (. VAR n: SymTab.Name; .)
- 1135      = GetIdent<n>                       (. IF NOT SymTab.EnterParam(n, isV) THEN
- 1136                                               SemError(200) END; .)
- 1137        { "," GetIdent<n>                 (. IF NOT SymTab.EnterParam(n, isV) THEN
- 1138                                               SemError(200) END; .) } .
- 1139    (* Procedure headings enter scopes/params/result and buffer the
- 1140       QBE header; bodies lower to functions (4.1, module level only).
- 1141       FORWARD marks; the body heading re-enters (signature compare
- 1142       deferred). Nested procedures parse + check, lowering = 4.2. *)
- 1143    ProcHeading<VAR pn: SymTab.Name; methCls: SymTab.TypeIndex>
- 1144                                          (. VAR t: SymTab.TypeIndex;
- 1145                                               mg: QbeGen.QVal; .)
- 1146      = "PROCEDURE"
- 1147        GetIdent<pn>                      (. IF methCls #
- 1148                                                SymTab.InvalidType THEN
- 1149                                             (* a method: resume the
- 1150                                                declared symbol (reuse
- 1151                                                its uid) *)
- 1152                                             IF NOT SymTab.ResumeMethod(
- 1153                                                  methCls, pn) THEN
- 1154                                               SemError(200) END
- 1155                                             ELSIF NOT SymTab.EnterProc(pn) THEN
- 1156                                             IF NOT SymTab.ReenterProc(pn) THEN
- 1157                                               IF NOT SymTab.ResumeProc(pn) THEN
- 1158                                                 SemError(200) END
- 1159                                               END
- 1160                                             END;
- 1161                                             Lower.ScopeEnter;
- 1162                                             Lower.NoteProc(pn,
- 1163                                               SymTab.ProcUid(pn),
- 1164                                               SymTab.InvalidType,
- 1165                                               SymTab.ProcDepthOf(pn),
- 1166                                               FALSE);
- 1167                                             IF methCls #
- 1168                                                SymTab.InvalidType THEN
- 1169                                               QbeGen.Mangled(pn,
- 1170                                                 SymTab.MethUid(), mg)
- 1171                                             ELSE
+ 1067                                             astTail := astNode;
+ 1068                                             i := 0;
+ 1069                                             WHILE i < SymTab.PendCount() DO
+ 1070                                               SymTab.PendName(i, nm);
+ 1071                                               Lower.NoteVar(nm, SymTab.KindVar, t);
+ 1072                                               (* chunked: a VAR list can
+ 1073                                                  exceed AST.MaxChild *)
+ 1074                                               AstAppend(AST.NkBlock,
+ 1075                                                 astNode, astTail,
+ 1076                                                 AST.MakeLeaf(AST.NkIdent, nm));
+ 1077                                               INC(i)
+ 1078                                             END;
+ 1079                                             AST.SetTy(astNode, t);
+ 1080                                             astDecl := astNode;
+ 1081                                             cls := SymTab.ClassOf(t);
+ 1082                                             IF (t # SymTab.InvalidType)
+ 1083   AND NOT SymTab.IsUnresolved(t)
+ 1084   AND (cls # SymTab.ClInt)
+ 1085   AND (cls # SymTab.ClBool)
+ 1086   AND (cls # SymTab.ClChar)
+ 1087   AND (cls # SymTab.ClReal)
+ 1088   AND (cls # SymTab.ClArray)
+ 1089   AND (cls # SymTab.ClSet)
+ 1090   AND (cls # SymTab.ClRecord)
+ 1091   AND (cls # SymTab.ClPtr)
+ 1092   AND (cls # SymTab.ClLong)
+ 1093   AND (cls # SymTab.ClProc)
+ 1094   AND (cls # SymTab.ClUChar)
+ 1095   AND (cls # SymTab.ClUStr)
+ 1096   AND (cls # SymTab.ClEnum)
+ 1097   AND (cls # SymTab.ClClass) THEN
+ 1098                                               SemError(230) END;
+ 1099                                             IF QbeGen.LocFull() THEN
+ 1100                                               SemError(233) END;
+ 1101                                             i := 0;
+ 1102                                             IF SymTab.IsUnresolved(t)
+ 1103                                                AND NOT SymTab.InProc() THEN
+ 1104                                               (* a forward-typed global:
+ 1105                                                  defer emission until the
+ 1106                                                  TYPE block completes *)
+ 1107                                               WHILE i < SymTab.PendCount() DO
+ 1108                                                 SymTab.PendName(i, nm);
+ 1109                                                 IF nPendVar <=
+ 1110                                                    HIGH(pendVarName) THEN
+ 1111                                                   pendVarName[nPendVar] := nm;
+ 1112                                                   pendVarT[nPendVar] := t;
+ 1113                                                   INC(nPendVar)
+ 1114                                                 END;
+ 1115                                                 INC(i)
+ 1116                                               END
+ 1117                                             ELSE
+ 1118                                               WHILE i < SymTab.PendCount() DO
+ 1119                                                 SymTab.PendName(i, nm);
+ 1120                                                 QbeGen.DeclVar(nm, t);
+ 1121                                                 INC(i)
+ 1122                                               END
+ 1123                                             END;
+ 1124                                             (* a plain VAR list, not a
+ 1125                                                heading: the signature
+ 1126                                                result is discarded *)
+ 1127                                             IF NOT SymTab.FixPending(t) THEN
+ 1128                                             END; .) .
+ 1129    VarIdents                             (. VAR n: SymTab.Name; .)
+ 1130      = GetIdent<n>                       (. IF NOT SymTab.EnterPending(n,
+ 1131                                               SymTab.KindVar) THEN
+ 1132                                               SemError(200) END; .)
+ 1133        { ","
+ 1134          GetIdent<n>                     (. IF NOT SymTab.EnterPending(n,
+ 1135                                               SymTab.KindVar) THEN
+ 1136                                               SemError(200) END; .) } .
+ 1137    ParIdents<isV: BOOLEAN>               (. VAR n: SymTab.Name; .)
+ 1138      = GetIdent<n>                       (. IF NOT SymTab.EnterParam(n, isV) THEN
+ 1139                                               SemError(200) END; .)
+ 1140        { "," GetIdent<n>                 (. IF NOT SymTab.EnterParam(n, isV) THEN
+ 1141                                               SemError(200) END; .) } .
+ 1142    (* Procedure headings enter scopes/params/result and buffer the
+ 1143       QBE header; bodies lower to functions (4.1, module level only).
+ 1144       FORWARD marks; the body heading re-enters (signature compare
+ 1145       deferred). Nested procedures parse + check, lowering = 4.2. *)
+ 1146    ProcHeading<VAR pn: SymTab.Name; methCls: SymTab.TypeIndex>
+ 1147                                          (. VAR t: SymTab.TypeIndex;
+ 1148                                               mg: QbeGen.QVal; .)
+ 1149      = "PROCEDURE"
+ 1150        GetIdent<pn>                      (. IF methCls #
+ 1151                                                SymTab.InvalidType THEN
+ 1152                                             (* a method: resume the
+ 1153                                                declared symbol (reuse
+ 1154                                                its uid) *)
+ 1155                                             IF NOT SymTab.ResumeMethod(
+ 1156                                                  methCls, pn) THEN
+ 1157                                               SemError(200) END
+ 1158                                             ELSIF NOT SymTab.EnterProc(pn) THEN
+ 1159                                             IF NOT SymTab.ReenterProc(pn) THEN
+ 1160                                               IF NOT SymTab.ResumeProc(pn) THEN
+ 1161                                                 SemError(200) END
+ 1162                                               END
+ 1163                                             END;
+ 1164                                             Lower.ScopeEnter;
+ 1165                                             Lower.NoteProc(pn,
+ 1166                                               SymTab.ProcUid(pn),
+ 1167                                               SymTab.InvalidType,
+ 1168                                               SymTab.ProcDepthOf(pn),
+ 1169                                               FALSE);
+ 1170                                             IF methCls #
+ 1171                                                SymTab.InvalidType THEN
  1172                                               QbeGen.Mangled(pn,
- 1173                                                 SymTab.ProcUid(pn), mg)
- 1174                                             END;
- 1175                                             QbeGen.BeginFunc(mg);
- 1176                                             IF methCls #
- 1177                                                SymTab.InvalidType THEN
- 1178                                               (* hidden THIS receiver:
- 1179                                                  a VAR param of the
- 1180                                                  class type, pushed as
- 1181                                                  the WITH base *)
- 1182                                               IF NOT SymTab.EnterThisParam(
- 1183                                                    methCls) THEN
- 1184                                                 SemError(200) END;
- 1185                                               IF NOT QbeGen.FuncParam(
- 1186                                                    "THIS", TRUE,
- 1187                                                    methCls) THEN
- 1188                                                 SemError(233) END
- 1189                                             END; .)
- 1190        [ FormalParams ]
- 1191        [ ":" TypeIdent<t>                (. IF NOT SymTab.SetProcRes(t) THEN
- 1192                                               SemError(235) END;
- 1193                                             Lower.SetProcRes(t);
- 1194                                             QbeGen.SetFuncRes(t);
- 1195                                             IF (t #
- 1196                                                SymTab.InvalidType)
- 1197   AND ((SymTab.ClassOf(t)
- 1198                                                   = SymTab.ClArray)
- 1199                                                OR (SymTab.ClassOf(t)
- 1200                                                   = SymTab.ClRecord)
- 1201                                                OR (SymTab.ClassOf(t)
- 1202                                                   = SymTab.ClSet)
- 1203                                                OR (SymTab.ClassOf(t)
- 1204                                                   = SymTab.ClClass)) THEN
- 1205                                               SemError(230) END; .) ] .
- 1206    FormalParams
- 1207      = "(" [ ParamSection { ";" ParamSection } ] ")" .
- 1208    ParamSection                          (. VAR t: SymTab.TypeIndex;
- 1209                                               nm: SymTab.Name;
- 1210                                               i: CARDINAL;
- 1211                                               isV: BOOLEAN; .)
- 1212      =                                   (. isV := FALSE; .)
- 1213        [ "VAR"                           (. isV := TRUE; .) ]
- 1214        ParIdents<isV> ":" Type<t, TRUE>  (. i := 0;
- 1215                                             WHILE i < SymTab.PendCount() DO
- 1216                                               SymTab.PendName(i, nm);
- 1217                                               Lower.NoteParam(nm, t, isV);
- 1218                                               Lower.NoteVar(nm, SymTab.KindParam, t);
- 1219                                               (* value open arrays are
- 1220                                                  passed as descriptor
- 1221                                                  addresses (no copy):
- 1222                                                  same representation as
- 1223                                                  VAR formals *)
- 1224                                               IF NOT QbeGen.FuncParam(nm,
- 1225                                                    isV
- 1226                                                    OR SymTab.IsOpenArray(t),
- 1227                                                    t) THEN
- 1228                                                 SemError(233) END;
- 1229                                               INC(i)
- 1230                                             END;
- 1231                                             IF NOT SymTab.FixPending(t) THEN
- 1232                                               SemError(235) END; .) .
- 1233    (* Nested procedures lower like top-level ones (4.2): the
- 1234       static link gives them their parent's frame. Methods keep
- 1235       parse-now/230-later. *)
- 1236    ProcDecl                              (. VAR pn: SymTab.Name;
- 1237                                               astNode: AST.Node; .)
- 1238      = ProcHeading<pn, SymTab.InvalidType> ";"
- 1239                                          (. astNode := AST.MakeNode(AST.NkProcDecl);
- 1240                                             AST.SetOp(astNode, 0);
- 1241                                             AST.SetChild(astNode, 0,
- 1242                                               AST.MakeLeaf(AST.NkIdent, pn)); .)
- 1243        ( "FORWARD"                       (. AST.SetOp(astNode, 1);
- 1244                                             astDecl := astNode;
- 1245                                             Lower.ScopeLeave;
- 1246                                             SymTab.MarkFwd;
- 1247                                             SymTab.CloseProc;
- 1248                                             QbeGen.AbortFunc; .)
- 1249        | "EXTERNAL"                      (. AST.SetOp(astNode, 2);
- 1250                                             astDecl := astNode;
- 1251                                             Lower.MarkProcExternal;
- 1252                                             Lower.ScopeLeave;
- 1253                                             SymTab.MarkExternal("");
- 1254                                             SymTab.CloseProc;
- 1255                                             QbeGen.AbortFunc; .)
- 1256        |                                 (. QbeGen.EndFuncHeader; .)
- 1257          Block<pn>                       (. AST.SetChild(astNode, 1, astStmt);
- 1258                                             AST.SetChild(astNode, 2, astBlkDecls);
- 1259                                             astDecl := astNode;
- 1260                                             Lower.ScopeLeave;
- 1261                                             SymTab.CloseProc;
- 1262                                             QbeGen.EndFunc(
- 1263                                               SymTab.ProcRes(pn)); .) ) .
- 1264    Block<pn: SymTab.Name>                (. VAR m2: SymTab.Name; .)
- 1265      = DeclSeq                           (. astBlkDecls := astDecl;
- 1266                                             astStmt := AST.NoNode; .)
- 1267        [ "BEGIN"
- 1268          [ StatSeq ] ]
- 1269        "END"
- 1270        GetIdent<m2>                      (. IF NOT SymTab.Equal(pn, m2) THEN
- 1271                                               SemError(202) END; .) .
- 1272    StatSeq                               (. VAR astSeq, astTail: AST.Node; .)
- 1273      =                                   (. astSeq := AST.NoNode;
- 1274                                             astTail := AST.NoNode; .)
- 1275        Statement                         (. AstAppend(AST.NkBlock,
- 1276                                               astSeq, astTail, astStmt); .)
- 1277        { ";" [ Statement                 (. AstAppend(AST.NkBlock,
- 1278                                               astSeq, astTail, astStmt); .) ] }
- 1279                                          (. astStmt := astSeq; .) .
- 1280    (* Trailing/empty statements (`a; ; b`, Coco/R's generated `;;`)
- 1281       are accepted: the statement after ';' is optional. *)
- 1282    Statement                             (. VAR lx: QbeGen.QVal; .)
- 1283      = (. astStmt := AST.NoNode; .)
- 1284        ( AssOrCall
- 1285      | IfStat
- 1286      | WhileStat
- 1287      | RepeatStat
- 1288      | LoopStat
- 1289      | ForStat
- 1290      | CaseStat
- 1291      | WithStat
- 1292      | ReturnStat
- 1293      | HaltStat
- 1294      | NewStat
- 1295      | DisposeStat
- 1296      | IncDecStat
- 1297      | InclExclStat
- 1298      | "EXIT"                            (. IF QbeGen.TopLoop(lx) THEN
- 1299                                               QbeGen.Jmp(lx)
- 1300                                             ELSE SemError(230) END;
- 1301                                             astStmt := AST.MakeNode(AST.NkExit); .) ) .
- 1302    (* INCL(set, elem) / EXCL(set, elem): PIM set-element builtins. *)
- 1303    InclExclStat                          (. VAR at, et2: SymTab.TypeIndex;
- 1304                                               dk: INTEGER;
- 1305                                               qd, qe: QbeGen.QVal;
- 1306                                               qn: SymTab.Name;
- 1307                                               sfx, isInc: BOOLEAN;
- 1308                                               astNode, astD: AST.Node; .)
- 1309      = ( "INCL"                          (. isInc := TRUE; .)
- 1310        | "EXCL"                          (. isInc := FALSE; .) )
- 1311        "(" Design<at, dk, qd, qn, sfx> (. astD := astCur; .) ","
- 1312        Expr<et2, qe> ")"
- 1313                                          (. astNode := AST.MakeNode(AST.NkCall);
- 1314                                             IF isInc THEN
- 1315                                               AST.SetChild(astNode, 0,
- 1316                                                 AST.MakeLeaf(AST.NkIdent, "INCL"))
- 1317                                             ELSE AST.SetChild(astNode, 0,
- 1318                                                 AST.MakeLeaf(AST.NkIdent, "EXCL"))
- 1319                                             END;
- 1320                                             IF astD # AST.NoNode THEN
- 1321                                               AST.SetChild(astNode, 1, astD) END;
- 1322                                             IF astCur # AST.NoNode THEN
- 1323                                               AST.SetChild(astNode, 2, astCur) END;
- 1324                                             astStmt := astNode; .)
- 1325                                          (. IF at = SymTab.InvalidType THEN
- 1326                                             ELSIF SymTab.ClassOf(at) #
- 1327                                                   SymTab.ClSet THEN
- 1328                                               SemError(222)
- 1329                                             ELSE
- 1330                                               IF isInc THEN
- 1331                                                 QbeGen.SetBit(qd, qe,
- 1332                                                   SymTab.SetBaseLo(at),
- 1333                                                   SymTab.SetCount(at))
- 1334                                               ELSE
- 1335                                                 QbeGen.SetClearBit(qd, qe,
- 1336                                                   SymTab.SetBaseLo(at),
- 1337                                                   SymTab.SetCount(at))
- 1338                                               END
- 1339                                             END; .) .
- 1340    (* INC(v [,step]) / DEC(v [,step]) as builtin statements over an
- 1341       integer designator. *)
- 1342    IncDecStat                            (. VAR dt, et2: SymTab.TypeIndex;
- 1343                                               dk: INTEGER;
- 1344                                               qd, qv, qn2, qstep:
- 1345                                                 QbeGen.QVal;
- 1346                                               qn: SymTab.Name;
- 1347                                               sfx, isInc: BOOLEAN;
- 1348                                               astNode, astD, astStep:
- 1349                                                 AST.Node; .)
- 1350      =                                   (. isInc := TRUE; .)
- 1351        ( "INC"                           (. isInc := TRUE; .)
- 1352        | "DEC"                           (. isInc := FALSE; .) )
- 1353        "("                               (. QbeGen.CopyOp("1", qstep); astStep := AST.NoNode; .)
- 1354        Design<dt, dk, qd, qn, sfx> (. astD := astCur; .)
- 1355        [ "," Expr<et2, qstep> (. astStep := astCur; .) ]
- 1356        ")"                               (. astNode := AST.MakeNode(AST.NkCall);
- 1357                                             IF isInc THEN
- 1358                                               AST.SetChild(astNode, 0,
- 1359                                                 AST.MakeLeaf(AST.NkIdent, "INC"))
- 1360                                             ELSE AST.SetChild(astNode, 0,
- 1361                                                 AST.MakeLeaf(AST.NkIdent, "DEC"))
- 1362                                             END;
- 1363                                             IF astD # AST.NoNode THEN
- 1364                                               AST.SetChild(astNode, 1, astD) END;
- 1365                                             IF astStep # AST.NoNode THEN
- 1366                                               AST.SetChild(astNode, 2, astStep) END;
- 1367                                             astStmt := astNode; .)                               (. IF dt = SymTab.InvalidType THEN
- 1368                                             ELSIF (dk # SymTab.KindVar)
- 1369   AND (dk # SymTab.KindParam)
- 1370   AND (dk # SymTab.KindField) THEN
- 1371                                               SemError(210)
- 1372                                             ELSIF NOT SymTab.IsIntFamily(dt) THEN
- 1373                                               SemError(211)
- 1374                                             ELSE
- 1375                                               IF sfx
- 1376                                                  OR (dk = SymTab.KindField) THEN
- 1377                                                 QbeGen.ElemLoad(qd, dt, qv)
- 1378                                               ELSE QbeGen.LoadVar(qn,
- 1379                                                 FALSE, qv)
- 1380                                               END;
- 1381                                               QbeGen.NewTemp(qn2);
- 1382                                               IF isInc THEN
- 1383                                                 QbeGen.Op3("add", qn2, qv,
- 1384                                                   qstep, FALSE)
- 1385                                               ELSE QbeGen.Op3("sub", qn2, qv,
- 1386                                                   qstep, FALSE)
- 1387                                               END;
- 1388                                               IF sfx
- 1389                                                  OR (dk = SymTab.KindField) THEN
- 1390                                                 QbeGen.ElemStore(qd, qn2,
- 1391                                                   dt)
- 1392                                               ELSE QbeGen.StoreVar(qn,
- 1393                                                 qn2, FALSE)
- 1394                                               END
- 1395                                             END; .) .
- 1396    (* NEW/DISPOSE as builtin statements (no call syntax until step 4).
- 1397       Targets are pointer designators; DISPOSE nils afterwards (safer
- 1398       than Wirth-undefined; documented). DISPOSE is shallow. *)
- 1399    NewStat                               (. VAR dt: SymTab.TypeIndex;
- 1400                                               dk: INTEGER;
- 1401                                               qd, qm: QbeGen.QVal;
- 1402                                               qn: SymTab.Name;
- 1403                                               sfx: BOOLEAN;
- 1404                                               bt: SymTab.TypeIndex;
- 1405                                               astNode, astD: AST.Node; .)
- 1406      = "NEW" "(" Design<dt, dk, qd, qn, sfx> (. astD := astCur; .) ")"
- 1407                                          (. astNode := AST.MakeNode(AST.NkCall);
- 1408                                             AST.SetChild(astNode, 0,
- 1409                                               AST.MakeLeaf(AST.NkIdent, "NEW"));
- 1410                                             IF astD # AST.NoNode THEN
- 1411                                               AST.SetChild(astNode, 1, astD) END;
- 1412                                             astStmt := astNode; .)
- 1413                                          (. IF dt = SymTab.InvalidType THEN
- 1414                                             ELSIF (dk # SymTab.KindVar)
- 1415   AND (dk # SymTab.KindParam)
- 1416   AND (dk # SymTab.KindField) THEN
- 1417                                               SemError(210)
- 1418                                             ELSIF SymTab.ClassOf(dt) #
- 1419                                                   SymTab.ClPtr THEN
- 1420                                               SemError(219)
- 1421                                             ELSE bt := SymTab.PtrBase(dt);
- 1422                                               IF bt #
- 1423                                                  SymTab.InvalidType THEN
- 1424                                                 QbeGen.NewHeap(bt, qm);
- 1425                                                 QbeGen.InitHeap(qm, bt);
- 1426                                                 IF sfx
- 1427                                                    OR (dk =
- 1428                                                       SymTab.KindField) THEN
- 1429                                                   QbeGen.ElemStore(qd, qm,
- 1430                                                     dt)
- 1431                                                 ELSE QbeGen.StorePtr(qn,
- 1432                                                   qm)
- 1433                                                 END
- 1434                                               END
- 1435                                             END; .) .
- 1436    DisposeStat                           (. VAR dt: SymTab.TypeIndex;
- 1437                                               dk: INTEGER;
- 1438                                               qd, qv: QbeGen.QVal;
- 1439                                               qn: SymTab.Name;
- 1440                                               sfx: BOOLEAN;
- 1441                                               astNode, astD: AST.Node; .)
- 1442      = "DISPOSE" "(" Design<dt, dk, qd, qn, sfx> (. astD := astCur; .) ")"
- 1443                                          (. astNode := AST.MakeNode(AST.NkCall);
- 1444                                             AST.SetChild(astNode, 0,
- 1445                                               AST.MakeLeaf(AST.NkIdent, "DISPOSE"));
- 1446                                             IF astD # AST.NoNode THEN
- 1447                                               AST.SetChild(astNode, 1, astD) END;
- 1448                                             astStmt := astNode; .)
- 1449                                          (. IF dt = SymTab.InvalidType THEN
- 1450                                             ELSIF (dk # SymTab.KindVar)
- 1451   AND (dk # SymTab.KindParam)
- 1452   AND (dk # SymTab.KindField) THEN
- 1453                                               SemError(210)
- 1454                                             ELSIF SymTab.ClassOf(dt) #
- 1455                                                   SymTab.ClPtr THEN
- 1456                                               SemError(219)
- 1457                                             ELSE
- 1458                                               IF sfx
- 1459                                                  OR (dk =
- 1460                                                     SymTab.KindField) THEN
- 1461                                                 QbeGen.ElemLoad(qd, dt,
- 1462                                                   qv)
- 1463                                               ELSE QbeGen.LoadPtr(qn, qv)
- 1464                                               END;
- 1465                                               QbeGen.FreeHeap(qv);
- 1466                                               IF sfx
- 1467                                                  OR (dk =
- 1468                                                     SymTab.KindField) THEN
- 1469                                                 QbeGen.ElemStore(qd, "0",
- 1470                                                   dt)
- 1471                                               ELSE QbeGen.StorePtr(qn,
- 1472                                                 "0")
- 1473                                               END
- 1474                                             END; .) .
- 1475    (* WITH pushes each record's fields (inner wins) plus its base
- 1476       address; field designators resolve through both stacks. *)
- 1477    WithStat                              (. VAR nW: CARDINAL;
- 1478                                               astNode: AST.Node; .)
- 1479      = "WITH"                            (. nW := 0;
- 1480                                             astNode := AST.MakeNode(AST.NkWith); .)
- 1481        WithItem<nW, astNode> { "," WithItem<nW, astNode> }
- 1482        "DO"                              (. astStmt := AST.NoNode; .)
- 1483        [ StatSeq ] "END"                 (. AST.SetChild(astNode,
- 1484                                             AST.NChild(astNode), astStmt);
- 1485                                             astStmt := astNode;
- 1486                                             WHILE nW > 0 DO
- 1487                                               SymTab.PopScope;
- 1488                                               QbeGen.PopWith;
- 1489                                               DEC(nW)
- 1490                                             END; .) .
- 1491    WithItem<VAR nW: CARDINAL; wnode: AST.Node>
- 1492                                          (. VAR dt: SymTab.TypeIndex;
- 1493                                               dk: INTEGER;
- 1494                                               qd, qe: QbeGen.QVal;
- 1495                                               qn: SymTab.Name;
- 1496                                               sfx: BOOLEAN; .)
- 1497      = Design<dt, dk, qd, qn, sfx>
- 1498                                          (. IF astCur # AST.NoNode THEN
- 1499                                               AST.SetChild(wnode,
- 1500                                                 AST.NChild(wnode), astCur) END;
- 1501                                             IF dt = SymTab.InvalidType THEN
- 1502                                             ELSIF (SymTab.ClassOf(dt) #
- 1503                                                    SymTab.ClRecord)
- 1504   AND (SymTab.ClassOf(dt) #
- 1505                                                   SymTab.ClClass) THEN
- 1506                                               SemError(215)
- 1507                                             ELSIF SymTab.PushRecord(dt) THEN
- 1508                                               QbeGen.PushWith(qd);
- 1509                                               INC(nW)
- 1510                                             END; .) .
- 1511    (* Assignment or procedure-statement call (4.1, module level).
- 1512       Bare `P;` is a syntax error; function-as-statement is 233. *)
- 1513    AssOrCall                             (. VAR dt, et: SymTab.TypeIndex;
- 1514                                               dk: INTEGER;
- 1515                                               qd, qe, qt, ql: QbeGen.QVal;
- 1516                                               qn: SymTab.Name;
- 1517                                               ct2, res0: SymTab.TypeIndex;
- 1518                                               q2, mg0: QbeGen.QVal;
- 1519                                               isR, conv, wconv: BOOLEAN;
- 1520                                               called, sfx: BOOLEAN;
- 1521                                               astLhs: AST.Node; .)
- 1522      = Design<dt, dk, qd, qn, sfx>
- 1523        (. astLhs := astCur; astNArgs := 0; .)
- 1524        ( ":="
- 1525          Expr<et, qe>                    (. astStmt := AST.MakeBin(
- 1526                                               AST.NkAssign, 0, astLhs, astCur);
- 1527                                             IF (dt # SymTab.InvalidType)
- 1528   AND (dk # SymTab.KindVar)
- 1529   AND (dk # SymTab.KindParam)
- 1530   AND (dk # SymTab.KindField) THEN
- 1531                                             SemError(210)
- 1532                                           ELSIF NOT SymTab.Assignable(et,
- 1533                                                    dt) THEN
+ 1173                                                 SymTab.MethUid(), mg)
+ 1174                                             ELSE
+ 1175                                               QbeGen.Mangled(pn,
+ 1176                                                 SymTab.ProcUid(pn), mg)
+ 1177                                             END;
+ 1178                                             QbeGen.BeginFunc(mg);
+ 1179                                             IF methCls #
+ 1180                                                SymTab.InvalidType THEN
+ 1181                                               (* hidden THIS receiver:
+ 1182                                                  a VAR param of the
+ 1183                                                  class type, pushed as
+ 1184                                                  the WITH base *)
+ 1185                                               IF NOT SymTab.EnterThisParam(
+ 1186                                                    methCls) THEN
+ 1187                                                 SemError(200) END;
+ 1188                                               IF NOT QbeGen.FuncParam(
+ 1189                                                    "THIS", TRUE,
+ 1190                                                    methCls) THEN
+ 1191                                                 SemError(233) END
+ 1192                                             END; .)
+ 1193        [ FormalParams ]
+ 1194        [ ":" TypeIdent<t>                (. IF NOT SymTab.SetProcRes(t) THEN
+ 1195                                               SemError(235) END;
+ 1196                                             Lower.SetProcRes(t);
+ 1197                                             QbeGen.SetFuncRes(t);
+ 1198                                             IF (t #
+ 1199                                                SymTab.InvalidType)
+ 1200   AND ((SymTab.ClassOf(t)
+ 1201                                                   = SymTab.ClArray)
+ 1202                                                OR (SymTab.ClassOf(t)
+ 1203                                                   = SymTab.ClRecord)
+ 1204                                                OR (SymTab.ClassOf(t)
+ 1205                                                   = SymTab.ClSet)
+ 1206                                                OR (SymTab.ClassOf(t)
+ 1207                                                   = SymTab.ClClass)) THEN
+ 1208                                               SemError(230) END; .) ] .
+ 1209    FormalParams
+ 1210      = "(" [ ParamSection { ";" ParamSection } ] ")" .
+ 1211    ParamSection                          (. VAR t: SymTab.TypeIndex;
+ 1212                                               nm: SymTab.Name;
+ 1213                                               i: CARDINAL;
+ 1214                                               isV: BOOLEAN; .)
+ 1215      =                                   (. isV := FALSE; .)
+ 1216        [ "VAR"                           (. isV := TRUE; .) ]
+ 1217        ParIdents<isV> ":" Type<t, TRUE>  (. i := 0;
+ 1218                                             WHILE i < SymTab.PendCount() DO
+ 1219                                               SymTab.PendName(i, nm);
+ 1220                                               Lower.NoteParam(nm, t, isV);
+ 1221                                               Lower.NoteVar(nm, SymTab.KindParam, t);
+ 1222                                               (* value open arrays are
+ 1223                                                  passed as descriptor
+ 1224                                                  addresses (no copy):
+ 1225                                                  same representation as
+ 1226                                                  VAR formals *)
+ 1227                                               IF NOT QbeGen.FuncParam(nm,
+ 1228                                                    isV
+ 1229                                                    OR SymTab.IsOpenArray(t),
+ 1230                                                    t) THEN
+ 1231                                                 SemError(233) END;
+ 1232                                               INC(i)
+ 1233                                             END;
+ 1234                                             IF NOT SymTab.FixPending(t) THEN
+ 1235                                               SemError(235) END; .) .
+ 1236    (* Nested procedures lower like top-level ones (4.2): the
+ 1237       static link gives them their parent's frame. Methods keep
+ 1238       parse-now/230-later. *)
+ 1239    ProcDecl                              (. VAR pn: SymTab.Name;
+ 1240                                               astNode: AST.Node; .)
+ 1241      = ProcHeading<pn, SymTab.InvalidType> ";"
+ 1242                                          (. astNode := AST.MakeNode(AST.NkProcDecl);
+ 1243                                             AST.SetOp(astNode, 0);
+ 1244                                             AST.SetChild(astNode, 0,
+ 1245                                               AST.MakeLeaf(AST.NkIdent, pn)); .)
+ 1246        ( "FORWARD"                       (. AST.SetOp(astNode, 1);
+ 1247                                             astDecl := astNode;
+ 1248                                             Lower.ScopeLeave;
+ 1249                                             SymTab.MarkFwd;
+ 1250                                             SymTab.CloseProc;
+ 1251                                             QbeGen.AbortFunc; .)
+ 1252        | "EXTERNAL"                      (. AST.SetOp(astNode, 2);
+ 1253                                             astDecl := astNode;
+ 1254                                             Lower.MarkProcExternal;
+ 1255                                             Lower.ScopeLeave;
+ 1256                                             SymTab.MarkExternal("");
+ 1257                                             SymTab.CloseProc;
+ 1258                                             QbeGen.AbortFunc; .)
+ 1259        |                                 (. QbeGen.EndFuncHeader; .)
+ 1260          Block<pn>                       (. AST.SetChild(astNode, 1, astStmt);
+ 1261                                             AST.SetChild(astNode, 2, astBlkDecls);
+ 1262                                             astDecl := astNode;
+ 1263                                             Lower.ScopeLeave;
+ 1264                                             SymTab.CloseProc;
+ 1265                                             QbeGen.EndFunc(
+ 1266                                               SymTab.ProcRes(pn)); .) ) .
+ 1267    Block<pn: SymTab.Name>                (. VAR m2: SymTab.Name; .)
+ 1268      = DeclSeq                           (. astBlkDecls := astDecl;
+ 1269                                             astStmt := AST.NoNode; .)
+ 1270        [ "BEGIN"
+ 1271          [ StatSeq ] ]
+ 1272        "END"
+ 1273        GetIdent<m2>                      (. IF NOT SymTab.Equal(pn, m2) THEN
+ 1274                                               SemError(202) END; .) .
+ 1275    StatSeq                               (. VAR astSeq, astTail: AST.Node; .)
+ 1276      =                                   (. astSeq := AST.NoNode;
+ 1277                                             astTail := AST.NoNode; .)
+ 1278        Statement                         (. AstAppend(AST.NkBlock,
+ 1279                                               astSeq, astTail, astStmt); .)
+ 1280        { ";" [ Statement                 (. AstAppend(AST.NkBlock,
+ 1281                                               astSeq, astTail, astStmt); .) ] }
+ 1282                                          (. astStmt := astSeq; .) .
+ 1283    (* Trailing/empty statements (`a; ; b`, Coco/R's generated `;;`)
+ 1284       are accepted: the statement after ';' is optional. *)
+ 1285    Statement                             (. VAR lx: QbeGen.QVal; .)
+ 1286      = (. astStmt := AST.NoNode; .)
+ 1287        ( AssOrCall
+ 1288      | IfStat
+ 1289      | WhileStat
+ 1290      | RepeatStat
+ 1291      | LoopStat
+ 1292      | ForStat
+ 1293      | CaseStat
+ 1294      | WithStat
+ 1295      | ReturnStat
+ 1296      | HaltStat
+ 1297      | NewStat
+ 1298      | DisposeStat
+ 1299      | IncDecStat
+ 1300      | InclExclStat
+ 1301      | "EXIT"                            (. IF QbeGen.TopLoop(lx) THEN
+ 1302                                               QbeGen.Jmp(lx)
+ 1303                                             ELSE SemError(230) END;
+ 1304                                             astStmt := AST.MakeNode(AST.NkExit); .) ) .
+ 1305    (* INCL(set, elem) / EXCL(set, elem): PIM set-element builtins. *)
+ 1306    InclExclStat                          (. VAR at, et2: SymTab.TypeIndex;
+ 1307                                               dk: INTEGER;
+ 1308                                               qd, qe: QbeGen.QVal;
+ 1309                                               qn: SymTab.Name;
+ 1310                                               sfx, isInc: BOOLEAN;
+ 1311                                               astNode, astD: AST.Node; .)
+ 1312      = ( "INCL"                          (. isInc := TRUE; .)
+ 1313        | "EXCL"                          (. isInc := FALSE; .) )
+ 1314        "(" Design<at, dk, qd, qn, sfx> (. astD := astCur; .) ","
+ 1315        Expr<et2, qe> ")"
+ 1316                                          (. astNode := AST.MakeNode(AST.NkCall);
+ 1317                                             IF isInc THEN
+ 1318                                               AST.SetChild(astNode, 0,
+ 1319                                                 AST.MakeLeaf(AST.NkIdent, "INCL"))
+ 1320                                             ELSE AST.SetChild(astNode, 0,
+ 1321                                                 AST.MakeLeaf(AST.NkIdent, "EXCL"))
+ 1322                                             END;
+ 1323                                             IF astD # AST.NoNode THEN
+ 1324                                               AST.SetChild(astNode, 1, astD) END;
+ 1325                                             IF astCur # AST.NoNode THEN
+ 1326                                               AST.SetChild(astNode, 2, astCur) END;
+ 1327                                             astStmt := astNode; .)
+ 1328                                          (. IF at = SymTab.InvalidType THEN
+ 1329                                             ELSIF SymTab.ClassOf(at) #
+ 1330                                                   SymTab.ClSet THEN
+ 1331                                               SemError(222)
+ 1332                                             ELSE
+ 1333                                               IF isInc THEN
+ 1334                                                 QbeGen.SetBit(qd, qe,
+ 1335                                                   SymTab.SetBaseLo(at),
+ 1336                                                   SymTab.SetCount(at))
+ 1337                                               ELSE
+ 1338                                                 QbeGen.SetClearBit(qd, qe,
+ 1339                                                   SymTab.SetBaseLo(at),
+ 1340                                                   SymTab.SetCount(at))
+ 1341                                               END
+ 1342                                             END; .) .
+ 1343    (* INC(v [,step]) / DEC(v [,step]) as builtin statements over an
+ 1344       integer designator. *)
+ 1345    IncDecStat                            (. VAR dt, et2: SymTab.TypeIndex;
+ 1346                                               dk: INTEGER;
+ 1347                                               qd, qv, qn2, qstep:
+ 1348                                                 QbeGen.QVal;
+ 1349                                               qn: SymTab.Name;
+ 1350                                               sfx, isInc: BOOLEAN;
+ 1351                                               astNode, astD, astStep:
+ 1352                                                 AST.Node; .)
+ 1353      =                                   (. isInc := TRUE; .)
+ 1354        ( "INC"                           (. isInc := TRUE; .)
+ 1355        | "DEC"                           (. isInc := FALSE; .) )
+ 1356        "("                               (. QbeGen.CopyOp("1", qstep); astStep := AST.NoNode; .)
+ 1357        Design<dt, dk, qd, qn, sfx> (. astD := astCur; .)
+ 1358        [ "," Expr<et2, qstep> (. astStep := astCur; .) ]
+ 1359        ")"                               (. astNode := AST.MakeNode(AST.NkCall);
+ 1360                                             IF isInc THEN
+ 1361                                               AST.SetChild(astNode, 0,
+ 1362                                                 AST.MakeLeaf(AST.NkIdent, "INC"))
+ 1363                                             ELSE AST.SetChild(astNode, 0,
+ 1364                                                 AST.MakeLeaf(AST.NkIdent, "DEC"))
+ 1365                                             END;
+ 1366                                             IF astD # AST.NoNode THEN
+ 1367                                               AST.SetChild(astNode, 1, astD) END;
+ 1368                                             IF astStep # AST.NoNode THEN
+ 1369                                               AST.SetChild(astNode, 2, astStep) END;
+ 1370                                             astStmt := astNode; .)                               (. IF dt = SymTab.InvalidType THEN
+ 1371                                             ELSIF (dk # SymTab.KindVar)
+ 1372   AND (dk # SymTab.KindParam)
+ 1373   AND (dk # SymTab.KindField) THEN
+ 1374                                               SemError(210)
+ 1375                                             ELSIF NOT SymTab.IsIntFamily(dt) THEN
+ 1376                                               SemError(211)
+ 1377                                             ELSE
+ 1378                                               IF sfx
+ 1379                                                  OR (dk = SymTab.KindField) THEN
+ 1380                                                 QbeGen.ElemLoad(qd, dt, qv)
+ 1381                                               ELSE QbeGen.LoadVar(qn,
+ 1382                                                 FALSE, qv)
+ 1383                                               END;
+ 1384                                               QbeGen.NewTemp(qn2);
+ 1385                                               IF isInc THEN
+ 1386                                                 QbeGen.Op3("add", qn2, qv,
+ 1387                                                   qstep, FALSE)
+ 1388                                               ELSE QbeGen.Op3("sub", qn2, qv,
+ 1389                                                   qstep, FALSE)
+ 1390                                               END;
+ 1391                                               IF sfx
+ 1392                                                  OR (dk = SymTab.KindField) THEN
+ 1393                                                 QbeGen.ElemStore(qd, qn2,
+ 1394                                                   dt)
+ 1395                                               ELSE QbeGen.StoreVar(qn,
+ 1396                                                 qn2, FALSE)
+ 1397                                               END
+ 1398                                             END; .) .
+ 1399    (* NEW/DISPOSE as builtin statements (no call syntax until step 4).
+ 1400       Targets are pointer designators; DISPOSE nils afterwards (safer
+ 1401       than Wirth-undefined; documented). DISPOSE is shallow. *)
+ 1402    NewStat                               (. VAR dt: SymTab.TypeIndex;
+ 1403                                               dk: INTEGER;
+ 1404                                               qd, qm: QbeGen.QVal;
+ 1405                                               qn: SymTab.Name;
+ 1406                                               sfx: BOOLEAN;
+ 1407                                               bt: SymTab.TypeIndex;
+ 1408                                               astNode, astD: AST.Node; .)
+ 1409      = "NEW" "(" Design<dt, dk, qd, qn, sfx> (. astD := astCur; .) ")"
+ 1410                                          (. astNode := AST.MakeNode(AST.NkCall);
+ 1411                                             AST.SetChild(astNode, 0,
+ 1412                                               AST.MakeLeaf(AST.NkIdent, "NEW"));
+ 1413                                             IF astD # AST.NoNode THEN
+ 1414                                               AST.SetChild(astNode, 1, astD) END;
+ 1415                                             astStmt := astNode; .)
+ 1416                                          (. IF dt = SymTab.InvalidType THEN
+ 1417                                             ELSIF (dk # SymTab.KindVar)
+ 1418   AND (dk # SymTab.KindParam)
+ 1419   AND (dk # SymTab.KindField) THEN
+ 1420                                               SemError(210)
+ 1421                                             ELSIF SymTab.ClassOf(dt) #
+ 1422                                                   SymTab.ClPtr THEN
+ 1423                                               SemError(219)
+ 1424                                             ELSE bt := SymTab.PtrBase(dt);
+ 1425                                               IF bt #
+ 1426                                                  SymTab.InvalidType THEN
+ 1427                                                 QbeGen.NewHeap(bt, qm);
+ 1428                                                 QbeGen.InitHeap(qm, bt);
+ 1429                                                 IF sfx
+ 1430                                                    OR (dk =
+ 1431                                                       SymTab.KindField) THEN
+ 1432                                                   QbeGen.ElemStore(qd, qm,
+ 1433                                                     dt)
+ 1434                                                 ELSE QbeGen.StorePtr(qn,
+ 1435                                                   qm)
+ 1436                                                 END
+ 1437                                               END
+ 1438                                             END; .) .
+ 1439    DisposeStat                           (. VAR dt: SymTab.TypeIndex;
+ 1440                                               dk: INTEGER;
+ 1441                                               qd, qv: QbeGen.QVal;
+ 1442                                               qn: SymTab.Name;
+ 1443                                               sfx: BOOLEAN;
+ 1444                                               astNode, astD: AST.Node; .)
+ 1445      = "DISPOSE" "(" Design<dt, dk, qd, qn, sfx> (. astD := astCur; .) ")"
+ 1446                                          (. astNode := AST.MakeNode(AST.NkCall);
+ 1447                                             AST.SetChild(astNode, 0,
+ 1448                                               AST.MakeLeaf(AST.NkIdent, "DISPOSE"));
+ 1449                                             IF astD # AST.NoNode THEN
+ 1450                                               AST.SetChild(astNode, 1, astD) END;
+ 1451                                             astStmt := astNode; .)
+ 1452                                          (. IF dt = SymTab.InvalidType THEN
+ 1453                                             ELSIF (dk # SymTab.KindVar)
+ 1454   AND (dk # SymTab.KindParam)
+ 1455   AND (dk # SymTab.KindField) THEN
+ 1456                                               SemError(210)
+ 1457                                             ELSIF SymTab.ClassOf(dt) #
+ 1458                                                   SymTab.ClPtr THEN
+ 1459                                               SemError(219)
+ 1460                                             ELSE
+ 1461                                               IF sfx
+ 1462                                                  OR (dk =
+ 1463                                                     SymTab.KindField) THEN
+ 1464                                                 QbeGen.ElemLoad(qd, dt,
+ 1465                                                   qv)
+ 1466                                               ELSE QbeGen.LoadPtr(qn, qv)
+ 1467                                               END;
+ 1468                                               QbeGen.FreeHeap(qv);
+ 1469                                               IF sfx
+ 1470                                                  OR (dk =
+ 1471                                                     SymTab.KindField) THEN
+ 1472                                                 QbeGen.ElemStore(qd, "0",
+ 1473                                                   dt)
+ 1474                                               ELSE QbeGen.StorePtr(qn,
+ 1475                                                 "0")
+ 1476                                               END
+ 1477                                             END; .) .
+ 1478    (* WITH pushes each record's fields (inner wins) plus its base
+ 1479       address; field designators resolve through both stacks. *)
+ 1480    WithStat                              (. VAR nW: CARDINAL;
+ 1481                                               astNode: AST.Node; .)
+ 1482      = "WITH"                            (. nW := 0;
+ 1483                                             astNode := AST.MakeNode(AST.NkWith); .)
+ 1484        WithItem<nW, astNode> { "," WithItem<nW, astNode> }
+ 1485        "DO"                              (. astStmt := AST.NoNode; .)
+ 1486        [ StatSeq ] "END"                 (. AST.SetChild(astNode,
+ 1487                                             AST.NChild(astNode), astStmt);
+ 1488                                             astStmt := astNode;
+ 1489                                             WHILE nW > 0 DO
+ 1490                                               SymTab.PopScope;
+ 1491                                               QbeGen.PopWith;
+ 1492                                               DEC(nW)
+ 1493                                             END; .) .
+ 1494    WithItem<VAR nW: CARDINAL; wnode: AST.Node>
+ 1495                                          (. VAR dt: SymTab.TypeIndex;
+ 1496                                               dk: INTEGER;
+ 1497                                               qd, qe: QbeGen.QVal;
+ 1498                                               qn: SymTab.Name;
+ 1499                                               sfx: BOOLEAN; .)
+ 1500      = Design<dt, dk, qd, qn, sfx>
+ 1501                                          (. IF astCur # AST.NoNode THEN
+ 1502                                               AST.SetChild(wnode,
+ 1503                                                 AST.NChild(wnode), astCur) END;
+ 1504                                             IF dt = SymTab.InvalidType THEN
+ 1505                                             ELSIF (SymTab.ClassOf(dt) #
+ 1506                                                    SymTab.ClRecord)
+ 1507   AND (SymTab.ClassOf(dt) #
+ 1508                                                   SymTab.ClClass) THEN
+ 1509                                               SemError(215)
+ 1510                                             ELSIF SymTab.PushRecord(dt) THEN
+ 1511                                               QbeGen.PushWith(qd);
+ 1512                                               INC(nW)
+ 1513                                             END; .) .
+ 1514    (* Assignment or procedure-statement call (4.1, module level).
+ 1515       Bare `P;` is a syntax error; function-as-statement is 233. *)
+ 1516    AssOrCall                             (. VAR dt, et: SymTab.TypeIndex;
+ 1517                                               dk: INTEGER;
+ 1518                                               qd, qe, qt, ql: QbeGen.QVal;
+ 1519                                               qn: SymTab.Name;
+ 1520                                               ct2, res0: SymTab.TypeIndex;
+ 1521                                               q2, mg0: QbeGen.QVal;
+ 1522                                               isR, conv, wconv: BOOLEAN;
+ 1523                                               called, sfx: BOOLEAN;
+ 1524                                               astLhs: AST.Node; .)
+ 1525      = Design<dt, dk, qd, qn, sfx>
+ 1526        (. astLhs := astCur; astNArgs := 0; .)
+ 1527        ( ":="
+ 1528          Expr<et, qe>                    (. astStmt := AST.MakeBin(
+ 1529                                               AST.NkAssign, 0, astLhs, astCur);
+ 1530                                             IF (dt # SymTab.InvalidType)
+ 1531   AND (dk # SymTab.KindVar)
+ 1532   AND (dk # SymTab.KindParam)
+ 1533   AND (dk # SymTab.KindField) THEN
  1534                                             SemError(210)
- 1535                                           ELSIF (dt # SymTab.InvalidType)
- 1536   AND (SymTab.ClassOf(dt) =
- 1537                                                 SymTab.ClClass) THEN
- 1538                                             SemError(230) END;
- 1539                                           isR := (dt #
- 1540                                                   SymTab.InvalidType)
- 1541   AND (SymTab.ClassOf(dt)
- 1542                                                     = SymTab.ClReal);
- 1543                                           conv := isR
- 1544   AND SymTab.IsIntFamily(et);
- 1545                                           wconv := (dt #
- 1546                                                     SymTab.InvalidType)
- 1547   AND SymTab.IsLongFamily(dt)
- 1548   AND SymTab.IsIntFamily(et);
- 1549                                           IF ((dk = SymTab.KindVar)
- 1550                                               OR (dk = SymTab.KindParam)
- 1551                                               OR (dk = SymTab.KindField))
- 1552   AND (dt # SymTab.InvalidType)
- 1553   AND (et # SymTab.InvalidType)
- 1554   AND (SymTab.ClassOf(dt) #
- 1555                                                 SymTab.ClClass) THEN
- 1556                                             IF sfx
- 1557                                                OR (dk = SymTab.KindField) THEN
- 1558                                               IF SymTab.ClassOf(dt) =
- 1559                                                  SymTab.ClArray THEN
- 1560                                                 IF (et # SymTab.InvalidType)
- 1561    AND (SymTab.ClassOf(et) = SymTab.ClUStr)
- 1562    AND SymTab.IsUCharArray(dt) THEN
- 1563                                                   QbeGen.UAssign(qd, qe)
- 1564                                                 ELSIF SymTab.StrCompat(dt,
- 1565                                                      et) THEN
- 1566                                                   QbeGen.StrAssign(qd,
- 1567                                                     qe)
- 1568                                                 ELSE
- 1569                                                   QbeGen.CopyArray(qd,
- 1570                                                     qe, dt)
- 1571                                                 END
- 1572                                               ELSIF SymTab.ClassOf(dt) =
- 1573                                                   SymTab.ClSet THEN
- 1574                                                 QbeGen.CopySet(qd, qe,
- 1575                                                   SymTab.SetWords(dt),
- 1576                                                   SymTab.SetWords(et))
- 1577                                               ELSIF SymTab.ClassOf(dt) =
- 1578                                                   SymTab.ClRecord THEN
- 1579                                                 QbeGen.CopyRecord(qd, qe,
- 1580                                                   dt)
- 1581                                               ELSIF SymTab.IsLongFamily(dt) THEN
- 1582                                                 IF wconv THEN
- 1583                                                   QbeGen.WidenLong(qe, ql);
- 1584                                                   QbeGen.ElemStore(qd, ql,
- 1585                                                     dt)
- 1586                                                 ELSE QbeGen.ElemStore(qd, qe,
- 1587                                                   dt)
- 1588                                                 END
- 1589                                               ELSIF conv THEN
- 1590                                                 QbeGen.ConvIR(qe, qt);
- 1591                                                 QbeGen.ElemStore(qd, qt,
- 1592                                                   dt)
- 1593                                               ELSE QbeGen.ElemStore(qd, qe,
- 1594                                                 dt)
- 1595                                               END
- 1596                                             ELSIF SymTab.ClassOf(dt) =
- 1597                                                   SymTab.ClArray THEN
- 1598                                               IF (et # SymTab.InvalidType)
- 1599    AND (SymTab.ClassOf(et) = SymTab.ClUStr)
- 1600    AND SymTab.IsUCharArray(dt) THEN
- 1601                                                 QbeGen.UAssign(qd, qe)
- 1602                                               ELSIF SymTab.StrCompat(dt,
- 1603                                                    et) THEN
- 1604                                                 QbeGen.StrAssign(qd, qe)
- 1605                                               ELSE
- 1606                                                 QbeGen.CopyArray(qd, qe,
- 1607                                                   dt)
- 1608                                               END
- 1609                                             ELSIF SymTab.ClassOf(dt) =
- 1610                                                   SymTab.ClSet THEN
- 1611                                               QbeGen.CopySet(qd, qe,
- 1612                                                 SymTab.SetWords(dt),
- 1613                                                 SymTab.SetWords(et))
- 1614                                             ELSIF SymTab.ClassOf(dt) =
- 1615                                                   SymTab.ClRecord THEN
- 1616                                               QbeGen.CopyRecord(qd, qe, dt)
- 1617                                             ELSIF (SymTab.ClassOf(dt) =
- 1618                                                   SymTab.ClPtr)
- 1619                                                OR (SymTab.ClassOf(dt) =
- 1620                                                   SymTab.ClProc) THEN
- 1621                                               QbeGen.StorePtr(qn, qe)
- 1622                                             ELSIF SymTab.IsLongFamily(dt) THEN
- 1623                                               IF wconv THEN
- 1624                                                 QbeGen.WidenLong(qe, ql);
- 1625                                                 QbeGen.StoreLong(qn, ql)
- 1626                                               ELSE QbeGen.StoreLong(qn, qe)
- 1627                                               END
- 1628                                             ELSIF conv THEN
- 1629                                               QbeGen.ConvIR(qe, qt);
- 1630                                               QbeGen.StoreVar(qn, qt, TRUE)
- 1631                                             ELSE
- 1632                                               QbeGen.StoreVar(qn, qe, isR)
- 1633                                             END
- 1634                                           END; .)
- 1635        | ArgList<qn, dt, qd, FALSE, FALSE, methCls, ct2, q2, called>
- 1636                                          (. astStmt := AstCallNode(astLhs); .)
- 1637        |                                 (* bare `P;`: proper parameterless
- 1638                                              procedure call; anything else
- 1639                                              here is 233 (was a bare syntax
- 1640                                              error before 4.2) *)
- 1641                                          (. astStmt := AstCallNode(astLhs);
- 1642                                              IF (dk = SymTab.KindProc)
- 1643   AND NOT sfx THEN
- 1644                                               res0 := SymTab.ProcRes(qn);
- 1645                                               IF res0 #
- 1646                                                  SymTab.InvalidType THEN
- 1647                                                 SemError(233)
- 1648                                               ELSIF SymTab.ProcNPar(qn) #
- 1649                                                       0 THEN
+ 1535                                           ELSIF NOT SymTab.Assignable(et,
+ 1536                                                    dt) THEN
+ 1537                                             SemError(210)
+ 1538                                           ELSIF (dt # SymTab.InvalidType)
+ 1539   AND (SymTab.ClassOf(dt) =
+ 1540                                                 SymTab.ClClass) THEN
+ 1541                                             SemError(230) END;
+ 1542                                           isR := (dt #
+ 1543                                                   SymTab.InvalidType)
+ 1544   AND (SymTab.ClassOf(dt)
+ 1545                                                     = SymTab.ClReal);
+ 1546                                           conv := isR
+ 1547   AND SymTab.IsIntFamily(et);
+ 1548                                           wconv := (dt #
+ 1549                                                     SymTab.InvalidType)
+ 1550   AND SymTab.IsLongFamily(dt)
+ 1551   AND SymTab.IsIntFamily(et);
+ 1552                                           IF ((dk = SymTab.KindVar)
+ 1553                                               OR (dk = SymTab.KindParam)
+ 1554                                               OR (dk = SymTab.KindField))
+ 1555   AND (dt # SymTab.InvalidType)
+ 1556   AND (et # SymTab.InvalidType)
+ 1557   AND (SymTab.ClassOf(dt) #
+ 1558                                                 SymTab.ClClass) THEN
+ 1559                                             IF sfx
+ 1560                                                OR (dk = SymTab.KindField) THEN
+ 1561                                               IF SymTab.ClassOf(dt) =
+ 1562                                                  SymTab.ClArray THEN
+ 1563                                                 IF (et # SymTab.InvalidType)
+ 1564    AND (SymTab.ClassOf(et) = SymTab.ClUStr)
+ 1565    AND SymTab.IsUCharArray(dt) THEN
+ 1566                                                   QbeGen.UAssign(qd, qe)
+ 1567                                                 ELSIF SymTab.StrCompat(dt,
+ 1568                                                      et) THEN
+ 1569                                                   QbeGen.StrAssign(qd,
+ 1570                                                     qe)
+ 1571                                                 ELSE
+ 1572                                                   QbeGen.CopyArray(qd,
+ 1573                                                     qe, dt)
+ 1574                                                 END
+ 1575                                               ELSIF SymTab.ClassOf(dt) =
+ 1576                                                   SymTab.ClSet THEN
+ 1577                                                 QbeGen.CopySet(qd, qe,
+ 1578                                                   SymTab.SetWords(dt),
+ 1579                                                   SymTab.SetWords(et))
+ 1580                                               ELSIF SymTab.ClassOf(dt) =
+ 1581                                                   SymTab.ClRecord THEN
+ 1582                                                 QbeGen.CopyRecord(qd, qe,
+ 1583                                                   dt)
+ 1584                                               ELSIF SymTab.IsLongFamily(dt) THEN
+ 1585                                                 IF wconv THEN
+ 1586                                                   QbeGen.WidenLong(qe, ql);
+ 1587                                                   QbeGen.ElemStore(qd, ql,
+ 1588                                                     dt)
+ 1589                                                 ELSE QbeGen.ElemStore(qd, qe,
+ 1590                                                   dt)
+ 1591                                                 END
+ 1592                                               ELSIF conv THEN
+ 1593                                                 QbeGen.ConvIR(qe, qt);
+ 1594                                                 QbeGen.ElemStore(qd, qt,
+ 1595                                                   dt)
+ 1596                                               ELSE QbeGen.ElemStore(qd, qe,
+ 1597                                                 dt)
+ 1598                                               END
+ 1599                                             ELSIF SymTab.ClassOf(dt) =
+ 1600                                                   SymTab.ClArray THEN
+ 1601                                               IF (et # SymTab.InvalidType)
+ 1602    AND (SymTab.ClassOf(et) = SymTab.ClUStr)
+ 1603    AND SymTab.IsUCharArray(dt) THEN
+ 1604                                                 QbeGen.UAssign(qd, qe)
+ 1605                                               ELSIF SymTab.StrCompat(dt,
+ 1606                                                    et) THEN
+ 1607                                                 QbeGen.StrAssign(qd, qe)
+ 1608                                               ELSE
+ 1609                                                 QbeGen.CopyArray(qd, qe,
+ 1610                                                   dt)
+ 1611                                               END
+ 1612                                             ELSIF SymTab.ClassOf(dt) =
+ 1613                                                   SymTab.ClSet THEN
+ 1614                                               QbeGen.CopySet(qd, qe,
+ 1615                                                 SymTab.SetWords(dt),
+ 1616                                                 SymTab.SetWords(et))
+ 1617                                             ELSIF SymTab.ClassOf(dt) =
+ 1618                                                   SymTab.ClRecord THEN
+ 1619                                               QbeGen.CopyRecord(qd, qe, dt)
+ 1620                                             ELSIF (SymTab.ClassOf(dt) =
+ 1621                                                   SymTab.ClPtr)
+ 1622                                                OR (SymTab.ClassOf(dt) =
+ 1623                                                   SymTab.ClProc) THEN
+ 1624                                               QbeGen.StorePtr(qn, qe)
+ 1625                                             ELSIF SymTab.IsLongFamily(dt) THEN
+ 1626                                               IF wconv THEN
+ 1627                                                 QbeGen.WidenLong(qe, ql);
+ 1628                                                 QbeGen.StoreLong(qn, ql)
+ 1629                                               ELSE QbeGen.StoreLong(qn, qe)
+ 1630                                               END
+ 1631                                             ELSIF conv THEN
+ 1632                                               QbeGen.ConvIR(qe, qt);
+ 1633                                               QbeGen.StoreVar(qn, qt, TRUE)
+ 1634                                             ELSE
+ 1635                                               QbeGen.StoreVar(qn, qe, isR)
+ 1636                                             END
+ 1637                                           END; .)
+ 1638        | ArgList<qn, dt, qd, FALSE, FALSE, methCls, ct2, q2, called>
+ 1639                                          (. astStmt := AstCallNode(astLhs); .)
+ 1640        |                                 (* bare `P;`: proper parameterless
+ 1641                                              procedure call; anything else
+ 1642                                              here is 233 (was a bare syntax
+ 1643                                              error before 4.2) *)
+ 1644                                          (. astStmt := AstCallNode(astLhs);
+ 1645                                              IF (dk = SymTab.KindProc)
+ 1646   AND NOT sfx THEN
+ 1647                                               res0 := SymTab.ProcRes(qn);
+ 1648                                               IF res0 #
+ 1649                                                  SymTab.InvalidType THEN
  1650                                                 SemError(233)
- 1651                                               ELSE QbeGen.Mangled(qn,
- 1652                                                 SymTab.ProcUid(qn), mg0);
- 1653                                                 QbeGen.CallBegin(mg0,
- 1654                                                   res0,
- 1655                                                   SymTab.ProcDepthOf(qn),
- 1656                                                   SymTab.IsExternal(qn));
- 1657                                                 QbeGen.CallEnd(FALSE, q2)
- 1658                                               END
- 1659                                             ELSE SemError(233)
- 1660                                             END; .) ) .
- 1661    (* Actual-parameter list shared by statement and expression calls.
- 1662       want selects CallEnd's result handling; t/q carry the call
- 1663       value (statement calls discard). Arity/type failures are 233;
- 1664       evaluation code still emits so the .ssa stays assembleable. *)
- 1665    ArgList<pn: SymTab.Name; pt: SymTab.TypeIndex; callee: QbeGen.QVal;
- 1666            want: BOOLEAN; soft: BOOLEAN; methCls: SymTab.TypeIndex;
- 1667            VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal;
- 1668            VAR called: BOOLEAN>          (. VAR i, np: CARDINAL;
- 1669                                               vs: INTEGER;
- 1670                                               res: SymTab.TypeIndex;
- 1671                                               mg: QbeGen.QVal;
- 1672                                               ok, ind, isMeth, va: BOOLEAN; .)
- 1673      = "("                               (. called := TRUE;
- 1674                                             ok := TRUE;
- 1675                                             ind := FALSE;
- 1676                                             isMeth := methCls #
- 1677                                               SymTab.InvalidType;
- 1678                                             IF isMeth THEN
- 1679                                               (* class method: the
- 1680                                                  receiver is armed.
- 1681                                                  Virtual -> dispatch
- 1682                                                  through the vtable;
- 1683                                                  otherwise a static
- 1684                                                  call. *)
- 1685                                               res := SymTab.ClassMethodRes(
- 1686                                                 methCls, pn);
- 1687                                               vs := SymTab.VirtSlot(
- 1688                                                 methCls, pn);
- 1689                                               IF vs >= 0 THEN
- 1690                                                 QbeGen.VirtCallBegin(
- 1691                                                   callee, vs, res)
- 1692                                               ELSE
- 1693                                                 QbeGen.Mangled(pn,
- 1694                                                   SymTab.ClassMethodUid(
- 1695                                                   methCls, pn), mg);
- 1696                                                 QbeGen.CallBegin(mg, res, 0,
- 1697                                                   FALSE)
- 1698                                               END
- 1699                                             ELSIF SymTab.SymKind(pn) =
- 1700                                                SymTab.KindProc THEN
- 1701                                               res := SymTab.ProcRes(pn);
- 1702                                               QbeGen.Mangled(pn,
- 1703                                                 SymTab.ProcUid(pn), mg);
- 1704                                               QbeGen.CallBegin(mg, res,
- 1705                                                 SymTab.ProcDepthOf(pn),
- 1706                                                 SymTab.IsExternal(pn))
- 1707                                             ELSIF (pt # SymTab.InvalidType)
- 1708    AND (SymTab.ClassOf(pt) = SymTab.ClProc) THEN
- 1709                                               ind := TRUE;
- 1710                                               res :=
- 1711                                                 SymTab.ProcTypeRes(pt);
- 1712                                               QbeGen.CallBeginInd(callee,
- 1713                                                 res, FALSE)
- 1714                                             ELSE SemError(233);
- 1715                                               ok := FALSE;
- 1716                                               res := SymTab.InvalidType
- 1717                                             END;
- 1718                                             i := 0; .)
- 1719        [ ActParam<pn, pt, ind, methCls, i>        (. INC(i); .)
- 1720          { "," ActParam<pn, pt, ind, methCls, i>  (. INC(i); .) } ]
- 1721        ")"                               (. IF ok THEN
- 1722                                               IF isMeth THEN
- 1723                                                 np := SymTab.ClassMethodNPar(
- 1724                                                   methCls, pn)
- 1725                                               ELSIF ind THEN
- 1726                                                 np := SymTab.ProcTypeNPar(pt)
- 1727                                               ELSE np := SymTab.ProcNPar(pn)
- 1728                                               END;
- 1729                                               va := (NOT isMeth) AND (NOT ind)
- 1730                                                 AND (SymTab.SymKind(pn) =
- 1731                                                      SymTab.KindProc)
- 1732                                                 AND SymTab.Varargs(pn);
- 1733                                               IF (i # np) AND NOT va THEN
- 1734                                                 SemError(233); ok := FALSE
- 1735                                               END
- 1736                                             END;
- 1737                                             IF NOT ok THEN
- 1738                                               t := SymTab.InvalidType;
- 1739                                               QbeGen.CopyOp("0", q)
- 1740                                             ELSIF want THEN
- 1741                                               IF res =
- 1742                                                  SymTab.InvalidType THEN
- 1743                                                 SemError(233);
- 1744                                                 t := SymTab.InvalidType;
- 1745                                                 QbeGen.CopyOp("0", q)
- 1746                                               ELSE t := res;
- 1747                                                 QbeGen.CallEnd(TRUE, q)
- 1748                                               END
- 1749                                             ELSE
- 1750                                               IF res #
- 1751                                                  SymTab.InvalidType THEN
- 1752                                                 SemError(233)
- 1753                                               END;
- 1754                                               t := SymTab.InvalidType;
- 1755                                               QbeGen.CopyOp("0", q);
- 1756                                               QbeGen.CallEnd(FALSE, q)
- 1757                                             END; .) .
- 1758    (* One actual: VAR formals take recorded designator addresses
- 1759       (233 otherwise); value formals take converted expressions. *)
- 1760    ActParam<pn: SymTab.Name; pt: SymTab.TypeIndex; ind: BOOLEAN;
- 1761             methCls: SymTab.TypeIndex; i: CARDINAL>
- 1762                                          (. VAR at, ft: SymTab.TypeIndex;
- 1763                                               qe, qa, qt: QbeGen.QVal;
- 1764                                               isV, conv, va: BOOLEAN;
- 1765                                               cl: CHAR;
- 1766                                               savedN, aj: CARDINAL;
- 1767                                               savedArgs: ARRAY [0 .. 31]
- 1768                                                 OF AST.Node; .)
- 1769      =                                   (. (* Parsing the actual can clobber
- 1770                                               the enclosing call's argument
- 1771                                               list (Factor resets astNArgs),
- 1772                                               so save/restore it. *)
- 1773                                             savedN := astNArgs; aj := 0;
- 1774                                             WHILE aj <= HIGH(astArgs) DO
- 1775                                               savedArgs[aj] := astArgs[aj];
- 1776                                               INC(aj)
- 1777                                             END; .)
- 1778        Expr<at, qe>                      (. astNArgs := savedN; aj := 0;
- 1779                                             WHILE aj <= HIGH(astArgs) DO
- 1780                                               astArgs[aj] := savedArgs[aj];
- 1781                                               INC(aj)
- 1782                                             END;
- 1783                                             IF astNArgs <= HIGH(astArgs) THEN
- 1784                                               astArgs[astNArgs] := astCur;
- 1785                                               INC(astNArgs)
- 1786                                             END;
- 1787                                             va := (NOT ind)
- 1788                                               AND (methCls =
- 1789                                                  SymTab.InvalidType)
- 1790                                               AND (SymTab.SymKind(pn) =
- 1791                                                  SymTab.KindProc)
- 1792                                               AND SymTab.Varargs(pn);
- 1793                                             IF ind THEN
- 1794                                               ft :=
- 1795                                                 SymTab.ProcTypeParamType(pt,
- 1796                                                   i);
- 1797                                               isV :=
- 1798                                                 SymTab.ProcTypeParamIsVar(pt,
- 1799                                                   i)
- 1800                                             ELSIF methCls #
- 1801                                                SymTab.InvalidType THEN
- 1802                                               ft :=
- 1803                                                 SymTab.ClassMethodParamType(
- 1804                                                 methCls, pn, i);
- 1805                                               isV :=
- 1806                                                 SymTab.ClassMethodParamIsVar(
- 1807                                                 methCls, pn, i)
- 1808                                             ELSE
- 1809                                               ft := SymTab.ParamType(pn, i);
- 1810                                               isV := SymTab.ParamIsVar(pn, i)
- 1811                                             END;
- 1812                                             IF (at = SymTab.InvalidType) THEN
- 1813                                             ELSIF ft = SymTab.InvalidType THEN
- 1814                                               IF va THEN
- 1815                                                 QbeGen.CArgAdd(qe, at, qa, cl)
- 1816                                               END
- 1817                                             ELSIF isV THEN
- 1818                                               IF (SymTab.ClassOf(at)
- 1819                                                  = SymTab.ClChar)
- 1820    AND (SymTab.ClassOf(ft) = SymTab.ClArray)
- 1821    AND (SymTab.ClassOf(SymTab.ArrayElem(ft))
- 1822         = SymTab.ClChar)
- 1823    AND QbeGen.IsImm(qe) THEN
- 1824                                                 (* 1-char string
- 1825                                                    literal passed to
- 1826                                                    a VAR ARRAY OF CHAR *)
- 1827                                                 QbeGen.DeclCharStr(qe,
- 1828                                                      qa);
- 1829                                                 IF NOT QbeGen.CallArg(qa,
- 1830                                                    "l") THEN
- 1831                                                   SemError(233)
- 1832                                                 END
- 1833                                               ELSIF NOT QbeGen.AddrOfVal(qe,
- 1834                                                    qa) THEN
- 1835                                                 SemError(233)
- 1836                                               ELSIF NOT SymTab.VarParamOk(at,
- 1837                                                        ft) THEN
+ 1651                                               ELSIF SymTab.ProcNPar(qn) #
+ 1652                                                       0 THEN
+ 1653                                                 SemError(233)
+ 1654                                               ELSE QbeGen.Mangled(qn,
+ 1655                                                 SymTab.ProcUid(qn), mg0);
+ 1656                                                 QbeGen.CallBegin(mg0,
+ 1657                                                   res0,
+ 1658                                                   SymTab.ProcDepthOf(qn),
+ 1659                                                   SymTab.IsExternal(qn));
+ 1660                                                 QbeGen.CallEnd(FALSE, q2)
+ 1661                                               END
+ 1662                                             ELSE SemError(233)
+ 1663                                             END; .) ) .
+ 1664    (* Actual-parameter list shared by statement and expression calls.
+ 1665       want selects CallEnd's result handling; t/q carry the call
+ 1666       value (statement calls discard). Arity/type failures are 233;
+ 1667       evaluation code still emits so the .ssa stays assembleable. *)
+ 1668    ArgList<pn: SymTab.Name; pt: SymTab.TypeIndex; callee: QbeGen.QVal;
+ 1669            want: BOOLEAN; soft: BOOLEAN; methCls: SymTab.TypeIndex;
+ 1670            VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal;
+ 1671            VAR called: BOOLEAN>          (. VAR i, np: CARDINAL;
+ 1672                                               vs: INTEGER;
+ 1673                                               res: SymTab.TypeIndex;
+ 1674                                               mg: QbeGen.QVal;
+ 1675                                               ok, ind, isMeth, va: BOOLEAN; .)
+ 1676      = "("                               (. called := TRUE;
+ 1677                                             ok := TRUE;
+ 1678                                             ind := FALSE;
+ 1679                                             isMeth := methCls #
+ 1680                                               SymTab.InvalidType;
+ 1681                                             IF isMeth THEN
+ 1682                                               (* class method: the
+ 1683                                                  receiver is armed.
+ 1684                                                  Virtual -> dispatch
+ 1685                                                  through the vtable;
+ 1686                                                  otherwise a static
+ 1687                                                  call. *)
+ 1688                                               res := SymTab.ClassMethodRes(
+ 1689                                                 methCls, pn);
+ 1690                                               vs := SymTab.VirtSlot(
+ 1691                                                 methCls, pn);
+ 1692                                               IF vs >= 0 THEN
+ 1693                                                 QbeGen.VirtCallBegin(
+ 1694                                                   callee, vs, res)
+ 1695                                               ELSE
+ 1696                                                 QbeGen.Mangled(pn,
+ 1697                                                   SymTab.ClassMethodUid(
+ 1698                                                   methCls, pn), mg);
+ 1699                                                 QbeGen.CallBegin(mg, res, 0,
+ 1700                                                   FALSE)
+ 1701                                               END
+ 1702                                             ELSIF SymTab.SymKind(pn) =
+ 1703                                                SymTab.KindProc THEN
+ 1704                                               res := SymTab.ProcRes(pn);
+ 1705                                               QbeGen.Mangled(pn,
+ 1706                                                 SymTab.ProcUid(pn), mg);
+ 1707                                               QbeGen.CallBegin(mg, res,
+ 1708                                                 SymTab.ProcDepthOf(pn),
+ 1709                                                 SymTab.IsExternal(pn))
+ 1710                                             ELSIF (pt # SymTab.InvalidType)
+ 1711    AND (SymTab.ClassOf(pt) = SymTab.ClProc) THEN
+ 1712                                               ind := TRUE;
+ 1713                                               res :=
+ 1714                                                 SymTab.ProcTypeRes(pt);
+ 1715                                               QbeGen.CallBeginInd(callee,
+ 1716                                                 res, FALSE)
+ 1717                                             ELSE SemError(233);
+ 1718                                               ok := FALSE;
+ 1719                                               res := SymTab.InvalidType
+ 1720                                             END;
+ 1721                                             i := 0; .)
+ 1722        [ ActParam<pn, pt, ind, methCls, i>        (. INC(i); .)
+ 1723          { "," ActParam<pn, pt, ind, methCls, i>  (. INC(i); .) } ]
+ 1724        ")"                               (. IF ok THEN
+ 1725                                               IF isMeth THEN
+ 1726                                                 np := SymTab.ClassMethodNPar(
+ 1727                                                   methCls, pn)
+ 1728                                               ELSIF ind THEN
+ 1729                                                 np := SymTab.ProcTypeNPar(pt)
+ 1730                                               ELSE np := SymTab.ProcNPar(pn)
+ 1731                                               END;
+ 1732                                               va := (NOT isMeth) AND (NOT ind)
+ 1733                                                 AND (SymTab.SymKind(pn) =
+ 1734                                                      SymTab.KindProc)
+ 1735                                                 AND SymTab.Varargs(pn);
+ 1736                                               IF (i # np) AND NOT va THEN
+ 1737                                                 SemError(233); ok := FALSE
+ 1738                                               END
+ 1739                                             END;
+ 1740                                             IF NOT ok THEN
+ 1741                                               t := SymTab.InvalidType;
+ 1742                                               QbeGen.CopyOp("0", q)
+ 1743                                             ELSIF want THEN
+ 1744                                               IF res =
+ 1745                                                  SymTab.InvalidType THEN
+ 1746                                                 SemError(233);
+ 1747                                                 t := SymTab.InvalidType;
+ 1748                                                 QbeGen.CopyOp("0", q)
+ 1749                                               ELSE t := res;
+ 1750                                                 QbeGen.CallEnd(TRUE, q)
+ 1751                                               END
+ 1752                                             ELSE
+ 1753                                               IF res #
+ 1754                                                  SymTab.InvalidType THEN
+ 1755                                                 SemError(233)
+ 1756                                               END;
+ 1757                                               t := SymTab.InvalidType;
+ 1758                                               QbeGen.CopyOp("0", q);
+ 1759                                               QbeGen.CallEnd(FALSE, q)
+ 1760                                             END; .) .
+ 1761    (* One actual: VAR formals take recorded designator addresses
+ 1762       (233 otherwise); value formals take converted expressions. *)
+ 1763    ActParam<pn: SymTab.Name; pt: SymTab.TypeIndex; ind: BOOLEAN;
+ 1764             methCls: SymTab.TypeIndex; i: CARDINAL>
+ 1765                                          (. VAR at, ft: SymTab.TypeIndex;
+ 1766                                               qe, qa, qt: QbeGen.QVal;
+ 1767                                               isV, conv, va: BOOLEAN;
+ 1768                                               cl: CHAR;
+ 1769                                               savedN, aj: CARDINAL;
+ 1770                                               savedArgs: ARRAY [0 .. 31]
+ 1771                                                 OF AST.Node; .)
+ 1772      =                                   (. (* Parsing the actual can clobber
+ 1773                                               the enclosing call's argument
+ 1774                                               list (Factor resets astNArgs),
+ 1775                                               so save/restore it. *)
+ 1776                                             savedN := astNArgs; aj := 0;
+ 1777                                             WHILE aj <= HIGH(astArgs) DO
+ 1778                                               savedArgs[aj] := astArgs[aj];
+ 1779                                               INC(aj)
+ 1780                                             END; .)
+ 1781        Expr<at, qe>                      (. astNArgs := savedN; aj := 0;
+ 1782                                             WHILE aj <= HIGH(astArgs) DO
+ 1783                                               astArgs[aj] := savedArgs[aj];
+ 1784                                               INC(aj)
+ 1785                                             END;
+ 1786                                             IF astNArgs <= HIGH(astArgs) THEN
+ 1787                                               astArgs[astNArgs] := astCur;
+ 1788                                               INC(astNArgs)
+ 1789                                             END;
+ 1790                                             va := (NOT ind)
+ 1791                                               AND (methCls =
+ 1792                                                  SymTab.InvalidType)
+ 1793                                               AND (SymTab.SymKind(pn) =
+ 1794                                                  SymTab.KindProc)
+ 1795                                               AND SymTab.Varargs(pn);
+ 1796                                             IF ind THEN
+ 1797                                               ft :=
+ 1798                                                 SymTab.ProcTypeParamType(pt,
+ 1799                                                   i);
+ 1800                                               isV :=
+ 1801                                                 SymTab.ProcTypeParamIsVar(pt,
+ 1802                                                   i)
+ 1803                                             ELSIF methCls #
+ 1804                                                SymTab.InvalidType THEN
+ 1805                                               ft :=
+ 1806                                                 SymTab.ClassMethodParamType(
+ 1807                                                 methCls, pn, i);
+ 1808                                               isV :=
+ 1809                                                 SymTab.ClassMethodParamIsVar(
+ 1810                                                 methCls, pn, i)
+ 1811                                             ELSE
+ 1812                                               ft := SymTab.ParamType(pn, i);
+ 1813                                               isV := SymTab.ParamIsVar(pn, i)
+ 1814                                             END;
+ 1815                                             IF (at = SymTab.InvalidType) THEN
+ 1816                                             ELSIF ft = SymTab.InvalidType THEN
+ 1817                                               IF va THEN
+ 1818                                                 QbeGen.CArgAdd(qe, at, qa, cl)
+ 1819                                               END
+ 1820                                             ELSIF isV THEN
+ 1821                                               IF (SymTab.ClassOf(at)
+ 1822                                                  = SymTab.ClChar)
+ 1823    AND (SymTab.ClassOf(ft) = SymTab.ClArray)
+ 1824    AND (SymTab.ClassOf(SymTab.ArrayElem(ft))
+ 1825         = SymTab.ClChar)
+ 1826    AND QbeGen.IsImm(qe) THEN
+ 1827                                                 (* 1-char string
+ 1828                                                    literal passed to
+ 1829                                                    a VAR ARRAY OF CHAR *)
+ 1830                                                 QbeGen.DeclCharStr(qe,
+ 1831                                                      qa);
+ 1832                                                 IF NOT QbeGen.CallArg(qa,
+ 1833                                                    "l") THEN
+ 1834                                                   SemError(233)
+ 1835                                                 END
+ 1836                                               ELSIF NOT QbeGen.AddrOfVal(qe,
+ 1837                                                    qa) THEN
  1838                                                 SemError(233)
- 1839                                               ELSIF NOT QbeGen.CallArg(qa,
- 1840                                                        "l") THEN
+ 1839                                               ELSIF NOT SymTab.VarParamOk(at,
+ 1840                                                        ft) THEN
  1841                                                 SemError(233)
- 1842                                               END
- 1843                                             ELSE
- 1844                                               IF (SymTab.ClassOf(at)
- 1845                                                  = SymTab.ClChar)
- 1846    AND (SymTab.ClassOf(ft) = SymTab.ClArray)
- 1847    AND (SymTab.ClassOf(SymTab.ArrayElem(ft))
- 1848         = SymTab.ClChar)
- 1849    AND QbeGen.IsImm(qe) THEN
- 1850                                                 (* 1-char string
- 1851                                                    literal passed to
- 1852                                                    ARRAY OF CHAR *)
- 1853                                                 QbeGen.DeclCharStr(qe,
- 1854                                                      qa);
- 1855                                                 IF NOT QbeGen.CallArg(qa,
- 1856                                                    "l") THEN
- 1857                                                   SemError(233)
- 1858                                                 END
- 1859                                               ELSIF NOT SymTab.Assignable(at,
- 1860                                                    ft) THEN
- 1861                                                 SemError(233)
- 1862                                               ELSE
- 1863                                                 conv := (SymTab.ClassOf(
- 1864                                                   ft) = SymTab.ClReal)
- 1865   AND SymTab.IsIntFamily(at);
- 1866                                                 IF conv THEN
- 1867                                                   QbeGen.ConvIR(qe, qt);
- 1868                                                   IF NOT QbeGen.CallArg(qt,
- 1869                                                      "d") THEN
- 1870                                                     SemError(233)
- 1871                                                   END
- 1872                                                 ELSIF NOT QbeGen.CallArg(qe,
- 1873                                                   QbeGen.ArgClass(ft)) THEN
- 1874                                                   SemError(233)
- 1875                                                 END
- 1876                                               END
- 1877                                             END; .) .
- 1878    IfStat                                (. VAR t: SymTab.TypeIndex;
- 1879                                               q, lThen, lElse, lEnd:
- 1880                                                 QbeGen.QVal;
- 1881                                               hasElse: BOOLEAN;
- 1882                                               astCond, astIf, astLast,
- 1883                                               astNode: AST.Node; .)
- 1884      = "IF" (. hasElse := FALSE; .)
- 1885        Expr<t, q> (. astCond := astCur; astStmt := AST.NoNode;
- 1886                                             IF NOT SymTab.BoolCheck(t) THEN
- 1887                                               SemError(214) END;
- 1888                                             QbeGen.NewLabel(lThen);
- 1889                                             QbeGen.NewLabel(lElse);
- 1890                                             QbeGen.NewLabel(lEnd);
- 1891                                             QbeGen.Jnz(q, lThen, lElse);
- 1892                                             QbeGen.EmitLabel(lThen); .)
- 1893        "THEN" [ StatSeq ]                (. astNode := AST.MakeNode(AST.NkIf);
- 1894                                             AST.SetChild(astNode, 0, astCond);
- 1895                                             AST.SetChild(astNode, 1, astStmt);
- 1896                                             astIf := astNode;
- 1897                                             astLast := astNode;
- 1898                                             QbeGen.Jmp(lEnd); .)
- 1899        { "ELSIF"                         (. QbeGen.EmitLabel(lElse);
- 1900                                             QbeGen.NewLabel(lElse); .)
- 1901          Expr<t, q> (. astCond := astCur; astStmt := AST.NoNode;
- 1902                                             IF NOT SymTab.BoolCheck(t) THEN
- 1903                                               SemError(214) END;
- 1904                                             QbeGen.NewLabel(lThen);
- 1905                                             QbeGen.Jnz(q, lThen, lElse);
- 1906                                             QbeGen.EmitLabel(lThen); .)
- 1907          "THEN" [ StatSeq ]              (. astNode := AST.MakeNode(AST.NkIf);
- 1908                                             AST.SetChild(astNode, 0, astCond);
- 1909                                             AST.SetChild(astNode, 1, astStmt);
- 1910                                             AST.SetChild(astLast, 2, astNode);
- 1911                                             astLast := astNode;
- 1912                                             QbeGen.Jmp(lEnd); .) }
- 1913        [ "ELSE"                          (. QbeGen.EmitLabel(lElse);
- 1914                                             hasElse := TRUE;
- 1915                                             astStmt := AST.NoNode; .)
- 1916          [ StatSeq ] (. AST.SetChild(astLast, 2, astStmt); .) ]
- 1917        "END" (. astStmt := astIf;
- 1918                                             IF hasElse THEN
- 1919                                               QbeGen.EmitLabel(lEnd)
- 1920                                             ELSE QbeGen.EmitLabel(lElse);
- 1921                                               QbeGen.EmitLabel(lEnd)
- 1922                                             END; .) .
- 1923    WhileStat                             (. VAR t: SymTab.TypeIndex;
- 1924                                               q, lTop, lBody, lEnd:
- 1925                                                 QbeGen.QVal;
- 1926                                               astCond, astNode: AST.Node; .)
- 1927      = "WHILE" (. astStmt := AST.NoNode;
- 1928                                             QbeGen.NewLabel(lTop);
- 1929                                             QbeGen.NewLabel(lBody);
- 1930                                             QbeGen.NewLabel(lEnd);
- 1931                                             QbeGen.EmitLabel(lTop); .)
- 1932        Expr<t, q> (. astCond := astCur;
- 1933                                             IF NOT SymTab.BoolCheck(t) THEN
- 1934                                               SemError(214) END;
- 1935                                             QbeGen.Jnz(q, lBody, lEnd);
- 1936                                             QbeGen.EmitLabel(lBody); .)
- 1937        "DO" [ StatSeq ]                      (. astNode := AST.MakeNode(AST.NkWhile);
- 1938                                             AST.SetChild(astNode, 0, astCond);
- 1939                                             AST.SetChild(astNode, 1, astStmt);
- 1940                                             astStmt := astNode;
- 1941                                             QbeGen.Jmp(lTop); .)
- 1942        "END"                             (. QbeGen.EmitLabel(lEnd); .) .
- 1943    RepeatStat                            (. VAR t: SymTab.TypeIndex;
- 1944                                               q, lTop, lEnd: QbeGen.QVal;
- 1945                                               astCond, astBody, astNode:
- 1946                                                 AST.Node; .)
- 1947      = "REPEAT" (. astStmt := AST.NoNode;
- 1948                                             QbeGen.NewLabel(lTop);
- 1949                                             QbeGen.NewLabel(lEnd);
- 1950                                             QbeGen.EmitLabel(lTop); .)
- 1951        [ StatSeq ] (. astBody := astStmt; .)
- 1952        "UNTIL" Expr<t, q> (. astCond := astCur;
- 1953                                             astNode := AST.MakeNode(AST.NkRepeat);
- 1954                                             AST.SetChild(astNode, 0, astBody);
- 1955                                             AST.SetChild(astNode, 1, astCond);
- 1956                                             astStmt := astNode;
- 1957                                             IF NOT SymTab.BoolCheck(t) THEN
- 1958                                               SemError(214) END;
- 1959                                             QbeGen.Jnz(q, lEnd, lTop);
- 1960                                             QbeGen.EmitLabel(lEnd); .) .
- 1961    LoopStat                              (. VAR lTop, lEnd: QbeGen.QVal; astNode: AST.Node; .)
- 1962      = "LOOP"                            (. QbeGen.NewLabel(lTop);
- 1963                                                    astStmt := AST.NoNode;
- 1964                                             QbeGen.NewLabel(lEnd);
- 1965                                             QbeGen.PushLoop(lEnd);
- 1966                                             QbeGen.EmitLabel(lTop); .)
- 1967        [ StatSeq ]
- 1968        "END"                             (. astNode := AST.MakeNode(AST.NkLoop);
- 1969                                             AST.SetChild(astNode, 0, astStmt);
- 1970                                             astStmt := astNode;
- 1971                                             QbeGen.Jmp(lTop);
- 1972                                             QbeGen.PopLoop;
- 1973                                             QbeGen.EmitLabel(lEnd); .) .
- 1974    (* FOR with static-sign BY (literal, non-zero; 220 otherwise).
- 1975       Runtime direction would need a compare-select; the literal
- 1976       sign picks cslew/csegew at "DO" time. *)
- 1977    ForStat                               (. VAR lv: SymTab.Name;
- 1978                                               tlo, thi, tby:
- 1979                                                 SymTab.TypeIndex;
- 1980                                               qlo, qhi, qby, qt, qk, qb:
- 1981                                                 QbeGen.QVal;
- 1982                                               lTop, lBody, lEnd:
- 1983                                                 QbeGen.QVal;
- 1984                                               by: INTEGER;
- 1985                                               ok: BOOLEAN;
- 1986                                               astVar, astLo, astHi, astBy,
- 1987                                               astNode: AST.Node; .)
- 1988      = "FOR"                             (. by := 1; .)
- 1989        GetIdent<lv> (. astVar := AST.MakeLeaf(AST.NkIdent, lv);
- 1990                                             astStmt := AST.NoNode;
- 1991                                             astBy := AST.NoNode;
- 1992                                             ok := SymTab.Lookup(lv);
- 1993                                             IF NOT ok THEN
- 1994                                               SemError(201)
- 1995                                             ELSIF (SymTab.SymKind(lv) #
- 1996                                                    SymTab.KindVar)
- 1997   AND (SymTab.SymKind(lv) #
- 1998                                                   SymTab.KindParam) THEN
- 1999                                               SemError(220); ok := FALSE
- 2000                                             ELSIF NOT SymTab.IsIntFamily(
- 2001                                                     SymTab.SymType(lv)) THEN
+ 1842                                               ELSIF NOT QbeGen.CallArg(qa,
+ 1843                                                        "l") THEN
+ 1844                                                 SemError(233)
+ 1845                                               END
+ 1846                                             ELSE
+ 1847                                               IF (SymTab.ClassOf(at)
+ 1848                                                  = SymTab.ClChar)
+ 1849    AND (SymTab.ClassOf(ft) = SymTab.ClArray)
+ 1850    AND (SymTab.ClassOf(SymTab.ArrayElem(ft))
+ 1851         = SymTab.ClChar)
+ 1852    AND QbeGen.IsImm(qe) THEN
+ 1853                                                 (* 1-char string
+ 1854                                                    literal passed to
+ 1855                                                    ARRAY OF CHAR *)
+ 1856                                                 QbeGen.DeclCharStr(qe,
+ 1857                                                      qa);
+ 1858                                                 IF NOT QbeGen.CallArg(qa,
+ 1859                                                    "l") THEN
+ 1860                                                   SemError(233)
+ 1861                                                 END
+ 1862                                               ELSIF NOT SymTab.Assignable(at,
+ 1863                                                    ft) THEN
+ 1864                                                 SemError(233)
+ 1865                                               ELSE
+ 1866                                                 conv := (SymTab.ClassOf(
+ 1867                                                   ft) = SymTab.ClReal)
+ 1868   AND SymTab.IsIntFamily(at);
+ 1869                                                 IF conv THEN
+ 1870                                                   QbeGen.ConvIR(qe, qt);
+ 1871                                                   IF NOT QbeGen.CallArg(qt,
+ 1872                                                      "d") THEN
+ 1873                                                     SemError(233)
+ 1874                                                   END
+ 1875                                                 ELSIF NOT QbeGen.CallArg(qe,
+ 1876                                                   QbeGen.ArgClass(ft)) THEN
+ 1877                                                   SemError(233)
+ 1878                                                 END
+ 1879                                               END
+ 1880                                             END; .) .
+ 1881    IfStat                                (. VAR t: SymTab.TypeIndex;
+ 1882                                               q, lThen, lElse, lEnd:
+ 1883                                                 QbeGen.QVal;
+ 1884                                               hasElse: BOOLEAN;
+ 1885                                               astCond, astIf, astLast,
+ 1886                                               astNode: AST.Node; .)
+ 1887      = "IF" (. hasElse := FALSE; .)
+ 1888        Expr<t, q> (. astCond := astCur; astStmt := AST.NoNode;
+ 1889                                             IF NOT SymTab.BoolCheck(t) THEN
+ 1890                                               SemError(214) END;
+ 1891                                             QbeGen.NewLabel(lThen);
+ 1892                                             QbeGen.NewLabel(lElse);
+ 1893                                             QbeGen.NewLabel(lEnd);
+ 1894                                             QbeGen.Jnz(q, lThen, lElse);
+ 1895                                             QbeGen.EmitLabel(lThen); .)
+ 1896        "THEN" [ StatSeq ]                (. astNode := AST.MakeNode(AST.NkIf);
+ 1897                                             AST.SetChild(astNode, 0, astCond);
+ 1898                                             AST.SetChild(astNode, 1, astStmt);
+ 1899                                             astIf := astNode;
+ 1900                                             astLast := astNode;
+ 1901                                             QbeGen.Jmp(lEnd); .)
+ 1902        { "ELSIF"                         (. QbeGen.EmitLabel(lElse);
+ 1903                                             QbeGen.NewLabel(lElse); .)
+ 1904          Expr<t, q> (. astCond := astCur; astStmt := AST.NoNode;
+ 1905                                             IF NOT SymTab.BoolCheck(t) THEN
+ 1906                                               SemError(214) END;
+ 1907                                             QbeGen.NewLabel(lThen);
+ 1908                                             QbeGen.Jnz(q, lThen, lElse);
+ 1909                                             QbeGen.EmitLabel(lThen); .)
+ 1910          "THEN" [ StatSeq ]              (. astNode := AST.MakeNode(AST.NkIf);
+ 1911                                             AST.SetChild(astNode, 0, astCond);
+ 1912                                             AST.SetChild(astNode, 1, astStmt);
+ 1913                                             AST.SetChild(astLast, 2, astNode);
+ 1914                                             astLast := astNode;
+ 1915                                             QbeGen.Jmp(lEnd); .) }
+ 1916        [ "ELSE"                          (. QbeGen.EmitLabel(lElse);
+ 1917                                             hasElse := TRUE;
+ 1918                                             astStmt := AST.NoNode; .)
+ 1919          [ StatSeq ] (. AST.SetChild(astLast, 2, astStmt); .) ]
+ 1920        "END" (. astStmt := astIf;
+ 1921                                             IF hasElse THEN
+ 1922                                               QbeGen.EmitLabel(lEnd)
+ 1923                                             ELSE QbeGen.EmitLabel(lElse);
+ 1924                                               QbeGen.EmitLabel(lEnd)
+ 1925                                             END; .) .
+ 1926    WhileStat                             (. VAR t: SymTab.TypeIndex;
+ 1927                                               q, lTop, lBody, lEnd:
+ 1928                                                 QbeGen.QVal;
+ 1929                                               astCond, astNode: AST.Node; .)
+ 1930      = "WHILE" (. astStmt := AST.NoNode;
+ 1931                                             QbeGen.NewLabel(lTop);
+ 1932                                             QbeGen.NewLabel(lBody);
+ 1933                                             QbeGen.NewLabel(lEnd);
+ 1934                                             QbeGen.EmitLabel(lTop); .)
+ 1935        Expr<t, q> (. astCond := astCur;
+ 1936                                             IF NOT SymTab.BoolCheck(t) THEN
+ 1937                                               SemError(214) END;
+ 1938                                             QbeGen.Jnz(q, lBody, lEnd);
+ 1939                                             QbeGen.EmitLabel(lBody); .)
+ 1940        "DO" [ StatSeq ]                      (. astNode := AST.MakeNode(AST.NkWhile);
+ 1941                                             AST.SetChild(astNode, 0, astCond);
+ 1942                                             AST.SetChild(astNode, 1, astStmt);
+ 1943                                             astStmt := astNode;
+ 1944                                             QbeGen.Jmp(lTop); .)
+ 1945        "END"                             (. QbeGen.EmitLabel(lEnd); .) .
+ 1946    RepeatStat                            (. VAR t: SymTab.TypeIndex;
+ 1947                                               q, lTop, lEnd: QbeGen.QVal;
+ 1948                                               astCond, astBody, astNode:
+ 1949                                                 AST.Node; .)
+ 1950      = "REPEAT" (. astStmt := AST.NoNode;
+ 1951                                             QbeGen.NewLabel(lTop);
+ 1952                                             QbeGen.NewLabel(lEnd);
+ 1953                                             QbeGen.EmitLabel(lTop); .)
+ 1954        [ StatSeq ] (. astBody := astStmt; .)
+ 1955        "UNTIL" Expr<t, q> (. astCond := astCur;
+ 1956                                             astNode := AST.MakeNode(AST.NkRepeat);
+ 1957                                             AST.SetChild(astNode, 0, astBody);
+ 1958                                             AST.SetChild(astNode, 1, astCond);
+ 1959                                             astStmt := astNode;
+ 1960                                             IF NOT SymTab.BoolCheck(t) THEN
+ 1961                                               SemError(214) END;
+ 1962                                             QbeGen.Jnz(q, lEnd, lTop);
+ 1963                                             QbeGen.EmitLabel(lEnd); .) .
+ 1964    LoopStat                              (. VAR lTop, lEnd: QbeGen.QVal; astNode: AST.Node; .)
+ 1965      = "LOOP"                            (. QbeGen.NewLabel(lTop);
+ 1966                                                    astStmt := AST.NoNode;
+ 1967                                             QbeGen.NewLabel(lEnd);
+ 1968                                             QbeGen.PushLoop(lEnd);
+ 1969                                             QbeGen.EmitLabel(lTop); .)
+ 1970        [ StatSeq ]
+ 1971        "END"                             (. astNode := AST.MakeNode(AST.NkLoop);
+ 1972                                             AST.SetChild(astNode, 0, astStmt);
+ 1973                                             astStmt := astNode;
+ 1974                                             QbeGen.Jmp(lTop);
+ 1975                                             QbeGen.PopLoop;
+ 1976                                             QbeGen.EmitLabel(lEnd); .) .
+ 1977    (* FOR with static-sign BY (literal, non-zero; 220 otherwise).
+ 1978       Runtime direction would need a compare-select; the literal
+ 1979       sign picks cslew/csegew at "DO" time. *)
+ 1980    ForStat                               (. VAR lv: SymTab.Name;
+ 1981                                               tlo, thi, tby:
+ 1982                                                 SymTab.TypeIndex;
+ 1983                                               qlo, qhi, qby, qt, qk, qb:
+ 1984                                                 QbeGen.QVal;
+ 1985                                               lTop, lBody, lEnd:
+ 1986                                                 QbeGen.QVal;
+ 1987                                               by: INTEGER;
+ 1988                                               ok: BOOLEAN;
+ 1989                                               astVar, astLo, astHi, astBy,
+ 1990                                               astNode: AST.Node; .)
+ 1991      = "FOR"                             (. by := 1; .)
+ 1992        GetIdent<lv> (. astVar := AST.MakeLeaf(AST.NkIdent, lv);
+ 1993                                             astStmt := AST.NoNode;
+ 1994                                             astBy := AST.NoNode;
+ 1995                                             ok := SymTab.Lookup(lv);
+ 1996                                             IF NOT ok THEN
+ 1997                                               SemError(201)
+ 1998                                             ELSIF (SymTab.SymKind(lv) #
+ 1999                                                    SymTab.KindVar)
+ 2000   AND (SymTab.SymKind(lv) #
+ 2001                                                   SymTab.KindParam) THEN
  2002                                               SemError(220); ok := FALSE
- 2003                                             END; .)
- 2004        ":=" Expr<tlo, qlo> (. astLo := astCur;
- 2005                                             IF NOT SymTab.IsIntFamily(tlo) THEN
- 2006                                               SemError(220); ok := FALSE
- 2007                                             END; .)
- 2008        "TO" Expr<thi, qhi> (. astHi := astCur;
- 2009                                             IF NOT SymTab.IsIntFamily(thi) THEN
- 2010                                               SemError(220); ok := FALSE
- 2011                                             END; .)
- 2012        [ "BY" Expr<tby, qby> (. astBy := astCur;
- 2013                                             IF (tby #
- 2014                                               SymTab.InvalidType)
- 2015   AND NOT SymTab.IsIntFamily(tby) THEN
- 2016                                               SemError(220); ok := FALSE
- 2017                                             END;
- 2018                                             IF NOT SymTab.ConstInt(qby, by) THEN
- 2019                                               SemError(230); by := 1
- 2020                                             ELSIF by = 0 THEN
- 2021                                               SemError(220); by := 1
- 2022                                             END; .) ]
- 2023        "DO"                              (. IF ok THEN
- 2024                                               QbeGen.StoreVar(lv, qlo,
- 2025                                                 FALSE) END;
- 2026                                             QbeGen.NewLabel(lTop);
- 2027                                             QbeGen.NewLabel(lBody);
- 2028                                             QbeGen.NewLabel(lEnd);
- 2029                                             QbeGen.EmitLabel(lTop);
- 2030                                             QbeGen.LoadVar(lv, FALSE, qt);
- 2031                                             QbeGen.NewTemp(qk);
- 2032                                             IF by > 0 THEN
- 2033                                               QbeGen.Op3("cslew", qk,
- 2034                                                 qt, qhi, FALSE)
- 2035                                             ELSE QbeGen.Op3("csgew", qk,
- 2036                                               qt, qhi, FALSE)
- 2037                                             END;
- 2038                                             QbeGen.Jnz(qk, lBody, lEnd);
- 2039                                             QbeGen.EmitLabel(lBody); .)
- 2040        [ StatSeq ]
- 2041        "END" (. astNode := AST.MakeNode(AST.NkFor);
- 2042                                             AST.SetChild(astNode, 0, astVar);
- 2043                                             AST.SetChild(astNode, 1, astLo);
- 2044                                             AST.SetChild(astNode, 2, astHi);
- 2045                                             AST.SetChild(astNode, 3, astBy);
- 2046                                             AST.SetChild(astNode, 4, astStmt);
- 2047                                             astStmt := astNode;
- 2048                                             IF ok THEN
- 2049                                               QbeGen.LoadVar(lv, FALSE,
- 2050                                                 qt);
- 2051                                               QbeGen.IntStr(by, qb);
- 2052                                               QbeGen.NewTemp(qk);
- 2053                                               QbeGen.Op3("add", qk,
- 2054                                                 qt, qb, FALSE);
- 2055                                               QbeGen.StoreVar(lv, qk,
- 2056                                                 FALSE) END;
- 2057                                             QbeGen.Jmp(lTop);
- 2058                                             QbeGen.EmitLabel(lEnd); .) .
- 2059    CaseStat                              (. VAR tsel: SymTab.TypeIndex;
- 2060                                               qsel, lEnd: QbeGen.QVal;
- 2061                                               arm, astNode, astArms,
- 2062                                               astArmsTail: AST.Node; .)
- 2063      = "CASE" Expr<tsel, qsel>           (. astNode := AST.MakeNode(AST.NkCase);
- 2064                                             AST.SetChild(astNode, 0, astCur);
- 2065                                             astArms := AST.NoNode;
- 2066                                             astArmsTail := AST.NoNode;
- 2067                                             QbeGen.NewLabel(lEnd); .)
- 2068        "OF" CaseAlt<tsel, qsel, lEnd, astArms, astArmsTail>
- 2069        { "|" CaseAlt<tsel, qsel, lEnd, astArms, astArmsTail> }
- 2070        [ "ELSE"                          (. astStmt := AST.NoNode; .)
- 2071          [ StatSeq ]                     (. arm := AST.MakeNode(AST.NkCaseArm);
- 2072                                             AST.SetOp(arm, 1);
- 2073                                             AST.SetChild(arm, 0, astStmt);
- 2074                                             AstAppend(AST.NkBlock,
- 2075                                               astArms, astArmsTail, arm); .) ]
- 2076        "END"                             (. AST.SetChild(astNode, 1, astArms);
- 2077                                             astStmt := astNode;
- 2078                                             QbeGen.EmitLabel(lEnd); .) .
- 2079    (* Compare-chain lowering: each alternative ends its match-tests
- 2080       with "jmp lAfter", so the no-match fallthrough skips the body:
- 2081       "cmp; jnz(lBody,lF); lF: ... ; jmp lAfter; lBody: S; jmp lEnd;
- 2082       lAfter:". Falls into the next alternative, ELSE, or END. *)
- 2083    CaseAlt<tsel: SymTab.TypeIndex; qsel: QbeGen.QVal;
- 2084            lEnd: QbeGen.QVal; VAR arms, armsTail: AST.Node>
- 2085                                          (. VAR lBody, lAfter: QbeGen.QVal;
- 2086                                               arm: AST.Node; .)
- 2087      =                                   (. arm := AST.MakeNode(AST.NkCaseArm);
- 2088                                             QbeGen.NewLabel(lBody);
- 2089                                             QbeGen.NewLabel(lAfter); .)
- 2090        CaseLabel<tsel, qsel, lBody, arm>
- 2091        { "," CaseLabel<tsel, qsel, lBody, arm> }
- 2092        ":"                               (. astStmt := AST.NoNode;
- 2093                                             QbeGen.Jmp(lAfter);
- 2094                                             QbeGen.EmitLabel(lBody); .)
- 2095        [ StatSeq ]                       (. AST.SetChild(arm, AST.NChild(arm),
- 2096                                             astStmt);
- 2097                                             AstAppend(AST.NkBlock,
- 2098                                               arms, armsTail, arm);
- 2099                                             QbeGen.Jmp(lEnd);
- 2100                                             QbeGen.EmitLabel(lAfter); .) .
- 2101    CaseLabel<tsel: SymTab.TypeIndex; qsel: QbeGen.QVal;
- 2102              lBody: QbeGen.QVal; arm: AST.Node>
- 2103                                          (. VAR t2, t3: SymTab.TypeIndex;
- 2104                                               q2, q3, qc, qd, qe:
- 2105                                                 QbeGen.QVal;
- 2106                                               astLab: AST.Node;
- 2107                                               lNext: QbeGen.QVal; .)
- 2108      = Expr<t2, q2> (. astLab := astCur;
- 2109                                             IF (t2 #
- 2110                                               SymTab.InvalidType)
- 2111   AND (tsel #
- 2112                                                 SymTab.InvalidType)
- 2113   AND ((SymTab.ClassOf(t2) =
- 2114                                                  SymTab.ClSet)
- 2115                                                 OR (SymTab.ClassOf(tsel) =
- 2116                                                     SymTab.ClSet)) THEN
- 2117                                               SemError(230)
- 2118                                             ELSIF (t2 #
- 2119                                               SymTab.InvalidType)
- 2120   AND (tsel #
- 2121                                                 SymTab.InvalidType)
- 2122   AND NOT SymTab.EqCheck(t2,
- 2123                                                   tsel) THEN
- 2124                                               SemError(213) END;
- 2125                                             IF NOT QbeGen.IsImm(q2) THEN
- 2126                                               SemError(230);
- 2127                                               QbeGen.CopyOp("0", q2)
- 2128                                             END;
- 2129                                             QbeGen.NewLabel(lNext);
- 2130                                             QbeGen.Cmp(SymTab.OpEq,
- 2131                                               qsel, q2, qc, FALSE);
- 2132                                             QbeGen.Jnz(qc, lBody, lNext);
- 2133                                             QbeGen.EmitLabel(lNext); .)
- 2134        [ ".." Expr<t3, q3>               (. astLab := AST.MakeBin(
- 2135                                               AST.NkSubrange, 0, astLab, astCur);
- 2136                                             IF (t3 #
- 2137                                               SymTab.InvalidType)
- 2138   AND (tsel #
- 2139                                                 SymTab.InvalidType)
- 2140   AND NOT SymTab.EqCheck(t3,
- 2141                                                   tsel) THEN
- 2142                                               SemError(213) END;
- 2143                                             IF NOT QbeGen.IsImm(q3) THEN
- 2144                                               SemError(230);
- 2145                                               QbeGen.CopyOp("0", q3)
- 2146                                             END;
- 2147                                             QbeGen.Cmp(SymTab.OpGe,
- 2148                                               qsel, q2, qc, FALSE);
- 2149                                             QbeGen.Cmp(SymTab.OpLe,
- 2150                                               qsel, q3, qd, FALSE);
- 2151                                             QbeGen.NewTemp(qe);
- 2152                                             QbeGen.Op3("and", qe, qc, qd,
- 2153                                               FALSE);
- 2154                                             QbeGen.NewLabel(lNext);
- 2155                                             QbeGen.Jnz(qe, lBody, lNext);
- 2156                                             QbeGen.EmitLabel(lNext); .) ]
- 2157                                          (. AST.SetChild(arm,
- 2158                                               AST.NChild(arm), astLab); .) .
- 2159    ReturnStat                            (. VAR t: SymTab.TypeIndex;
- 2160                                               q, qt: QbeGen.QVal;
- 2161                                               res: SymTab.TypeIndex;
- 2162                                               hadE, conv: BOOLEAN;
- 2163                                               astVal, astNode: AST.Node; .)
- 2164      = "RETURN"                          (. hadE := FALSE; astStmt := AST.NoNode; .)
- 2165        [ Expr<t, q> (. hadE := TRUE; astVal := astCur; .) ]
- 2166                                          (. astNode := AST.MakeNode(AST.NkReturn);
- 2167                                             IF hadE THEN
- 2168                                               AST.SetChild(astNode, 0, astVal)
- 2169                                             END;
- 2170                                             astStmt := astNode;
- 2171                                             conv := FALSE;
- 2172                                             IF NOT SymTab.InProc() THEN
- 2173                                               SemError(232)
- 2174                                             ELSE res := SymTab.CurRes();
- 2175                                               IF NOT hadE THEN
- 2176                                                 IF res #
- 2177                                                    SymTab.InvalidType THEN
- 2178                                                   SemError(232)
- 2179                                                 ELSE QbeGen.EmitRet(q,
- 2180                                                   FALSE)
- 2181                                                 END
- 2182                                               ELSIF (res =
- 2183                                                      SymTab.InvalidType)
- 2184                                                  OR (t #
- 2185                                                      SymTab.InvalidType)
- 2186   AND NOT SymTab.Assignable(t,
- 2187                                                       res) THEN
- 2188                                                 SemError(232)
- 2189                                               ELSE
- 2190                                                 conv := (SymTab.ClassOf(
- 2191                                                   res) = SymTab.ClReal)
- 2192   AND SymTab.IsIntFamily(t);
- 2193                                                 IF conv THEN
- 2194                                                   QbeGen.ConvIR(q, qt);
- 2195                                                   QbeGen.EmitRet(qt, TRUE)
- 2196                                                 ELSE QbeGen.EmitRet(q, TRUE)
- 2197                                                 END
- 2198                                               END
- 2199                                             END; .) .
- 2200    HaltStat                              (. VAR t: SymTab.TypeIndex;
- 2201                                               q: QbeGen.QVal;
- 2202                                               astVal, astNode: AST.Node; .)
- 2203      = "HALT" (. astVal := AST.NoNode; .)
- 2204        [ "(" Expr<t, q> (. astVal := astCur; .) ")" ]
- 2205                                          (. astNode := AST.MakeNode(AST.NkHalt);
- 2206                                             IF astVal # AST.NoNode THEN
- 2207                                               AST.SetChild(astNode, 0, astVal)
- 2208                                             END;
- 2209                                             astStmt := astNode;
- 2210                                             QbeGen.HaltQ; .) .
- 2211    (* Designator: scalar loads, array addresses, and index suffixes.
- 2212       Each index descends one level (bounds-checked, trap on breach);
- 2213       nested levels reload the inner descriptor address. q ends as the
- 2214       value (scalars), the descriptor address (plain arrays), or the
- 2215       element address (indexed); sfx marks the indexed form. *)
- 2216    Design<VAR t: SymTab.TypeIndex; VAR k: INTEGER;
- 2217           VAR q: QbeGen.QVal; VAR qn: SymTab.Name; VAR sfx: BOOLEAN>
- 2218                                          (. VAR n, fn, mal: SymTab.Name;
- 2219                                               cls: INTEGER;
- 2220                                               ic: SymTab.TypeIndex;
- 2221                                               curT, it, eT, bt:
- 2222                                                 SymTab.TypeIndex;
- 2223                                               iq, ql, qlo, qhi, qe:
- 2224                                                 QbeGen.QVal;
- 2225                                               lo, hi: INTEGER;
- 2226                                               fo: INTEGER;
- 2227                                               isOpen: BOOLEAN;
- 2228                                               qb, cv: QbeGen.QVal;
- 2229                                               fid, fref, slot: INTEGER;
- 2230                                               r: BOOLEAN;
- 2231                                                astDes, astSel: AST.Node; .)
- 2232      = GetIdent<n>                       (. methCls := SymTab.InvalidType;
- 2233                                             QbeGen.CopyOp(n, qn);
- 2234                                             sfx := FALSE;
- 2235                                             fid := 0; fref := 0; slot := 0;
- 2236                                             IF NOT SymTab.Lookup(n) THEN
- 2237                                               (* a bare method name inside
- 2238                                                  a CLASS IMPLEMENTATION
- 2239                                                  is a sibling call on
- 2240                                                  THIS *)
- 2241                                               ic := SymTab.CurImplClass();
- 2242                                               IF (ic #
- 2243                                                  SymTab.InvalidType)
- 2244    AND SymTab.MethodExists(ic, n) THEN
- 2245                                                 sfx := FALSE;
- 2246                                                 QbeGen.ThisBase(q);
- 2247                                                 QbeGen.ArmRecv(q);
- 2248                                                 methCls := ic;
- 2249                                                 k := SymTab.KindProc;
- 2250                                                 t := SymTab.InvalidType
- 2251                                               ELSIF SymTab.InProc() THEN
- 2252                                                 (* not declared yet: a
- 2253                                                    forward reference to a
- 2254                                                    module-level variable
- 2255                                                    declared further down. *)
- 2256                                                 k := SymTab.KindVar;
- 2257                                                 r := SymTab.FwdVarRef(n, k,
- 2258                                                   fref, t);
- 2259                                                 slot := QbeGen.FwdDesignator();
- 2260                                                 FwdVarNote(fref, slot);
- 2261                                                 fid := slot;
- 2262                                                 QbeGen.FwdAddrOper(fid, q);
- 2263                                                 sfx := TRUE
- 2264                                               ELSE
- 2265                                                 SemError(201);
- 2266                                                 t :=
- 2267                                                   SymTab.InvalidType;
- 2268                                                 k := -1;
- 2269                                                 QbeGen.CopyOp("0", q)
- 2270                                               END
- 2271                                             ELSE
- 2272                                               t := SymTab.SymType(n);
- 2273                                               k := SymTab.SymKind(n);
- 2274                                               IF k = SymTab.KindConst THEN
- 2275                                                 IF SymTab.Equal(n,
- 2276                                                    "TRUE") THEN
- 2277                                                   t := SymTab.BoolType();
- 2278                                                   QbeGen.CopyOp("1", q)
- 2279                                                 ELSIF SymTab.Equal(n,
- 2280                                                    "FALSE") THEN
- 2281                                                   t := SymTab.BoolType();
- 2282                                                   QbeGen.CopyOp("0", q)
- 2283                                                 ELSIF SymTab.Equal(n,
- 2284                                                    "NIL") THEN
+ 2003                                             ELSIF NOT SymTab.IsIntFamily(
+ 2004                                                     SymTab.SymType(lv)) THEN
+ 2005                                               SemError(220); ok := FALSE
+ 2006                                             END; .)
+ 2007        ":=" Expr<tlo, qlo> (. astLo := astCur;
+ 2008                                             IF NOT SymTab.IsIntFamily(tlo) THEN
+ 2009                                               SemError(220); ok := FALSE
+ 2010                                             END; .)
+ 2011        "TO" Expr<thi, qhi> (. astHi := astCur;
+ 2012                                             IF NOT SymTab.IsIntFamily(thi) THEN
+ 2013                                               SemError(220); ok := FALSE
+ 2014                                             END; .)
+ 2015        [ "BY" Expr<tby, qby> (. astBy := astCur;
+ 2016                                             IF (tby #
+ 2017                                               SymTab.InvalidType)
+ 2018   AND NOT SymTab.IsIntFamily(tby) THEN
+ 2019                                               SemError(220); ok := FALSE
+ 2020                                             END;
+ 2021                                             IF NOT SymTab.ConstInt(qby, by) THEN
+ 2022                                               SemError(230); by := 1
+ 2023                                             ELSIF by = 0 THEN
+ 2024                                               SemError(220); by := 1
+ 2025                                             END; .) ]
+ 2026        "DO"                              (. IF ok THEN
+ 2027                                               QbeGen.StoreVar(lv, qlo,
+ 2028                                                 FALSE) END;
+ 2029                                             QbeGen.NewLabel(lTop);
+ 2030                                             QbeGen.NewLabel(lBody);
+ 2031                                             QbeGen.NewLabel(lEnd);
+ 2032                                             QbeGen.EmitLabel(lTop);
+ 2033                                             QbeGen.LoadVar(lv, FALSE, qt);
+ 2034                                             QbeGen.NewTemp(qk);
+ 2035                                             IF by > 0 THEN
+ 2036                                               QbeGen.Op3("cslew", qk,
+ 2037                                                 qt, qhi, FALSE)
+ 2038                                             ELSE QbeGen.Op3("csgew", qk,
+ 2039                                               qt, qhi, FALSE)
+ 2040                                             END;
+ 2041                                             QbeGen.Jnz(qk, lBody, lEnd);
+ 2042                                             QbeGen.EmitLabel(lBody); .)
+ 2043        [ StatSeq ]
+ 2044        "END" (. astNode := AST.MakeNode(AST.NkFor);
+ 2045                                             AST.SetChild(astNode, 0, astVar);
+ 2046                                             AST.SetChild(astNode, 1, astLo);
+ 2047                                             AST.SetChild(astNode, 2, astHi);
+ 2048                                             AST.SetChild(astNode, 3, astBy);
+ 2049                                             AST.SetChild(astNode, 4, astStmt);
+ 2050                                             astStmt := astNode;
+ 2051                                             IF ok THEN
+ 2052                                               QbeGen.LoadVar(lv, FALSE,
+ 2053                                                 qt);
+ 2054                                               QbeGen.IntStr(by, qb);
+ 2055                                               QbeGen.NewTemp(qk);
+ 2056                                               QbeGen.Op3("add", qk,
+ 2057                                                 qt, qb, FALSE);
+ 2058                                               QbeGen.StoreVar(lv, qk,
+ 2059                                                 FALSE) END;
+ 2060                                             QbeGen.Jmp(lTop);
+ 2061                                             QbeGen.EmitLabel(lEnd); .) .
+ 2062    CaseStat                              (. VAR tsel: SymTab.TypeIndex;
+ 2063                                               qsel, lEnd: QbeGen.QVal;
+ 2064                                               arm, astNode, astArms,
+ 2065                                               astArmsTail: AST.Node; .)
+ 2066      = "CASE" Expr<tsel, qsel>           (. astNode := AST.MakeNode(AST.NkCase);
+ 2067                                             AST.SetChild(astNode, 0, astCur);
+ 2068                                             astArms := AST.NoNode;
+ 2069                                             astArmsTail := AST.NoNode;
+ 2070                                             QbeGen.NewLabel(lEnd); .)
+ 2071        "OF" CaseAlt<tsel, qsel, lEnd, astArms, astArmsTail>
+ 2072        { "|" CaseAlt<tsel, qsel, lEnd, astArms, astArmsTail> }
+ 2073        [ "ELSE"                          (. astStmt := AST.NoNode; .)
+ 2074          [ StatSeq ]                     (. arm := AST.MakeNode(AST.NkCaseArm);
+ 2075                                             AST.SetOp(arm, 1);
+ 2076                                             AST.SetChild(arm, 0, astStmt);
+ 2077                                             AstAppend(AST.NkBlock,
+ 2078                                               astArms, astArmsTail, arm); .) ]
+ 2079        "END"                             (. AST.SetChild(astNode, 1, astArms);
+ 2080                                             astStmt := astNode;
+ 2081                                             QbeGen.EmitLabel(lEnd); .) .
+ 2082    (* Compare-chain lowering: each alternative ends its match-tests
+ 2083       with "jmp lAfter", so the no-match fallthrough skips the body:
+ 2084       "cmp; jnz(lBody,lF); lF: ... ; jmp lAfter; lBody: S; jmp lEnd;
+ 2085       lAfter:". Falls into the next alternative, ELSE, or END. *)
+ 2086    CaseAlt<tsel: SymTab.TypeIndex; qsel: QbeGen.QVal;
+ 2087            lEnd: QbeGen.QVal; VAR arms, armsTail: AST.Node>
+ 2088                                          (. VAR lBody, lAfter: QbeGen.QVal;
+ 2089                                               arm: AST.Node; .)
+ 2090      =                                   (. arm := AST.MakeNode(AST.NkCaseArm);
+ 2091                                             QbeGen.NewLabel(lBody);
+ 2092                                             QbeGen.NewLabel(lAfter); .)
+ 2093        CaseLabel<tsel, qsel, lBody, arm>
+ 2094        { "," CaseLabel<tsel, qsel, lBody, arm> }
+ 2095        ":"                               (. astStmt := AST.NoNode;
+ 2096                                             QbeGen.Jmp(lAfter);
+ 2097                                             QbeGen.EmitLabel(lBody); .)
+ 2098        [ StatSeq ]                       (. AST.SetChild(arm, AST.NChild(arm),
+ 2099                                             astStmt);
+ 2100                                             AstAppend(AST.NkBlock,
+ 2101                                               arms, armsTail, arm);
+ 2102                                             QbeGen.Jmp(lEnd);
+ 2103                                             QbeGen.EmitLabel(lAfter); .) .
+ 2104    CaseLabel<tsel: SymTab.TypeIndex; qsel: QbeGen.QVal;
+ 2105              lBody: QbeGen.QVal; arm: AST.Node>
+ 2106                                          (. VAR t2, t3: SymTab.TypeIndex;
+ 2107                                               q2, q3, qc, qd, qe:
+ 2108                                                 QbeGen.QVal;
+ 2109                                               astLab: AST.Node;
+ 2110                                               lNext: QbeGen.QVal; .)
+ 2111      = Expr<t2, q2> (. astLab := astCur;
+ 2112                                             IF (t2 #
+ 2113                                               SymTab.InvalidType)
+ 2114   AND (tsel #
+ 2115                                                 SymTab.InvalidType)
+ 2116   AND ((SymTab.ClassOf(t2) =
+ 2117                                                  SymTab.ClSet)
+ 2118                                                 OR (SymTab.ClassOf(tsel) =
+ 2119                                                     SymTab.ClSet)) THEN
+ 2120                                               SemError(230)
+ 2121                                             ELSIF (t2 #
+ 2122                                               SymTab.InvalidType)
+ 2123   AND (tsel #
+ 2124                                                 SymTab.InvalidType)
+ 2125   AND NOT SymTab.EqCheck(t2,
+ 2126                                                   tsel) THEN
+ 2127                                               SemError(213) END;
+ 2128                                             IF NOT QbeGen.IsImm(q2) THEN
+ 2129                                               SemError(230);
+ 2130                                               QbeGen.CopyOp("0", q2)
+ 2131                                             END;
+ 2132                                             QbeGen.NewLabel(lNext);
+ 2133                                             QbeGen.Cmp(SymTab.OpEq,
+ 2134                                               qsel, q2, qc, FALSE);
+ 2135                                             QbeGen.Jnz(qc, lBody, lNext);
+ 2136                                             QbeGen.EmitLabel(lNext); .)
+ 2137        [ ".." Expr<t3, q3>               (. astLab := AST.MakeBin(
+ 2138                                               AST.NkSubrange, 0, astLab, astCur);
+ 2139                                             IF (t3 #
+ 2140                                               SymTab.InvalidType)
+ 2141   AND (tsel #
+ 2142                                                 SymTab.InvalidType)
+ 2143   AND NOT SymTab.EqCheck(t3,
+ 2144                                                   tsel) THEN
+ 2145                                               SemError(213) END;
+ 2146                                             IF NOT QbeGen.IsImm(q3) THEN
+ 2147                                               SemError(230);
+ 2148                                               QbeGen.CopyOp("0", q3)
+ 2149                                             END;
+ 2150                                             QbeGen.Cmp(SymTab.OpGe,
+ 2151                                               qsel, q2, qc, FALSE);
+ 2152                                             QbeGen.Cmp(SymTab.OpLe,
+ 2153                                               qsel, q3, qd, FALSE);
+ 2154                                             QbeGen.NewTemp(qe);
+ 2155                                             QbeGen.Op3("and", qe, qc, qd,
+ 2156                                               FALSE);
+ 2157                                             QbeGen.NewLabel(lNext);
+ 2158                                             QbeGen.Jnz(qe, lBody, lNext);
+ 2159                                             QbeGen.EmitLabel(lNext); .) ]
+ 2160                                          (. AST.SetChild(arm,
+ 2161                                               AST.NChild(arm), astLab); .) .
+ 2162    ReturnStat                            (. VAR t: SymTab.TypeIndex;
+ 2163                                               q, qt: QbeGen.QVal;
+ 2164                                               res: SymTab.TypeIndex;
+ 2165                                               hadE, conv: BOOLEAN;
+ 2166                                               astVal, astNode: AST.Node; .)
+ 2167      = "RETURN"                          (. hadE := FALSE; astStmt := AST.NoNode; .)
+ 2168        [ Expr<t, q> (. hadE := TRUE; astVal := astCur; .) ]
+ 2169                                          (. astNode := AST.MakeNode(AST.NkReturn);
+ 2170                                             IF hadE THEN
+ 2171                                               AST.SetChild(astNode, 0, astVal)
+ 2172                                             END;
+ 2173                                             astStmt := astNode;
+ 2174                                             conv := FALSE;
+ 2175                                             IF NOT SymTab.InProc() THEN
+ 2176                                               SemError(232)
+ 2177                                             ELSE res := SymTab.CurRes();
+ 2178                                               IF NOT hadE THEN
+ 2179                                                 IF res #
+ 2180                                                    SymTab.InvalidType THEN
+ 2181                                                   SemError(232)
+ 2182                                                 ELSE QbeGen.EmitRet(q,
+ 2183                                                   FALSE)
+ 2184                                                 END
+ 2185                                               ELSIF (res =
+ 2186                                                      SymTab.InvalidType)
+ 2187                                                  OR (t #
+ 2188                                                      SymTab.InvalidType)
+ 2189   AND NOT SymTab.Assignable(t,
+ 2190                                                       res) THEN
+ 2191                                                 SemError(232)
+ 2192                                               ELSE
+ 2193                                                 conv := (SymTab.ClassOf(
+ 2194                                                   res) = SymTab.ClReal)
+ 2195   AND SymTab.IsIntFamily(t);
+ 2196                                                 IF conv THEN
+ 2197                                                   QbeGen.ConvIR(q, qt);
+ 2198                                                   QbeGen.EmitRet(qt, TRUE)
+ 2199                                                 ELSE QbeGen.EmitRet(q, TRUE)
+ 2200                                                 END
+ 2201                                               END
+ 2202                                             END; .) .
+ 2203    HaltStat                              (. VAR t: SymTab.TypeIndex;
+ 2204                                               q: QbeGen.QVal;
+ 2205                                               astVal, astNode: AST.Node; .)
+ 2206      = "HALT" (. astVal := AST.NoNode; .)
+ 2207        [ "(" Expr<t, q> (. astVal := astCur; .) ")" ]
+ 2208                                          (. astNode := AST.MakeNode(AST.NkHalt);
+ 2209                                             IF astVal # AST.NoNode THEN
+ 2210                                               AST.SetChild(astNode, 0, astVal)
+ 2211                                             END;
+ 2212                                             astStmt := astNode;
+ 2213                                             QbeGen.HaltQ; .) .
+ 2214    (* Designator: scalar loads, array addresses, and index suffixes.
+ 2215       Each index descends one level (bounds-checked, trap on breach);
+ 2216       nested levels reload the inner descriptor address. q ends as the
+ 2217       value (scalars), the descriptor address (plain arrays), or the
+ 2218       element address (indexed); sfx marks the indexed form. *)
+ 2219    Design<VAR t: SymTab.TypeIndex; VAR k: INTEGER;
+ 2220           VAR q: QbeGen.QVal; VAR qn: SymTab.Name; VAR sfx: BOOLEAN>
+ 2221                                          (. VAR n, fn, mal: SymTab.Name;
+ 2222                                               cls: INTEGER;
+ 2223                                               ic: SymTab.TypeIndex;
+ 2224                                               curT, it, eT, bt:
+ 2225                                                 SymTab.TypeIndex;
+ 2226                                               iq, ql, qlo, qhi, qe:
+ 2227                                                 QbeGen.QVal;
+ 2228                                               lo, hi: INTEGER;
+ 2229                                               fo: INTEGER;
+ 2230                                               isOpen: BOOLEAN;
+ 2231                                               qb, cv: QbeGen.QVal;
+ 2232                                               fid, fref, slot: INTEGER;
+ 2233                                               r: BOOLEAN;
+ 2234                                                astDes, astSel: AST.Node; .)
+ 2235      = GetIdent<n>                       (. methCls := SymTab.InvalidType;
+ 2236                                             QbeGen.CopyOp(n, qn);
+ 2237                                             sfx := FALSE;
+ 2238                                             fid := 0; fref := 0; slot := 0;
+ 2239                                             IF NOT SymTab.Lookup(n) THEN
+ 2240                                               (* a bare method name inside
+ 2241                                                  a CLASS IMPLEMENTATION
+ 2242                                                  is a sibling call on
+ 2243                                                  THIS *)
+ 2244                                               ic := SymTab.CurImplClass();
+ 2245                                               IF (ic #
+ 2246                                                  SymTab.InvalidType)
+ 2247    AND SymTab.MethodExists(ic, n) THEN
+ 2248                                                 sfx := FALSE;
+ 2249                                                 QbeGen.ThisBase(q);
+ 2250                                                 QbeGen.ArmRecv(q);
+ 2251                                                 methCls := ic;
+ 2252                                                 k := SymTab.KindProc;
+ 2253                                                 t := SymTab.InvalidType
+ 2254                                               ELSIF SymTab.InProc() THEN
+ 2255                                                 (* not declared yet: a
+ 2256                                                    forward reference to a
+ 2257                                                    module-level variable
+ 2258                                                    declared further down. *)
+ 2259                                                 k := SymTab.KindVar;
+ 2260                                                 r := SymTab.FwdVarRef(n, k,
+ 2261                                                   fref, t);
+ 2262                                                 slot := QbeGen.FwdDesignator();
+ 2263                                                 FwdVarNote(fref, slot);
+ 2264                                                 fid := slot;
+ 2265                                                 QbeGen.FwdAddrOper(fid, q);
+ 2266                                                 sfx := TRUE
+ 2267                                               ELSE
+ 2268                                                 SemError(201);
+ 2269                                                 t :=
+ 2270                                                   SymTab.InvalidType;
+ 2271                                                 k := -1;
+ 2272                                                 QbeGen.CopyOp("0", q)
+ 2273                                               END
+ 2274                                             ELSE
+ 2275                                               t := SymTab.SymType(n);
+ 2276                                               k := SymTab.SymKind(n);
+ 2277                                               IF k = SymTab.KindConst THEN
+ 2278                                                 IF SymTab.Equal(n,
+ 2279                                                    "TRUE") THEN
+ 2280                                                   t := SymTab.BoolType();
+ 2281                                                   QbeGen.CopyOp("1", q)
+ 2282                                                 ELSIF SymTab.Equal(n,
+ 2283                                                    "FALSE") THEN
+ 2284                                                   t := SymTab.BoolType();
  2285                                                   QbeGen.CopyOp("0", q)
- 2286                                                 ELSE
- 2287                                                   cls :=
- 2288                                                     SymTab.ClassOf(t);
- 2289                                                   IF (t #
- 2290                                                       SymTab.InvalidType)
- 2291   AND ((cls = SymTab.ClInt)
- 2292                                                      OR (cls
- 2293                                                          = SymTab.ClChar)
- 2294                                                      OR (cls
- 2295                                                          = SymTab.ClEnum)
- 2296                                                      OR (cls
- 2297                                                          = SymTab.ClReal)
- 2298                                                      OR (cls
- 2299                                                          = SymTab.ClLong)
- 2300                                                      OR (cls
- 2301                                                          = SymTab.ClNil)) THEN
- 2302                                                     IF cls = SymTab.ClNil THEN
- 2303                                                       QbeGen.CopyOp("0", q)
- 2304                                                     ELSIF ((cls
- 2305                                                         = SymTab.ClInt)
- 2306                                                       OR (cls
- 2307                                                         = SymTab.ClChar)
- 2308                                                       OR (cls
- 2309                                                         = SymTab.ClEnum)
- 2310                                                       OR (cls
- 2311                                                         = SymTab.ClLong))
- 2312    AND SymTab.GetSymVal(n, cv)
- 2313    AND QbeGen.IsImm(cv) THEN
- 2314                                                       QbeGen.CopyOp(cv, q)
- 2315                                                     ELSE
- 2316                                                       QbeGen.LoadVar(n,
- 2317                                                         cls = SymTab.ClReal,
- 2318                                                         q)
- 2319                                                     END
- 2320                                                   ELSIF (cls = SymTab.ClArray)
- 2321                                                      OR (cls = SymTab.ClRecord)
- 2322                                                      OR (cls = SymTab.ClClass)
- 2323                                                      OR (cls = SymTab.ClStr)
- 2324                                                      OR (cls = SymTab.ClUStr) THEN
- 2325                                                     (* aggregate constant:
- 2326                                                        its value IS the
- 2327                                                        descriptor address *)
- 2328                                                     IF SymTab.GetSymVal(n, cv) THEN
- 2329                                                       QbeGen.CopyOp(cv, q)
- 2330                                                     ELSE
- 2331                                                       QbeGen.CopyOp("0", q)
- 2332                                                     END
- 2333                                                   ELSE
- 2334                                                     IF t #
- 2335                                                        SymTab.InvalidType THEN
- 2336                                                       SemError(230)
- 2337                                                     END;
- 2338                                                     QbeGen.CopyOp("0", q)
- 2339                                                   END
- 2340                                                 END
- 2341                                               ELSIF (k = SymTab.KindVar)
- 2342                                                  OR (k = SymTab.KindParam) THEN
- 2343                                                 cls :=
- 2344                                                   SymTab.ClassOf(t);
- 2345                                                 IF (cls = SymTab.ClInt)
- 2346                                                    OR (cls = SymTab.ClBool)
- 2347                                                    OR (cls = SymTab.ClChar)
- 2348                                                    OR (cls = SymTab.ClUChar)
- 2349                                                    OR (cls = SymTab.ClEnum)
- 2350                                                    OR (cls
- 2351                                                        = SymTab.ClReal) THEN
- 2352                                                   QbeGen.LoadVar(n,
- 2353                                                     cls = SymTab.ClReal, q)
- 2354                                                 ELSIF (cls = SymTab.ClPtr)
- 2355                                                    OR (cls = SymTab.ClProc) THEN
- 2356                                                   QbeGen.LoadPtr(n, q)
- 2357                                                 ELSIF cls = SymTab.ClLong THEN
- 2358                                                   QbeGen.LoadLong(n, q)
- 2359                                                 ELSIF (cls
- 2360                                                         = SymTab.ClArray)
- 2361                                                    OR (cls
- 2362                                                        = SymTab.ClSet)
- 2363                                                    OR (cls
- 2364                                                        = SymTab.ClRecord)
- 2365                                                    OR (cls
- 2366                                                        = SymTab.ClUStr)
- 2367                                                    OR (cls
- 2368                                                        = SymTab.ClClass) THEN
- 2369                                                   QbeGen.AddrOf(n, q)
- 2370                                                 ELSE SemError(230);
- 2371                                                   QbeGen.CopyOp("0", q)
- 2372                                                 END
- 2373                                               ELSE QbeGen.CopyOp("0", q);
- 2374                                                 IF k = SymTab.KindImport THEN
- 2375                                                   SemError(230)
- 2376                                                 ELSIF k =
- 2377                                                    SymTab.KindProc THEN
- 2378                                                   (* bare procedure name:
- 2379                                                      a following ArgList
- 2380                                                      makes it a call;
- 2381                                                      otherwise Fact
- 2382                                                      reports 230 *)
- 2383                                                 ELSE
- 2384                                                   IF k = SymTab.KindField THEN
- 2385                                                     IF QbeGen.TopWith(qb) THEN
- 2386                                                       fo :=
- 2387                                                         SymTab.FieldOffset(
- 2388                                                         SymTab.FieldOwner(n),
- 2389                                                         n);
- 2390                                                       QbeGen.FieldAddr(qb,
- 2391                                                         fo, q);
- 2392                                                       sfx := TRUE
- 2393                                                     ELSE SemError(230);
- 2394                                                       QbeGen.CopyOp("0", q)
- 2395                                                     END
- 2396                                                   END
- 2397                                                 END
- 2398                                               END
- 2399                                             END; .)
- 2400        (. astDes := AST.MakeNode(AST.NkDesignator);
- 2401           AST.SetChild(astDes, AST.NChild(astDes), AST.MakeLeaf(AST.NkIdent, n)); .)
- 2402        { "[" Expr<it, iq>
- 2403                                          (. AST.SetChild(astDes, AST.NChild(astDes),
- 2404               AST.MakeUn(AST.NkSelector, AST.SelIndex, astCur)); IF t = SymTab.InvalidType THEN
- 2405                                             ELSIF SymTab.ClassOf(t) #
- 2406                                                   SymTab.ClArray THEN
- 2407                                               SemError(217);
- 2408                                               t := SymTab.InvalidType
- 2409                                             ELSIF NOT SymTab.IsIntFamily(it)
- 2410   AND (SymTab.ClassOf(it) #
- 2411                                                   SymTab.ClChar)
- 2412   AND (SymTab.ClassOf(it) #
- 2413                                                   SymTab.ClEnum) THEN
- 2414                                               SemError(218);
- 2415                                               t := SymTab.InvalidType
- 2416                                             ELSE
- 2417                                               QbeGen.WidenIndex(iq, ql);
- 2418                                               isOpen :=
- 2419                                                 SymTab.IsOpenArray(t);
- 2420                                               IF isOpen THEN
- 2421                                                 QbeGen.CopyOp("0", qlo);
- 2422                                                 IF SymTab.IsCharArray(t)
- 2423    OR SymTab.IsUCharArray(t) THEN
- 2424                                                   QbeGen.OpenHiChar(q, qhi)
- 2425                                                 ELSE QbeGen.OpenHi(q, qhi)
- 2426                                                 END
- 2427                                               ELSE
- 2428                                                 lo := SymTab.ArrayLo(t);
- 2429                                                 hi := SymTab.ArrayHi(t);
- 2430                                                 IF SymTab.IsCharArray(t)
- 2431    OR SymTab.IsUCharArray(t) THEN
- 2432                                                   hi := hi + 1
- 2433                                                 END;
- 2434                                                 QbeGen.IntStr(lo, qlo);
- 2435                                                 QbeGen.IntStr(hi, qhi)
- 2436                                               END;
- 2437                                               QbeGen.CheckRange(ql, qlo,
- 2438                                                 qhi);
- 2439                                               eT := SymTab.ArrayElem(t);
- 2440                                               QbeGen.ElemAddr(q, ql, qlo,
- 2441                                                 t, qe);
- 2442                                               IF SymTab.ClassOf(eT) =
- 2443                                                  SymTab.ClArray THEN
- 2444                                                 QbeGen.ElemLoad(qe, eT, q)
- 2445                                               ELSE QbeGen.CopyOp(qe, q)
- 2446                                               END;
- 2447                                               t := eT; sfx := TRUE
- 2448                                             END; .)
- 2449          { "," Expr<it, iq>
- 2450                                          (. AST.SetChild(astDes, AST.NChild(astDes),
- 2451               AST.MakeUn(AST.NkSelector, AST.SelIndex, astCur)); IF t = SymTab.InvalidType THEN
- 2452                                             ELSIF SymTab.ClassOf(t) #
- 2453                                                   SymTab.ClArray THEN
- 2454                                               SemError(217);
- 2455                                               t := SymTab.InvalidType
- 2456                                             ELSIF NOT SymTab.IsIntFamily(it)
- 2457   AND (SymTab.ClassOf(it) #
- 2458                                                   SymTab.ClChar)
- 2459   AND (SymTab.ClassOf(it) #
- 2460                                                   SymTab.ClEnum) THEN
- 2461                                               SemError(218);
- 2462                                               t := SymTab.InvalidType
- 2463                                             ELSE
- 2464                                               QbeGen.WidenIndex(iq, ql);
- 2465                                               isOpen :=
- 2466                                                 SymTab.IsOpenArray(t);
- 2467                                               IF isOpen THEN
- 2468                                                 QbeGen.CopyOp("0", qlo);
- 2469                                                 IF SymTab.IsCharArray(t)
- 2470    OR SymTab.IsUCharArray(t) THEN
- 2471                                                   QbeGen.OpenHiChar(q, qhi)
- 2472                                                 ELSE QbeGen.OpenHi(q, qhi)
- 2473                                                 END
- 2474                                               ELSE
- 2475                                                 lo := SymTab.ArrayLo(t);
- 2476                                                 hi := SymTab.ArrayHi(t);
- 2477                                                 IF SymTab.IsCharArray(t)
- 2478    OR SymTab.IsUCharArray(t) THEN
- 2479                                                   hi := hi + 1
- 2480                                                 END;
- 2481                                                 QbeGen.IntStr(lo, qlo);
- 2482                                                 QbeGen.IntStr(hi, qhi)
- 2483                                               END;
- 2484                                               QbeGen.CheckRange(ql, qlo,
- 2485                                                 qhi);
- 2486                                               eT := SymTab.ArrayElem(t);
- 2487                                               QbeGen.ElemAddr(q, ql, qlo,
- 2488                                                 t, qe);
- 2489                                               IF SymTab.ClassOf(eT) =
- 2490                                                  SymTab.ClArray THEN
- 2491                                                 QbeGen.ElemLoad(qe, eT, q)
- 2492                                               ELSE QbeGen.CopyOp(qe, q)
- 2493                                               END;
- 2494                                               t := eT; sfx := TRUE
- 2495                                             END; .) }
- 2496          "]"
- 2497        | "." GetIdent<fn>
- 2498                                          (. astSel := AST.MakeNode(AST.NkSelector);
- 2499               AST.SetOp(astSel, AST.SelField);
- 2500               AST.SetChild(astSel, 0, AST.MakeLeaf(AST.NkIdent, fn));
- 2501               AST.SetChild(astDes, AST.NChild(astDes), astSel); IF k = SymTab.KindModule THEN
- 2502                                               (* qualified L.x: materialize
- 2503                                                  the export, then load it *)
- 2504                                               IF NOT SymTab.MaterializeAlias(n,
- 2505                                                    fn, mal) THEN
- 2506                                                 SemError(201);
- 2507                                                 t := SymTab.InvalidType;
- 2508                                                 QbeGen.CopyOp("0", q)
- 2509                                               ELSE
- 2510                                                 QbeGen.CopyOp(mal, qn);
- 2511                                                 t := SymTab.SymType(mal);
- 2512                                                 k := SymTab.SymKind(mal);
- 2513                                                 sfx := FALSE;
- 2514                                                 IF k = SymTab.KindProc THEN
- 2515                                                   (* call: ArgList supplies
- 2516                                                      the value *)
- 2517                                                   QbeGen.CopyOp("0", q)
- 2518                                                 ELSIF NOT QbeGen.LoadDesignator(
- 2519                                                      mal, t, k, q) THEN
- 2520                                                   SemError(230);
- 2521                                                   QbeGen.CopyOp("0", q)
- 2522                                                 END
- 2523                                               END
- 2524                                             ELSIF t = SymTab.InvalidType THEN
- 2525                                             ELSIF (SymTab.ClassOf(t) #
- 2526                                                    SymTab.ClRecord)
- 2527   AND (SymTab.ClassOf(t) #
- 2528                                                   SymTab.ClClass) THEN
- 2529                                               SemError(215);
- 2530                                               t := SymTab.InvalidType
- 2531                                             ELSIF (SymTab.ClassOf(t) =
- 2532                                                    SymTab.ClClass)
- 2533    AND SymTab.MethodExists(t, fn) THEN
- 2534                                               (* obj.Method: bind the
- 2535                                                  method and pass obj as
- 2536                                                  the hidden receiver; q
- 2537                                                  already holds the
- 2538                                                  object's address *)
- 2539                                               QbeGen.ArmRecv(q);
- 2540                                               QbeGen.CopyOp(fn, n);
- 2541                                               QbeGen.CopyOp(fn, qn);
- 2542                                               methCls := t;
- 2543                                               k := SymTab.KindProc;
- 2544                                               t := SymTab.InvalidType
- 2545                                             ELSIF NOT SymTab.FieldExists(t,
- 2546                                                      fn) THEN
- 2547                                               SemError(216);
- 2548                                               t := SymTab.InvalidType
- 2549                                             ELSE
- 2550                                               fo := SymTab.FieldOffset(t,
- 2551                                                 fn);
- 2552                                               t := SymTab.FieldType(t, fn);
- 2553                                               QbeGen.FieldAddr(q, fo, qe);
- 2554                                               (* array fields are inline:
- 2555                                                  the field address is the
- 2556                                                  descriptor, like records *)
- 2557                                               QbeGen.CopyOp(qe, q);
- 2558                                               sfx := TRUE
- 2559                                             END; .)
- 2560        | "^"
- 2561                                          (. astSel := AST.MakeNode(AST.NkSelector);
- 2562               AST.SetOp(astSel, AST.SelDeref);
- 2563               AST.SetChild(astDes, AST.NChild(astDes), astSel); IF t = SymTab.InvalidType THEN
- 2564                                             ELSIF SymTab.ClassOf(t) #
- 2565                                                   SymTab.ClPtr THEN
- 2566                                               SemError(219);
- 2567                                               t := SymTab.InvalidType
- 2568                                             ELSE
- 2569                                               bt := SymTab.PtrBase(t);
- 2570                                               IF bt = SymTab.InvalidType THEN
- 2571                                               ELSE
- 2572                                                 IF sfx THEN
- 2573                                                   QbeGen.ElemLoad(q, t,
- 2574                                                     qb);
- 2575                                                   QbeGen.CopyOp(qb, q)
- 2576                                                 END;
- 2577                                                 t := bt;
- 2578                                                 (* q holds the pointee
- 2579                                                    address: Fact loads
- 2580                                                    scalars/pointers and uses
- 2581                                                    the address for
- 2582                                                    aggregates; the VAR-actual
- 2583                                                    note is q itself. *)
- 2584                                                 sfx := TRUE
- 2585                                               END
- 2586                                             END; .) } (. astCur := astDes; .) .
- 2587    (* Result suffix (ISO component after a function call): `F()^`,
- 2588       `F()[i]`, `F().field`.  The call result is in t/q with sfx FALSE
- 2589       (a value, or a descriptor address for aggregates); each component
- 2590       descends one level exactly like the Design components. *)
- 2591    ResultComp<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal;
- 2592               VAR sfx: BOOLEAN; VAR node: AST.Node>          (. VAR it, eT, bt: SymTab.TypeIndex;
- 2593                                               iq, ql, qlo, qhi, qe, qb:
- 2594                                                 QbeGen.QVal;
- 2595                                               lo, hi, fo: INTEGER;
- 2596                                               isOpen: BOOLEAN;
- 2597                                               fname: SymTab.Name;
- 2598                                               astWrap, astSel: AST.Node; .)
- 2599      = "[" Expr<it, iq>
- 2600                                          (. IF AST.Kind(node) # AST.NkDesignator THEN
- 2601                                               astWrap := AST.MakeNode(
- 2602                                                 AST.NkDesignator);
- 2603                                               AST.SetChild(astWrap, 0, node);
- 2604                                               node := astWrap
- 2605                                             END;
- 2606                                             AST.SetChild(node, AST.NChild(node),
- 2607                                               AST.MakeUn(AST.NkSelector,
- 2608                                                 AST.SelIndex, astCur)); IF t = SymTab.InvalidType THEN
- 2609                                             ELSIF SymTab.ClassOf(t) #
- 2610                                                   SymTab.ClArray THEN
- 2611                                               SemError(217);
- 2612                                               t := SymTab.InvalidType
- 2613                                             ELSIF NOT SymTab.IsIntFamily(it)
- 2614    AND (SymTab.ClassOf(it) # SymTab.ClChar)
- 2615    AND (SymTab.ClassOf(it) # SymTab.ClEnum) THEN
- 2616                                               SemError(218);
- 2617                                               t := SymTab.InvalidType
- 2618                                             ELSE
- 2619                                               QbeGen.WidenIndex(iq, ql);
- 2620                                               isOpen :=
- 2621                                                 SymTab.IsOpenArray(t);
- 2622                                               IF isOpen THEN
- 2623                                                 QbeGen.CopyOp("0", qlo);
- 2624                                                 IF SymTab.IsCharArray(t)
- 2625    OR SymTab.IsUCharArray(t) THEN
- 2626                                                   QbeGen.OpenHiChar(q, qhi)
- 2627                                                 ELSE QbeGen.OpenHi(q, qhi)
- 2628                                                 END
- 2629                                               ELSE
- 2630                                                 lo := SymTab.ArrayLo(t);
- 2631                                                 hi := SymTab.ArrayHi(t);
- 2632                                                 IF SymTab.IsCharArray(t)
- 2633    OR SymTab.IsUCharArray(t) THEN
- 2634                                                   hi := hi + 1
- 2635                                                 END;
- 2636                                                 QbeGen.IntStr(lo, qlo);
- 2637                                                 QbeGen.IntStr(hi, qhi)
- 2638                                               END;
- 2639                                               QbeGen.CheckRange(ql, qlo,
- 2640                                                 qhi);
- 2641                                               eT := SymTab.ArrayElem(t);
- 2642                                               QbeGen.ElemAddr(q, ql, qlo,
- 2643                                                 t, qe);
- 2644                                               IF SymTab.ClassOf(eT) =
- 2645                                                  SymTab.ClArray THEN
- 2646                                                 QbeGen.ElemLoad(qe, eT, q)
- 2647                                               ELSE QbeGen.CopyOp(qe, q)
- 2648                                               END;
- 2649                                               t := eT; sfx := TRUE
- 2650                                             END; .)
- 2651        "]"
- 2652      | "." GetIdent<fname>
- 2653                                          (. IF AST.Kind(node) # AST.NkDesignator THEN
- 2654                                               astWrap := AST.MakeNode(
- 2655                                                 AST.NkDesignator);
- 2656                                               AST.SetChild(astWrap, 0, node);
- 2657                                               node := astWrap
- 2658                                             END;
- 2659                                             AST.SetChild(node, AST.NChild(node),
- 2660                                               AST.MakeUn(AST.NkSelector,
- 2661                                                 AST.SelField,
- 2662                                                 AST.MakeLeaf(AST.NkIdent,
- 2663                                                   fname))); IF t = SymTab.InvalidType THEN
- 2664                                             ELSIF (SymTab.ClassOf(t) #
- 2665                                                    SymTab.ClRecord)
- 2666    AND (SymTab.ClassOf(t) # SymTab.ClClass) THEN
- 2667                                               SemError(215);
- 2668                                               t := SymTab.InvalidType
- 2669                                             ELSIF NOT SymTab.FieldExists(t,
- 2670                                                      fname) THEN
- 2671                                               SemError(216);
- 2672                                               t := SymTab.InvalidType
- 2673                                             ELSE
- 2674                                               fo := SymTab.FieldOffset(t,
- 2675                                                 fname);
- 2676                                               t := SymTab.FieldType(t, fname);
- 2677                                               QbeGen.FieldAddr(q, fo, qe);
- 2678                                               QbeGen.CopyOp(qe, q);
- 2679                                               sfx := TRUE
- 2680                                             END; .)
- 2681      | "^"                               (. IF AST.Kind(node) # AST.NkDesignator THEN
- 2682                                               astWrap := AST.MakeNode(
- 2683                                                 AST.NkDesignator);
- 2684                                               AST.SetChild(astWrap, 0, node);
- 2685                                               node := astWrap
- 2686                                             END;
- 2687                                             astSel := AST.MakeNode(AST.NkSelector);
- 2688                                             AST.SetOp(astSel, AST.SelDeref);
- 2689                                             AST.SetChild(node,
- 2690                                               AST.NChild(node), astSel); IF t = SymTab.InvalidType THEN
- 2691                                             ELSIF SymTab.ClassOf(t) #
- 2692                                                   SymTab.ClPtr THEN
- 2693                                               SemError(219);
- 2694                                               t := SymTab.InvalidType
- 2695                                             ELSE
- 2696                                               bt := SymTab.PtrBase(t);
- 2697                                               IF bt # SymTab.InvalidType THEN
- 2698                                                 IF sfx THEN
- 2699                                                   QbeGen.ElemLoad(q, t, qb);
- 2700                                                   QbeGen.CopyOp(qb, q)
- 2701                                                 END;
- 2702                                                 t := bt; sfx := TRUE
- 2703                                               END
- 2704                                             END; .) .
- 2705    Expr<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
- 2706                                          (. VAR t2: SymTab.TypeIndex;
- 2707                                               op: INTEGER;
- 2708                                               q2, qt, wl: QbeGen.QVal;
- 2709                                                astA, astB: AST.Node;
- 2710                                                astOp: INTEGER;
- 2711                                                astMade: BOOLEAN;
- 2712                                               isR: BOOLEAN; .)
- 2713      = SimExpr<t, q>                     (. astA := astCur; astMade := FALSE; .)
- 2714        [ Rel<op> SimExpr<t2, q2>
- 2715          (. astB := astCur; astMade := TRUE;
- 2716              astOp := AST.OpEq;
- 2717              IF op = SymTab.OpNeq1 THEN astOp := AST.OpNe
- 2718              ELSIF op = SymTab.OpNeq2 THEN astOp := AST.OpNe
- 2719              ELSIF op = SymTab.OpLt THEN astOp := AST.OpLt
- 2720              ELSIF op = SymTab.OpLe THEN astOp := AST.OpLe
- 2721              ELSIF op = SymTab.OpGt THEN astOp := AST.OpGt
- 2722              ELSIF op = SymTab.OpGe THEN astOp := AST.OpGe
- 2723              ELSIF op = SymTab.OpIn THEN astOp := AST.OpIn
- 2724              END;
- 2725              IF op = SymTab.OpIn THEN
- 2726               IF SymTab.InCheck(t, t2) THEN
- 2727                 IF (t = SymTab.InvalidType)
- 2728                    OR (t2 = SymTab.InvalidType) THEN
- 2729                   t := SymTab.BoolType(); QbeGen.CopyOp("0", q)
- 2730                 ELSE
- 2731                   QbeGen.InSet(q, q2, SymTab.SetBaseLo(t2),
- 2732                     SymTab.SetCount(t2), qt);
- 2733                   t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
- 2734                 END
- 2735               ELSE SemError(222); t := SymTab.InvalidType;
- 2736                 QbeGen.CopyOp("0", q)
- 2737               END
- 2738             ELSIF SymTab.RelCheck(t, t2, op) THEN
- 2739               IF (t = SymTab.InvalidType)
- 2740                  OR (t2 = SymTab.InvalidType) THEN
- 2741                 t := SymTab.BoolType(); QbeGen.CopyOp("0", q)
- 2742               ELSIF (SymTab.ClassOf(t) = SymTab.ClPtr)
- 2743                  OR (SymTab.ClassOf(t2) = SymTab.ClPtr) THEN
- 2744                 IF SymTab.IsFwdVar(t) OR SymTab.IsFwdVar(t2) THEN
- 2745                   QbeGen.Cmp(op, q, q2, qt, FALSE);
- 2746                   t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
- 2747                 ELSIF (op # SymTab.OpEq) AND (op # SymTab.OpNeq1)
- 2748   AND (op # SymTab.OpNeq2) THEN
- 2749                   SemError(213); t := SymTab.InvalidType;
- 2750                   QbeGen.CopyOp("0", q)
- 2751                 ELSE
- 2752                   QbeGen.CmpL(op, q, q2, qt);
- 2753                   t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
- 2754                 END
- 2755               ELSIF (SymTab.ClassOf(t) = SymTab.ClSet)
- 2756                  OR (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
- 2757                 QbeGen.CmpSet(op, q, q2,
- 2758                   SymTab.SetWords(t), SymTab.SetWords(t2), qt);
- 2759                 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
- 2760               ELSIF SymTab.StrCompat(t, t2) THEN
- 2761                 QbeGen.StrEq(op, q, q2, qt);
+ 2286                                                 ELSIF SymTab.Equal(n,
+ 2287                                                    "NIL") THEN
+ 2288                                                   QbeGen.CopyOp("0", q)
+ 2289                                                 ELSE
+ 2290                                                   cls :=
+ 2291                                                     SymTab.ClassOf(t);
+ 2292                                                   IF (t #
+ 2293                                                       SymTab.InvalidType)
+ 2294   AND ((cls = SymTab.ClInt)
+ 2295                                                      OR (cls
+ 2296                                                          = SymTab.ClChar)
+ 2297                                                      OR (cls
+ 2298                                                          = SymTab.ClEnum)
+ 2299                                                      OR (cls
+ 2300                                                          = SymTab.ClReal)
+ 2301                                                      OR (cls
+ 2302                                                          = SymTab.ClLong)
+ 2303                                                      OR (cls
+ 2304                                                          = SymTab.ClNil)) THEN
+ 2305                                                     IF cls = SymTab.ClNil THEN
+ 2306                                                       QbeGen.CopyOp("0", q)
+ 2307                                                     ELSIF ((cls
+ 2308                                                         = SymTab.ClInt)
+ 2309                                                       OR (cls
+ 2310                                                         = SymTab.ClChar)
+ 2311                                                       OR (cls
+ 2312                                                         = SymTab.ClEnum)
+ 2313                                                       OR (cls
+ 2314                                                         = SymTab.ClLong))
+ 2315    AND SymTab.GetSymVal(n, cv)
+ 2316    AND QbeGen.IsImm(cv) THEN
+ 2317                                                       QbeGen.CopyOp(cv, q)
+ 2318                                                     ELSE
+ 2319                                                       QbeGen.LoadVar(n,
+ 2320                                                         cls = SymTab.ClReal,
+ 2321                                                         q)
+ 2322                                                     END
+ 2323                                                   ELSIF (cls = SymTab.ClArray)
+ 2324                                                      OR (cls = SymTab.ClRecord)
+ 2325                                                      OR (cls = SymTab.ClClass)
+ 2326                                                      OR (cls = SymTab.ClStr)
+ 2327                                                      OR (cls = SymTab.ClUStr) THEN
+ 2328                                                     (* aggregate constant:
+ 2329                                                        its value IS the
+ 2330                                                        descriptor address *)
+ 2331                                                     IF SymTab.GetSymVal(n, cv) THEN
+ 2332                                                       QbeGen.CopyOp(cv, q)
+ 2333                                                     ELSE
+ 2334                                                       QbeGen.CopyOp("0", q)
+ 2335                                                     END
+ 2336                                                   ELSE
+ 2337                                                     IF t #
+ 2338                                                        SymTab.InvalidType THEN
+ 2339                                                       SemError(230)
+ 2340                                                     END;
+ 2341                                                     QbeGen.CopyOp("0", q)
+ 2342                                                   END
+ 2343                                                 END
+ 2344                                               ELSIF (k = SymTab.KindVar)
+ 2345                                                  OR (k = SymTab.KindParam) THEN
+ 2346                                                 cls :=
+ 2347                                                   SymTab.ClassOf(t);
+ 2348                                                 IF (cls = SymTab.ClInt)
+ 2349                                                    OR (cls = SymTab.ClBool)
+ 2350                                                    OR (cls = SymTab.ClChar)
+ 2351                                                    OR (cls = SymTab.ClUChar)
+ 2352                                                    OR (cls = SymTab.ClEnum)
+ 2353                                                    OR (cls
+ 2354                                                        = SymTab.ClReal) THEN
+ 2355                                                   QbeGen.LoadVar(n,
+ 2356                                                     cls = SymTab.ClReal, q)
+ 2357                                                 ELSIF (cls = SymTab.ClPtr)
+ 2358                                                    OR (cls = SymTab.ClProc) THEN
+ 2359                                                   QbeGen.LoadPtr(n, q)
+ 2360                                                 ELSIF cls = SymTab.ClLong THEN
+ 2361                                                   QbeGen.LoadLong(n, q)
+ 2362                                                 ELSIF (cls
+ 2363                                                         = SymTab.ClArray)
+ 2364                                                    OR (cls
+ 2365                                                        = SymTab.ClSet)
+ 2366                                                    OR (cls
+ 2367                                                        = SymTab.ClRecord)
+ 2368                                                    OR (cls
+ 2369                                                        = SymTab.ClUStr)
+ 2370                                                    OR (cls
+ 2371                                                        = SymTab.ClClass) THEN
+ 2372                                                   QbeGen.AddrOf(n, q)
+ 2373                                                 ELSE SemError(230);
+ 2374                                                   QbeGen.CopyOp("0", q)
+ 2375                                                 END
+ 2376                                               ELSE QbeGen.CopyOp("0", q);
+ 2377                                                 IF k = SymTab.KindImport THEN
+ 2378                                                   SemError(230)
+ 2379                                                 ELSIF k =
+ 2380                                                    SymTab.KindProc THEN
+ 2381                                                   (* bare procedure name:
+ 2382                                                      a following ArgList
+ 2383                                                      makes it a call;
+ 2384                                                      otherwise Fact
+ 2385                                                      reports 230 *)
+ 2386                                                 ELSE
+ 2387                                                   IF k = SymTab.KindField THEN
+ 2388                                                     IF QbeGen.TopWith(qb) THEN
+ 2389                                                       fo :=
+ 2390                                                         SymTab.FieldOffset(
+ 2391                                                         SymTab.FieldOwner(n),
+ 2392                                                         n);
+ 2393                                                       QbeGen.FieldAddr(qb,
+ 2394                                                         fo, q);
+ 2395                                                       sfx := TRUE
+ 2396                                                     ELSE SemError(230);
+ 2397                                                       QbeGen.CopyOp("0", q)
+ 2398                                                     END
+ 2399                                                   END
+ 2400                                                 END
+ 2401                                               END
+ 2402                                             END; .)
+ 2403        (. astDes := AST.MakeNode(AST.NkDesignator);
+ 2404           AST.SetChild(astDes, AST.NChild(astDes), AST.MakeLeaf(AST.NkIdent, n)); .)
+ 2405        { "[" Expr<it, iq>
+ 2406                                          (. AST.SetChild(astDes, AST.NChild(astDes),
+ 2407               AST.MakeUn(AST.NkSelector, AST.SelIndex, astCur)); IF t = SymTab.InvalidType THEN
+ 2408                                             ELSIF SymTab.ClassOf(t) #
+ 2409                                                   SymTab.ClArray THEN
+ 2410                                               SemError(217);
+ 2411                                               t := SymTab.InvalidType
+ 2412                                             ELSIF NOT SymTab.IsIntFamily(it)
+ 2413   AND (SymTab.ClassOf(it) #
+ 2414                                                   SymTab.ClChar)
+ 2415   AND (SymTab.ClassOf(it) #
+ 2416                                                   SymTab.ClEnum) THEN
+ 2417                                               SemError(218);
+ 2418                                               t := SymTab.InvalidType
+ 2419                                             ELSE
+ 2420                                               QbeGen.WidenIndex(iq, ql);
+ 2421                                               isOpen :=
+ 2422                                                 SymTab.IsOpenArray(t);
+ 2423                                               IF isOpen THEN
+ 2424                                                 QbeGen.CopyOp("0", qlo);
+ 2425                                                 IF SymTab.IsCharArray(t)
+ 2426    OR SymTab.IsUCharArray(t) THEN
+ 2427                                                   QbeGen.OpenHiChar(q, qhi)
+ 2428                                                 ELSE QbeGen.OpenHi(q, qhi)
+ 2429                                                 END
+ 2430                                               ELSE
+ 2431                                                 lo := SymTab.ArrayLo(t);
+ 2432                                                 hi := SymTab.ArrayHi(t);
+ 2433                                                 IF SymTab.IsCharArray(t)
+ 2434    OR SymTab.IsUCharArray(t) THEN
+ 2435                                                   hi := hi + 1
+ 2436                                                 END;
+ 2437                                                 QbeGen.IntStr(lo, qlo);
+ 2438                                                 QbeGen.IntStr(hi, qhi)
+ 2439                                               END;
+ 2440                                               QbeGen.CheckRange(ql, qlo,
+ 2441                                                 qhi);
+ 2442                                               eT := SymTab.ArrayElem(t);
+ 2443                                               QbeGen.ElemAddr(q, ql, qlo,
+ 2444                                                 t, qe);
+ 2445                                               IF SymTab.ClassOf(eT) =
+ 2446                                                  SymTab.ClArray THEN
+ 2447                                                 QbeGen.ElemLoad(qe, eT, q)
+ 2448                                               ELSE QbeGen.CopyOp(qe, q)
+ 2449                                               END;
+ 2450                                               t := eT; sfx := TRUE
+ 2451                                             END; .)
+ 2452          { "," Expr<it, iq>
+ 2453                                          (. AST.SetChild(astDes, AST.NChild(astDes),
+ 2454               AST.MakeUn(AST.NkSelector, AST.SelIndex, astCur)); IF t = SymTab.InvalidType THEN
+ 2455                                             ELSIF SymTab.ClassOf(t) #
+ 2456                                                   SymTab.ClArray THEN
+ 2457                                               SemError(217);
+ 2458                                               t := SymTab.InvalidType
+ 2459                                             ELSIF NOT SymTab.IsIntFamily(it)
+ 2460   AND (SymTab.ClassOf(it) #
+ 2461                                                   SymTab.ClChar)
+ 2462   AND (SymTab.ClassOf(it) #
+ 2463                                                   SymTab.ClEnum) THEN
+ 2464                                               SemError(218);
+ 2465                                               t := SymTab.InvalidType
+ 2466                                             ELSE
+ 2467                                               QbeGen.WidenIndex(iq, ql);
+ 2468                                               isOpen :=
+ 2469                                                 SymTab.IsOpenArray(t);
+ 2470                                               IF isOpen THEN
+ 2471                                                 QbeGen.CopyOp("0", qlo);
+ 2472                                                 IF SymTab.IsCharArray(t)
+ 2473    OR SymTab.IsUCharArray(t) THEN
+ 2474                                                   QbeGen.OpenHiChar(q, qhi)
+ 2475                                                 ELSE QbeGen.OpenHi(q, qhi)
+ 2476                                                 END
+ 2477                                               ELSE
+ 2478                                                 lo := SymTab.ArrayLo(t);
+ 2479                                                 hi := SymTab.ArrayHi(t);
+ 2480                                                 IF SymTab.IsCharArray(t)
+ 2481    OR SymTab.IsUCharArray(t) THEN
+ 2482                                                   hi := hi + 1
+ 2483                                                 END;
+ 2484                                                 QbeGen.IntStr(lo, qlo);
+ 2485                                                 QbeGen.IntStr(hi, qhi)
+ 2486                                               END;
+ 2487                                               QbeGen.CheckRange(ql, qlo,
+ 2488                                                 qhi);
+ 2489                                               eT := SymTab.ArrayElem(t);
+ 2490                                               QbeGen.ElemAddr(q, ql, qlo,
+ 2491                                                 t, qe);
+ 2492                                               IF SymTab.ClassOf(eT) =
+ 2493                                                  SymTab.ClArray THEN
+ 2494                                                 QbeGen.ElemLoad(qe, eT, q)
+ 2495                                               ELSE QbeGen.CopyOp(qe, q)
+ 2496                                               END;
+ 2497                                               t := eT; sfx := TRUE
+ 2498                                             END; .) }
+ 2499          "]"
+ 2500        | "." GetIdent<fn>
+ 2501                                          (. astSel := AST.MakeNode(AST.NkSelector);
+ 2502               AST.SetOp(astSel, AST.SelField);
+ 2503               AST.SetChild(astSel, 0, AST.MakeLeaf(AST.NkIdent, fn));
+ 2504               AST.SetChild(astDes, AST.NChild(astDes), astSel); IF k = SymTab.KindModule THEN
+ 2505                                               (* qualified L.x: materialize
+ 2506                                                  the export, then load it *)
+ 2507                                               IF NOT SymTab.MaterializeAlias(n,
+ 2508                                                    fn, mal) THEN
+ 2509                                                 SemError(201);
+ 2510                                                 t := SymTab.InvalidType;
+ 2511                                                 QbeGen.CopyOp("0", q)
+ 2512                                               ELSE
+ 2513                                                 QbeGen.CopyOp(mal, qn);
+ 2514                                                 t := SymTab.SymType(mal);
+ 2515                                                 k := SymTab.SymKind(mal);
+ 2516                                                 sfx := FALSE;
+ 2517                                                 IF k = SymTab.KindProc THEN
+ 2518                                                   (* call: ArgList supplies
+ 2519                                                      the value *)
+ 2520                                                   QbeGen.CopyOp("0", q)
+ 2521                                                 ELSIF NOT QbeGen.LoadDesignator(
+ 2522                                                      mal, t, k, q) THEN
+ 2523                                                   SemError(230);
+ 2524                                                   QbeGen.CopyOp("0", q)
+ 2525                                                 END
+ 2526                                               END
+ 2527                                             ELSIF t = SymTab.InvalidType THEN
+ 2528                                             ELSIF (SymTab.ClassOf(t) #
+ 2529                                                    SymTab.ClRecord)
+ 2530   AND (SymTab.ClassOf(t) #
+ 2531                                                   SymTab.ClClass) THEN
+ 2532                                               SemError(215);
+ 2533                                               t := SymTab.InvalidType
+ 2534                                             ELSIF (SymTab.ClassOf(t) =
+ 2535                                                    SymTab.ClClass)
+ 2536    AND SymTab.MethodExists(t, fn) THEN
+ 2537                                               (* obj.Method: bind the
+ 2538                                                  method and pass obj as
+ 2539                                                  the hidden receiver; q
+ 2540                                                  already holds the
+ 2541                                                  object's address *)
+ 2542                                               QbeGen.ArmRecv(q);
+ 2543                                               QbeGen.CopyOp(fn, n);
+ 2544                                               QbeGen.CopyOp(fn, qn);
+ 2545                                               methCls := t;
+ 2546                                               k := SymTab.KindProc;
+ 2547                                               t := SymTab.InvalidType
+ 2548                                             ELSIF NOT SymTab.FieldExists(t,
+ 2549                                                      fn) THEN
+ 2550                                               SemError(216);
+ 2551                                               t := SymTab.InvalidType
+ 2552                                             ELSE
+ 2553                                               fo := SymTab.FieldOffset(t,
+ 2554                                                 fn);
+ 2555                                               t := SymTab.FieldType(t, fn);
+ 2556                                               QbeGen.FieldAddr(q, fo, qe);
+ 2557                                               (* array fields are inline:
+ 2558                                                  the field address is the
+ 2559                                                  descriptor, like records *)
+ 2560                                               QbeGen.CopyOp(qe, q);
+ 2561                                               sfx := TRUE
+ 2562                                             END; .)
+ 2563        | "^"
+ 2564                                          (. astSel := AST.MakeNode(AST.NkSelector);
+ 2565               AST.SetOp(astSel, AST.SelDeref);
+ 2566               AST.SetChild(astDes, AST.NChild(astDes), astSel); IF t = SymTab.InvalidType THEN
+ 2567                                             ELSIF SymTab.ClassOf(t) #
+ 2568                                                   SymTab.ClPtr THEN
+ 2569                                               SemError(219);
+ 2570                                               t := SymTab.InvalidType
+ 2571                                             ELSE
+ 2572                                               bt := SymTab.PtrBase(t);
+ 2573                                               IF bt = SymTab.InvalidType THEN
+ 2574                                               ELSE
+ 2575                                                 IF sfx THEN
+ 2576                                                   QbeGen.ElemLoad(q, t,
+ 2577                                                     qb);
+ 2578                                                   QbeGen.CopyOp(qb, q)
+ 2579                                                 END;
+ 2580                                                 t := bt;
+ 2581                                                 (* q holds the pointee
+ 2582                                                    address: Fact loads
+ 2583                                                    scalars/pointers and uses
+ 2584                                                    the address for
+ 2585                                                    aggregates; the VAR-actual
+ 2586                                                    note is q itself. *)
+ 2587                                                 sfx := TRUE
+ 2588                                               END
+ 2589                                             END; .) } (. astCur := astDes; .) .
+ 2590    (* Result suffix (ISO component after a function call): `F()^`,
+ 2591       `F()[i]`, `F().field`.  The call result is in t/q with sfx FALSE
+ 2592       (a value, or a descriptor address for aggregates); each component
+ 2593       descends one level exactly like the Design components. *)
+ 2594    ResultComp<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal;
+ 2595               VAR sfx: BOOLEAN; VAR node: AST.Node>          (. VAR it, eT, bt: SymTab.TypeIndex;
+ 2596                                               iq, ql, qlo, qhi, qe, qb:
+ 2597                                                 QbeGen.QVal;
+ 2598                                               lo, hi, fo: INTEGER;
+ 2599                                               isOpen: BOOLEAN;
+ 2600                                               fname: SymTab.Name;
+ 2601                                               astWrap, astSel: AST.Node; .)
+ 2602      = "[" Expr<it, iq>
+ 2603                                          (. IF AST.Kind(node) # AST.NkDesignator THEN
+ 2604                                               astWrap := AST.MakeNode(
+ 2605                                                 AST.NkDesignator);
+ 2606                                               AST.SetChild(astWrap, 0, node);
+ 2607                                               node := astWrap
+ 2608                                             END;
+ 2609                                             AST.SetChild(node, AST.NChild(node),
+ 2610                                               AST.MakeUn(AST.NkSelector,
+ 2611                                                 AST.SelIndex, astCur)); IF t = SymTab.InvalidType THEN
+ 2612                                             ELSIF SymTab.ClassOf(t) #
+ 2613                                                   SymTab.ClArray THEN
+ 2614                                               SemError(217);
+ 2615                                               t := SymTab.InvalidType
+ 2616                                             ELSIF NOT SymTab.IsIntFamily(it)
+ 2617    AND (SymTab.ClassOf(it) # SymTab.ClChar)
+ 2618    AND (SymTab.ClassOf(it) # SymTab.ClEnum) THEN
+ 2619                                               SemError(218);
+ 2620                                               t := SymTab.InvalidType
+ 2621                                             ELSE
+ 2622                                               QbeGen.WidenIndex(iq, ql);
+ 2623                                               isOpen :=
+ 2624                                                 SymTab.IsOpenArray(t);
+ 2625                                               IF isOpen THEN
+ 2626                                                 QbeGen.CopyOp("0", qlo);
+ 2627                                                 IF SymTab.IsCharArray(t)
+ 2628    OR SymTab.IsUCharArray(t) THEN
+ 2629                                                   QbeGen.OpenHiChar(q, qhi)
+ 2630                                                 ELSE QbeGen.OpenHi(q, qhi)
+ 2631                                                 END
+ 2632                                               ELSE
+ 2633                                                 lo := SymTab.ArrayLo(t);
+ 2634                                                 hi := SymTab.ArrayHi(t);
+ 2635                                                 IF SymTab.IsCharArray(t)
+ 2636    OR SymTab.IsUCharArray(t) THEN
+ 2637                                                   hi := hi + 1
+ 2638                                                 END;
+ 2639                                                 QbeGen.IntStr(lo, qlo);
+ 2640                                                 QbeGen.IntStr(hi, qhi)
+ 2641                                               END;
+ 2642                                               QbeGen.CheckRange(ql, qlo,
+ 2643                                                 qhi);
+ 2644                                               eT := SymTab.ArrayElem(t);
+ 2645                                               QbeGen.ElemAddr(q, ql, qlo,
+ 2646                                                 t, qe);
+ 2647                                               IF SymTab.ClassOf(eT) =
+ 2648                                                  SymTab.ClArray THEN
+ 2649                                                 QbeGen.ElemLoad(qe, eT, q)
+ 2650                                               ELSE QbeGen.CopyOp(qe, q)
+ 2651                                               END;
+ 2652                                               t := eT; sfx := TRUE
+ 2653                                             END; .)
+ 2654        "]"
+ 2655      | "." GetIdent<fname>
+ 2656                                          (. IF AST.Kind(node) # AST.NkDesignator THEN
+ 2657                                               astWrap := AST.MakeNode(
+ 2658                                                 AST.NkDesignator);
+ 2659                                               AST.SetChild(astWrap, 0, node);
+ 2660                                               node := astWrap
+ 2661                                             END;
+ 2662                                             AST.SetChild(node, AST.NChild(node),
+ 2663                                               AST.MakeUn(AST.NkSelector,
+ 2664                                                 AST.SelField,
+ 2665                                                 AST.MakeLeaf(AST.NkIdent,
+ 2666                                                   fname))); IF t = SymTab.InvalidType THEN
+ 2667                                             ELSIF (SymTab.ClassOf(t) #
+ 2668                                                    SymTab.ClRecord)
+ 2669    AND (SymTab.ClassOf(t) # SymTab.ClClass) THEN
+ 2670                                               SemError(215);
+ 2671                                               t := SymTab.InvalidType
+ 2672                                             ELSIF NOT SymTab.FieldExists(t,
+ 2673                                                      fname) THEN
+ 2674                                               SemError(216);
+ 2675                                               t := SymTab.InvalidType
+ 2676                                             ELSE
+ 2677                                               fo := SymTab.FieldOffset(t,
+ 2678                                                 fname);
+ 2679                                               t := SymTab.FieldType(t, fname);
+ 2680                                               QbeGen.FieldAddr(q, fo, qe);
+ 2681                                               QbeGen.CopyOp(qe, q);
+ 2682                                               sfx := TRUE
+ 2683                                             END; .)
+ 2684      | "^"                               (. IF AST.Kind(node) # AST.NkDesignator THEN
+ 2685                                               astWrap := AST.MakeNode(
+ 2686                                                 AST.NkDesignator);
+ 2687                                               AST.SetChild(astWrap, 0, node);
+ 2688                                               node := astWrap
+ 2689                                             END;
+ 2690                                             astSel := AST.MakeNode(AST.NkSelector);
+ 2691                                             AST.SetOp(astSel, AST.SelDeref);
+ 2692                                             AST.SetChild(node,
+ 2693                                               AST.NChild(node), astSel); IF t = SymTab.InvalidType THEN
+ 2694                                             ELSIF SymTab.ClassOf(t) #
+ 2695                                                   SymTab.ClPtr THEN
+ 2696                                               SemError(219);
+ 2697                                               t := SymTab.InvalidType
+ 2698                                             ELSE
+ 2699                                               bt := SymTab.PtrBase(t);
+ 2700                                               IF bt # SymTab.InvalidType THEN
+ 2701                                                 IF sfx THEN
+ 2702                                                   QbeGen.ElemLoad(q, t, qb);
+ 2703                                                   QbeGen.CopyOp(qb, q)
+ 2704                                                 END;
+ 2705                                                 t := bt; sfx := TRUE
+ 2706                                               END
+ 2707                                             END; .) .
+ 2708    Expr<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
+ 2709                                          (. VAR t2: SymTab.TypeIndex;
+ 2710                                               op: INTEGER;
+ 2711                                               q2, qt, wl: QbeGen.QVal;
+ 2712                                                astA, astB: AST.Node;
+ 2713                                                astOp: INTEGER;
+ 2714                                                astMade: BOOLEAN;
+ 2715                                               isR: BOOLEAN; .)
+ 2716      = SimExpr<t, q>                     (. astA := astCur; astMade := FALSE; .)
+ 2717        [ Rel<op> SimExpr<t2, q2>
+ 2718          (. astB := astCur; astMade := TRUE;
+ 2719              astOp := AST.OpEq;
+ 2720              IF op = SymTab.OpNeq1 THEN astOp := AST.OpNe
+ 2721              ELSIF op = SymTab.OpNeq2 THEN astOp := AST.OpNe
+ 2722              ELSIF op = SymTab.OpLt THEN astOp := AST.OpLt
+ 2723              ELSIF op = SymTab.OpLe THEN astOp := AST.OpLe
+ 2724              ELSIF op = SymTab.OpGt THEN astOp := AST.OpGt
+ 2725              ELSIF op = SymTab.OpGe THEN astOp := AST.OpGe
+ 2726              ELSIF op = SymTab.OpIn THEN astOp := AST.OpIn
+ 2727              END;
+ 2728              IF op = SymTab.OpIn THEN
+ 2729               IF SymTab.InCheck(t, t2) THEN
+ 2730                 IF (t = SymTab.InvalidType)
+ 2731                    OR (t2 = SymTab.InvalidType) THEN
+ 2732                   t := SymTab.BoolType(); QbeGen.CopyOp("0", q)
+ 2733                 ELSE
+ 2734                   QbeGen.InSet(q, q2, SymTab.SetBaseLo(t2),
+ 2735                     SymTab.SetCount(t2), qt);
+ 2736                   t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
+ 2737                 END
+ 2738               ELSE SemError(222); t := SymTab.InvalidType;
+ 2739                 QbeGen.CopyOp("0", q)
+ 2740               END
+ 2741             ELSIF SymTab.RelCheck(t, t2, op) THEN
+ 2742               IF (t = SymTab.InvalidType)
+ 2743                  OR (t2 = SymTab.InvalidType) THEN
+ 2744                 t := SymTab.BoolType(); QbeGen.CopyOp("0", q)
+ 2745               ELSIF (SymTab.ClassOf(t) = SymTab.ClPtr)
+ 2746                  OR (SymTab.ClassOf(t2) = SymTab.ClPtr) THEN
+ 2747                 IF SymTab.IsFwdVar(t) OR SymTab.IsFwdVar(t2) THEN
+ 2748                   QbeGen.Cmp(op, q, q2, qt, FALSE);
+ 2749                   t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
+ 2750                 ELSIF (op # SymTab.OpEq) AND (op # SymTab.OpNeq1)
+ 2751   AND (op # SymTab.OpNeq2) THEN
+ 2752                   SemError(213); t := SymTab.InvalidType;
+ 2753                   QbeGen.CopyOp("0", q)
+ 2754                 ELSE
+ 2755                   QbeGen.CmpL(op, q, q2, qt);
+ 2756                   t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
+ 2757                 END
+ 2758               ELSIF (SymTab.ClassOf(t) = SymTab.ClSet)
+ 2759                  OR (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
+ 2760                 QbeGen.CmpSet(op, q, q2,
+ 2761                   SymTab.SetWords(t), SymTab.SetWords(t2), qt);
  2762                 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
- 2763               ELSIF SymTab.IsLongFamily(t)
- 2764                  OR SymTab.IsLongFamily(t2) THEN
- 2765                 IF SymTab.IsIntFamily(t) THEN
- 2766                   QbeGen.WidenLong(q, wl); QbeGen.CopyOp(wl, q)
- 2767                 END;
- 2768                 IF SymTab.IsIntFamily(t2) THEN
- 2769                   QbeGen.WidenLong(q2, wl); QbeGen.CopyOp(wl, q2)
+ 2763               ELSIF SymTab.StrCompat(t, t2) THEN
+ 2764                 QbeGen.StrEq(op, q, q2, qt);
+ 2765                 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
+ 2766               ELSIF SymTab.IsLongFamily(t)
+ 2767                  OR SymTab.IsLongFamily(t2) THEN
+ 2768                 IF SymTab.IsIntFamily(t) THEN
+ 2769                   QbeGen.WidenLong(q, wl); QbeGen.CopyOp(wl, q)
  2770                 END;
- 2771                 QbeGen.CmpLong(op, q, q2, qt);
- 2772                 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
- 2773               ELSE
- 2774                 isR := SymTab.ClassOf(t) = SymTab.ClReal;
- 2775                 t := SymTab.BoolType();
- 2776                 QbeGen.Cmp(op, q, q2, qt, isR);
- 2777                 QbeGen.CopyOp(qt, q)
- 2778               END
- 2779             ELSE SemError(213); t := SymTab.InvalidType;
- 2780                QbeGen.CopyOp("0", q)
- 2781              END;
- 2782              astCur := AST.MakeBin(AST.NkBinExpr, astOp, astA, astB); .) ]
- 2783         (. IF NOT astMade THEN astCur := astA END; .) .
- 2784    Rel<VAR op: INTEGER>
- 2785      = "="                               (. op := SymTab.OpEq; .)
- 2786      | "#"                               (. op := SymTab.OpNeq1; .)
- 2787      | "<"                               (. op := SymTab.OpLt; .)
- 2788      | "<="                              (. op := SymTab.OpLe; .)
- 2789      | ">"                               (. op := SymTab.OpGt; .)
- 2790      | ">="                              (. op := SymTab.OpGe; .)
- 2791      | "IN"                              (. op := SymTab.OpIn; .) .
- 2792    SimExpr<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
- 2793                                          (. VAR t2, res2, lt, rt:
- 2794                                                 SymTab.TypeIndex;
- 2795                                               op: INTEGER;
- 2796                                               q2, qt, wq, qf, q2a, q2b:
- 2797                                                 QbeGen.QVal;
- 2798                                               neg, isR, isL, folded:
- 2799                                                 BOOLEAN;
- 2800                                               fok: BOOLEAN;
- 2801                                               lw, rw, mw: CARDINAL;
- 2802                                               lTrue, lNext, lDone, qr, qs: QbeGen.QVal;
- 2803                                                astA, astB: AST.Node;
- 2804                                                astSign, astOp: INTEGER; .)
- 2805      =                                   (. neg := FALSE; astSign := 0; .)
- 2806        [ "+"                         (. neg := TRUE; astSign := 1; .)
- 2807        | "-"                         (. neg := TRUE; astSign := -1; .) ]
- 2808        Term<t, q> (. astA := astCur; IF neg THEN
- 2809                                             IF QbeGen.IsImm(q) THEN
- 2810                                               QbeGen.NegFold(q, q)
- 2811                                             ELSE QbeGen.NewTemp(qt);
- 2812                                               QbeGen.NegQ(q, qt,
- 2813                                                 SymTab.ClassOf(t)
- 2814                                                 = SymTab.ClReal);
- 2815                                               QbeGen.CopyOp(qt, q)
- 2816                                             END
- 2817                                           END;
- 2818                                           IF astSign < 0 THEN
- 2819                                             astCur := AST.MakeUn(
- 2820                                               AST.NkUnary, AST.OpSub, astA);
- 2821                                             astA := astCur
- 2822                                           END; .)
- 2823        { AddOp<op>                       (. IF op = SymTab.OpOr THEN
- 2824                                               QbeGen.DelayBegin END; .)
- 2825          Term<t2, q2> (. astB := astCur; IF op = SymTab.OpOr THEN
- 2826                                               QbeGen.DelayEnd END; .)
- 2827          (. astOp := AST.OpAdd;
- 2828             IF op = SymTab.OpSub THEN astOp := AST.OpSub
- 2829             ELSIF op = SymTab.OpOr THEN astOp := AST.OpOr END;
- 2830             astA := AST.MakeBin(AST.NkBinExpr, astOp, astA, astB);
- 2831             astCur := astA;
- 2832             IF op = SymTab.OpOr THEN
- 2833               (* short-circuit: if q is true the RHS is skipped *)
- 2834               IF SymTab.BoolCheck(t) AND SymTab.BoolCheck(t2) THEN
- 2835                 t := SymTab.BoolType()
- 2836               ELSE SemError(212); t := SymTab.InvalidType END;
- 2837               IF t # SymTab.InvalidType THEN
- 2838                 QbeGen.Slot4(qs);
- 2839                 QbeGen.NewLabel(lTrue);
- 2840                 QbeGen.NewLabel(lNext);
- 2841                 QbeGen.NewLabel(lDone);
- 2842                 QbeGen.Jnz(q, lTrue, lNext);
- 2843                 QbeGen.EmitLabel(lTrue);
- 2844                 QbeGen.StoreW(qs, "1");
- 2845                 QbeGen.Jmp(lDone);
- 2846                 QbeGen.EmitLabel(lNext);
- 2847                 QbeGen.DelayFlush;
- 2848                 QbeGen.StoreW(qs, q2);
- 2849                 QbeGen.Jmp(lDone);
- 2850                 QbeGen.EmitLabel(lDone);
- 2851                 QbeGen.LoadW(qs, qr);
- 2852                 QbeGen.CopyOp(qr, q)
- 2853               ELSE QbeGen.DelayFlush; QbeGen.CopyOp("0", q)
- 2854               END
- 2855             ELSIF (op = SymTab.OpAdd)
- 2856               AND (SymTab.UStrCompat(t, t2)
- 2857                 OR ((SymTab.ClassOf(t) = SymTab.ClUChar)
- 2858                   AND (SymTab.ClassOf(t2) = SymTab.ClUStr))
- 2859                 OR ((SymTab.ClassOf(t) = SymTab.ClUStr)
- 2860                   AND (SymTab.ClassOf(t2) = SymTab.ClUChar))
- 2861                 OR ((SymTab.ClassOf(t) = SymTab.ClUChar)
- 2862                   AND (SymTab.ClassOf(t2) = SymTab.ClUChar))) THEN
- 2863               (* UString concatenation: a UCHAR operand becomes a
- 2864                  1-codepoint UString; the result is a descriptor in the
- 2865                  shim's concat buffer.  Work on copies so neither
- 2866                  operand is clobbered. *)
- 2867               IF SymTab.ClassOf(t) = SymTab.ClUStr THEN
- 2868                 QbeGen.CopyOp(q, q2a)
- 2869               ELSE
- 2870                 QbeGen.UStrFrom(q, q2a)
- 2871               END;
- 2872               IF SymTab.ClassOf(t2) = SymTab.ClUStr THEN
- 2873                 QbeGen.UStrCat(q2a, q2, qt)
- 2874               ELSE
- 2875                 QbeGen.UStrFrom(q2, q2b);
- 2876                 QbeGen.UStrCat(q2a, q2b, qt)
- 2877               END;
- 2878               t := SymTab.NewUStr();
- 2879               QbeGen.CopyOp(qt, q)
- 2880             ELSIF (op = SymTab.OpAdd)
- 2881               AND (SymTab.StrCompat(t, t2)
- 2882                 OR (SymTab.IsStrType(t)
- 2883                   AND (SymTab.ClassOf(t2) = SymTab.ClChar))
- 2884                 OR ((SymTab.ClassOf(t) = SymTab.ClChar)
- 2885                   AND SymTab.IsStrType(t2))) THEN
- 2886               (* string concatenation; a CHAR operand becomes a
- 2887                  1-character string literal.  When both operands are
- 2888                  constants, fold to a single string literal so a
- 2889                  constructor element stays compile-time. *)
- 2890               QbeGen.StrFold(q, q2, SymTab.ClassOf(t), SymTab.ClassOf(t2),
- 2891                 qt, fok);
- 2892               IF NOT fok THEN
- 2893                 IF SymTab.StrCompat(t, t2) THEN
- 2894                   QbeGen.StrCat(q, q2, qt)
- 2895                 ELSIF SymTab.IsStrType(t) THEN
- 2896                   QbeGen.DeclCharStr(q2, qs);
- 2897                   QbeGen.StrCat(q, qs, qt)
- 2898                 ELSE
- 2899                   QbeGen.DeclCharStr(q, qs);
- 2900                   QbeGen.StrCat(qs, q2, qt)
- 2901                 END
- 2902               END;
- 2903               t := SymTab.NewStr();
- 2904               QbeGen.CopyOp(qt, q)
- 2905             ELSIF (t # SymTab.InvalidType) AND (t2 # SymTab.InvalidType)
- 2906   AND (SymTab.ClassOf(t) = SymTab.ClSet)
- 2907   AND (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
- 2908               lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
- 2909               mw := lw;
- 2910               IF rw > mw THEN mw := rw END;
- 2911               IF op = SymTab.OpAdd THEN
- 2912                 QbeGen.SetBinOp(0, q, q2, lw, rw, qt)
- 2913               ELSE
- 2914                 QbeGen.SetBinOp(2, q, q2, lw, rw, qt)
- 2915               END;
- 2916               t := SymTab.NewSet(
- 2917                      SymTab.NewSubR(0,
- 2918                        VAL(INTEGER, mw) * 32 - 1));
- 2919               QbeGen.CopyOp(qt, q)
- 2920             ELSE
- 2921               IF SymTab.ArithCheck(t, t2, FALSE, res2) THEN
- 2922                 lt := t; rt := t2; t := res2
- 2923               ELSE SemError(211); t := SymTab.InvalidType END;
- 2924               IF t # SymTab.InvalidType THEN
- 2925                 isL := SymTab.IsLongFamily(t);
- 2926                 isR := SymTab.ClassOf(t) = SymTab.ClReal;
- 2927                 folded := FALSE;
- 2928                 IF (NOT isL) AND (NOT isR)
- 2929    AND QbeGen.IsImm(q) AND QbeGen.IsImm(q2) THEN
- 2930                   IF op = SymTab.OpAdd THEN
- 2931                     folded := QbeGen.Fold2(0, q, q2, qf)
- 2932                   ELSE
- 2933                     folded := QbeGen.Fold2(1, q, q2, qf)
- 2934                   END
- 2935                 END;
- 2936                 IF folded THEN QbeGen.CopyOp(qf, q)
- 2937                 ELSE
- 2938                 IF isL THEN
- 2939                   IF SymTab.IsIntFamily(lt) THEN
- 2940                     QbeGen.WidenLong(q, wq); QbeGen.CopyOp(wq, q)
- 2941                   END;
- 2942                   IF SymTab.IsIntFamily(rt) THEN
- 2943                     QbeGen.WidenLong(q2, wq); QbeGen.CopyOp(wq, q2)
+ 2771                 IF SymTab.IsIntFamily(t2) THEN
+ 2772                   QbeGen.WidenLong(q2, wl); QbeGen.CopyOp(wl, q2)
+ 2773                 END;
+ 2774                 QbeGen.CmpLong(op, q, q2, qt);
+ 2775                 t := SymTab.BoolType(); QbeGen.CopyOp(qt, q)
+ 2776               ELSE
+ 2777                 isR := SymTab.ClassOf(t) = SymTab.ClReal;
+ 2778                 t := SymTab.BoolType();
+ 2779                 QbeGen.Cmp(op, q, q2, qt, isR);
+ 2780                 QbeGen.CopyOp(qt, q)
+ 2781               END
+ 2782             ELSE SemError(213); t := SymTab.InvalidType;
+ 2783                QbeGen.CopyOp("0", q)
+ 2784              END;
+ 2785              astCur := AST.MakeBin(AST.NkBinExpr, astOp, astA, astB); .) ]
+ 2786         (. IF NOT astMade THEN astCur := astA END; .) .
+ 2787    Rel<VAR op: INTEGER>
+ 2788      = "="                               (. op := SymTab.OpEq; .)
+ 2789      | "#"                               (. op := SymTab.OpNeq1; .)
+ 2790      | "<"                               (. op := SymTab.OpLt; .)
+ 2791      | "<="                              (. op := SymTab.OpLe; .)
+ 2792      | ">"                               (. op := SymTab.OpGt; .)
+ 2793      | ">="                              (. op := SymTab.OpGe; .)
+ 2794      | "IN"                              (. op := SymTab.OpIn; .) .
+ 2795    SimExpr<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
+ 2796                                          (. VAR t2, res2, lt, rt:
+ 2797                                                 SymTab.TypeIndex;
+ 2798                                               op: INTEGER;
+ 2799                                               q2, qt, wq, qf, q2a, q2b:
+ 2800                                                 QbeGen.QVal;
+ 2801                                               neg, isR, isL, folded:
+ 2802                                                 BOOLEAN;
+ 2803                                               fok: BOOLEAN;
+ 2804                                               lw, rw, mw: CARDINAL;
+ 2805                                               lTrue, lNext, lDone, qr, qs: QbeGen.QVal;
+ 2806                                                astA, astB: AST.Node;
+ 2807                                                astSign, astOp: INTEGER; .)
+ 2808      =                                   (. neg := FALSE; astSign := 0; .)
+ 2809        [ "+"                         (. neg := TRUE; astSign := 1; .)
+ 2810        | "-"                         (. neg := TRUE; astSign := -1; .) ]
+ 2811        Term<t, q> (. astA := astCur; IF neg THEN
+ 2812                                             IF QbeGen.IsImm(q) THEN
+ 2813                                               QbeGen.NegFold(q, q)
+ 2814                                             ELSE QbeGen.NewTemp(qt);
+ 2815                                               QbeGen.NegQ(q, qt,
+ 2816                                                 SymTab.ClassOf(t)
+ 2817                                                 = SymTab.ClReal);
+ 2818                                               QbeGen.CopyOp(qt, q)
+ 2819                                             END
+ 2820                                           END;
+ 2821                                           IF astSign < 0 THEN
+ 2822                                             astCur := AST.MakeUn(
+ 2823                                               AST.NkUnary, AST.OpSub, astA);
+ 2824                                             astA := astCur
+ 2825                                           END; .)
+ 2826        { AddOp<op>                       (. IF op = SymTab.OpOr THEN
+ 2827                                               QbeGen.DelayBegin END; .)
+ 2828          Term<t2, q2> (. astB := astCur; IF op = SymTab.OpOr THEN
+ 2829                                               QbeGen.DelayEnd END; .)
+ 2830          (. astOp := AST.OpAdd;
+ 2831             IF op = SymTab.OpSub THEN astOp := AST.OpSub
+ 2832             ELSIF op = SymTab.OpOr THEN astOp := AST.OpOr END;
+ 2833             astA := AST.MakeBin(AST.NkBinExpr, astOp, astA, astB);
+ 2834             astCur := astA;
+ 2835             IF op = SymTab.OpOr THEN
+ 2836               (* short-circuit: if q is true the RHS is skipped *)
+ 2837               IF SymTab.BoolCheck(t) AND SymTab.BoolCheck(t2) THEN
+ 2838                 t := SymTab.BoolType()
+ 2839               ELSE SemError(212); t := SymTab.InvalidType END;
+ 2840               IF t # SymTab.InvalidType THEN
+ 2841                 QbeGen.Slot4(qs);
+ 2842                 QbeGen.NewLabel(lTrue);
+ 2843                 QbeGen.NewLabel(lNext);
+ 2844                 QbeGen.NewLabel(lDone);
+ 2845                 QbeGen.Jnz(q, lTrue, lNext);
+ 2846                 QbeGen.EmitLabel(lTrue);
+ 2847                 QbeGen.StoreW(qs, "1");
+ 2848                 QbeGen.Jmp(lDone);
+ 2849                 QbeGen.EmitLabel(lNext);
+ 2850                 QbeGen.DelayFlush;
+ 2851                 QbeGen.StoreW(qs, q2);
+ 2852                 QbeGen.Jmp(lDone);
+ 2853                 QbeGen.EmitLabel(lDone);
+ 2854                 QbeGen.LoadW(qs, qr);
+ 2855                 QbeGen.CopyOp(qr, q)
+ 2856               ELSE QbeGen.DelayFlush; QbeGen.CopyOp("0", q)
+ 2857               END
+ 2858             ELSIF (op = SymTab.OpAdd)
+ 2859               AND (SymTab.UStrCompat(t, t2)
+ 2860                 OR ((SymTab.ClassOf(t) = SymTab.ClUChar)
+ 2861                   AND (SymTab.ClassOf(t2) = SymTab.ClUStr))
+ 2862                 OR ((SymTab.ClassOf(t) = SymTab.ClUStr)
+ 2863                   AND (SymTab.ClassOf(t2) = SymTab.ClUChar))
+ 2864                 OR ((SymTab.ClassOf(t) = SymTab.ClUChar)
+ 2865                   AND (SymTab.ClassOf(t2) = SymTab.ClUChar))) THEN
+ 2866               (* UString concatenation: a UCHAR operand becomes a
+ 2867                  1-codepoint UString; the result is a descriptor in the
+ 2868                  shim's concat buffer.  Work on copies so neither
+ 2869                  operand is clobbered. *)
+ 2870               IF SymTab.ClassOf(t) = SymTab.ClUStr THEN
+ 2871                 QbeGen.CopyOp(q, q2a)
+ 2872               ELSE
+ 2873                 QbeGen.UStrFrom(q, q2a)
+ 2874               END;
+ 2875               IF SymTab.ClassOf(t2) = SymTab.ClUStr THEN
+ 2876                 QbeGen.UStrCat(q2a, q2, qt)
+ 2877               ELSE
+ 2878                 QbeGen.UStrFrom(q2, q2b);
+ 2879                 QbeGen.UStrCat(q2a, q2b, qt)
+ 2880               END;
+ 2881               t := SymTab.NewUStr();
+ 2882               QbeGen.CopyOp(qt, q)
+ 2883             ELSIF (op = SymTab.OpAdd)
+ 2884               AND (SymTab.StrCompat(t, t2)
+ 2885                 OR (SymTab.IsStrType(t)
+ 2886                   AND (SymTab.ClassOf(t2) = SymTab.ClChar))
+ 2887                 OR ((SymTab.ClassOf(t) = SymTab.ClChar)
+ 2888                   AND SymTab.IsStrType(t2))) THEN
+ 2889               (* string concatenation; a CHAR operand becomes a
+ 2890                  1-character string literal.  When both operands are
+ 2891                  constants, fold to a single string literal so a
+ 2892                  constructor element stays compile-time. *)
+ 2893               QbeGen.StrFold(q, q2, SymTab.ClassOf(t), SymTab.ClassOf(t2),
+ 2894                 qt, fok);
+ 2895               IF NOT fok THEN
+ 2896                 IF SymTab.StrCompat(t, t2) THEN
+ 2897                   QbeGen.StrCat(q, q2, qt)
+ 2898                 ELSIF SymTab.IsStrType(t) THEN
+ 2899                   QbeGen.DeclCharStr(q2, qs);
+ 2900                   QbeGen.StrCat(q, qs, qt)
+ 2901                 ELSE
+ 2902                   QbeGen.DeclCharStr(q, qs);
+ 2903                   QbeGen.StrCat(qs, q2, qt)
+ 2904                 END
+ 2905               END;
+ 2906               t := SymTab.NewStr();
+ 2907               QbeGen.CopyOp(qt, q)
+ 2908             ELSIF (t # SymTab.InvalidType) AND (t2 # SymTab.InvalidType)
+ 2909   AND (SymTab.ClassOf(t) = SymTab.ClSet)
+ 2910   AND (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
+ 2911               lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
+ 2912               mw := lw;
+ 2913               IF rw > mw THEN mw := rw END;
+ 2914               IF op = SymTab.OpAdd THEN
+ 2915                 QbeGen.SetBinOp(0, q, q2, lw, rw, qt)
+ 2916               ELSE
+ 2917                 QbeGen.SetBinOp(2, q, q2, lw, rw, qt)
+ 2918               END;
+ 2919               t := SymTab.NewSet(
+ 2920                      SymTab.NewSubR(0,
+ 2921                        VAL(INTEGER, mw) * 32 - 1));
+ 2922               QbeGen.CopyOp(qt, q)
+ 2923             ELSE
+ 2924               IF SymTab.ArithCheck(t, t2, FALSE, res2) THEN
+ 2925                 lt := t; rt := t2; t := res2
+ 2926               ELSE SemError(211); t := SymTab.InvalidType END;
+ 2927               IF t # SymTab.InvalidType THEN
+ 2928                 isL := SymTab.IsLongFamily(t);
+ 2929                 isR := SymTab.ClassOf(t) = SymTab.ClReal;
+ 2930                 folded := FALSE;
+ 2931                 IF (NOT isL) AND (NOT isR)
+ 2932    AND QbeGen.IsImm(q) AND QbeGen.IsImm(q2) THEN
+ 2933                   IF op = SymTab.OpAdd THEN
+ 2934                     folded := QbeGen.Fold2(0, q, q2, qf)
+ 2935                   ELSE
+ 2936                     folded := QbeGen.Fold2(1, q, q2, qf)
+ 2937                   END
+ 2938                 END;
+ 2939                 IF folded THEN QbeGen.CopyOp(qf, q)
+ 2940                 ELSE
+ 2941                 IF isL THEN
+ 2942                   IF SymTab.IsIntFamily(lt) THEN
+ 2943                     QbeGen.WidenLong(q, wq); QbeGen.CopyOp(wq, q)
  2944                   END;
- 2945                   QbeGen.NewTemp(qt);
- 2946                   IF op = SymTab.OpAdd THEN
- 2947                     QbeGen.Op3L("add", qt, q, q2)
- 2948                   ELSE
- 2949                     QbeGen.Op3L("sub", qt, q, q2)
- 2950                   END
- 2951                 ELSE
- 2952                   QbeGen.NewTemp(qt);
- 2953                   IF op = SymTab.OpAdd THEN
- 2954                     QbeGen.Op3("add", qt, q, q2, isR)
- 2955                   ELSE
- 2956                     QbeGen.Op3("sub", qt, q, q2, isR)
- 2957                   END
- 2958                 END;
- 2959                 QbeGen.CopyOp(qt, q)
- 2960                 END
- 2961               ELSE QbeGen.CopyOp("0", q)
- 2962               END
- 2963             END; .) } .
- 2964    AddOp<VAR op: INTEGER>
- 2965      = "+"                               (. op := SymTab.OpAdd; .)
- 2966      | "-"                               (. op := SymTab.OpSub; .)
- 2967      | "OR"                              (. op := SymTab.OpOr; .) .
- 2968    Term<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
- 2969                                          (. VAR t2, res2, lt, rt:
- 2970                                                 SymTab.TypeIndex;
- 2971                                               op: INTEGER;
- 2972                                               q2, qt, wq, qf:
- 2973                                                 QbeGen.QVal;
- 2974                                               isR, isL, folded: BOOLEAN;
- 2975                                               lw, rw, mw: CARDINAL;
- 2976                                               lNext, lFalse, lDone, qr, qs: QbeGen.QVal;
- 2977                                                astA, astB: AST.Node;
- 2978                                                astOp: INTEGER; .)
- 2979      = Fact<t, q> (. astA := astCur; .) { MulOp<op>            (. IF op = SymTab.OpAnd THEN
- 2980                                               QbeGen.DelayBegin END; .)
- 2981          Fact<t2, q2> (. astB := astCur; IF op = SymTab.OpAnd THEN
- 2982                                                QbeGen.DelayEnd END; .)
- 2983        (. astOp := AST.OpMul;
- 2984           IF op = SymTab.OpSlash THEN astOp := AST.OpDiv
- 2985           ELSIF op = SymTab.OpDiv THEN astOp := AST.OpDiv
- 2986           ELSIF op = SymTab.OpMod THEN astOp := AST.OpMod
- 2987           ELSIF op = SymTab.OpAnd THEN astOp := AST.OpAnd END;
- 2988           astA := AST.MakeBin(AST.NkBinExpr, astOp, astA, astB);
- 2989           astCur := astA;
- 2990           IF op = SymTab.OpAnd THEN
- 2991             (* short-circuit: if q is false the RHS is skipped *)
- 2992             IF SymTab.BoolCheck(t) AND SymTab.BoolCheck(t2) THEN
- 2993               t := SymTab.BoolType()
- 2994             ELSE SemError(212); t := SymTab.InvalidType END;
- 2995             IF t # SymTab.InvalidType THEN
- 2996               QbeGen.Slot4(qs);
- 2997               QbeGen.NewLabel(lNext);
- 2998               QbeGen.NewLabel(lFalse);
- 2999               QbeGen.NewLabel(lDone);
- 3000               QbeGen.Jnz(q, lNext, lFalse);
- 3001               QbeGen.EmitLabel(lNext);
- 3002               QbeGen.DelayFlush;
- 3003               QbeGen.StoreW(qs, q2);
- 3004               QbeGen.Jmp(lDone);
- 3005               QbeGen.EmitLabel(lFalse);
- 3006               QbeGen.StoreW(qs, "0");
+ 2945                   IF SymTab.IsIntFamily(rt) THEN
+ 2946                     QbeGen.WidenLong(q2, wq); QbeGen.CopyOp(wq, q2)
+ 2947                   END;
+ 2948                   QbeGen.NewTemp(qt);
+ 2949                   IF op = SymTab.OpAdd THEN
+ 2950                     QbeGen.Op3L("add", qt, q, q2)
+ 2951                   ELSE
+ 2952                     QbeGen.Op3L("sub", qt, q, q2)
+ 2953                   END
+ 2954                 ELSE
+ 2955                   QbeGen.NewTemp(qt);
+ 2956                   IF op = SymTab.OpAdd THEN
+ 2957                     QbeGen.Op3("add", qt, q, q2, isR)
+ 2958                   ELSE
+ 2959                     QbeGen.Op3("sub", qt, q, q2, isR)
+ 2960                   END
+ 2961                 END;
+ 2962                 QbeGen.CopyOp(qt, q)
+ 2963                 END
+ 2964               ELSE QbeGen.CopyOp("0", q)
+ 2965               END
+ 2966             END; .) } .
+ 2967    AddOp<VAR op: INTEGER>
+ 2968      = "+"                               (. op := SymTab.OpAdd; .)
+ 2969      | "-"                               (. op := SymTab.OpSub; .)
+ 2970      | "OR"                              (. op := SymTab.OpOr; .) .
+ 2971    Term<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
+ 2972                                          (. VAR t2, res2, lt, rt:
+ 2973                                                 SymTab.TypeIndex;
+ 2974                                               op: INTEGER;
+ 2975                                               q2, qt, wq, qf:
+ 2976                                                 QbeGen.QVal;
+ 2977                                               isR, isL, folded: BOOLEAN;
+ 2978                                               lw, rw, mw: CARDINAL;
+ 2979                                               lNext, lFalse, lDone, qr, qs: QbeGen.QVal;
+ 2980                                                astA, astB: AST.Node;
+ 2981                                                astOp: INTEGER; .)
+ 2982      = Fact<t, q> (. astA := astCur; .) { MulOp<op>            (. IF op = SymTab.OpAnd THEN
+ 2983                                               QbeGen.DelayBegin END; .)
+ 2984          Fact<t2, q2> (. astB := astCur; IF op = SymTab.OpAnd THEN
+ 2985                                                QbeGen.DelayEnd END; .)
+ 2986        (. astOp := AST.OpMul;
+ 2987           IF op = SymTab.OpSlash THEN astOp := AST.OpDiv
+ 2988           ELSIF op = SymTab.OpDiv THEN astOp := AST.OpDiv
+ 2989           ELSIF op = SymTab.OpMod THEN astOp := AST.OpMod
+ 2990           ELSIF op = SymTab.OpAnd THEN astOp := AST.OpAnd END;
+ 2991           astA := AST.MakeBin(AST.NkBinExpr, astOp, astA, astB);
+ 2992           astCur := astA;
+ 2993           IF op = SymTab.OpAnd THEN
+ 2994             (* short-circuit: if q is false the RHS is skipped *)
+ 2995             IF SymTab.BoolCheck(t) AND SymTab.BoolCheck(t2) THEN
+ 2996               t := SymTab.BoolType()
+ 2997             ELSE SemError(212); t := SymTab.InvalidType END;
+ 2998             IF t # SymTab.InvalidType THEN
+ 2999               QbeGen.Slot4(qs);
+ 3000               QbeGen.NewLabel(lNext);
+ 3001               QbeGen.NewLabel(lFalse);
+ 3002               QbeGen.NewLabel(lDone);
+ 3003               QbeGen.Jnz(q, lNext, lFalse);
+ 3004               QbeGen.EmitLabel(lNext);
+ 3005               QbeGen.DelayFlush;
+ 3006               QbeGen.StoreW(qs, q2);
  3007               QbeGen.Jmp(lDone);
- 3008               QbeGen.EmitLabel(lDone);
- 3009               QbeGen.LoadW(qs, qr);
- 3010               QbeGen.CopyOp(qr, q)
- 3011             ELSE QbeGen.DelayFlush; QbeGen.CopyOp("0", q)
- 3012             END
- 3013           ELSIF (t # SymTab.InvalidType) AND (t2 # SymTab.InvalidType)
- 3014   AND (SymTab.ClassOf(t) = SymTab.ClSet)
- 3015   AND (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
- 3016             lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
- 3017             mw := lw;
- 3018             IF rw > mw THEN mw := rw END;
- 3019             IF op = SymTab.OpTimes THEN
- 3020               QbeGen.SetBinOp(1, q, q2, lw, rw, qt)
- 3021             ELSE
- 3022               QbeGen.SetBinOp(3, q, q2, lw, rw, qt)
- 3023             END;
- 3024             t := SymTab.NewSet(
- 3025                    SymTab.NewSubR(0,
- 3026                      VAL(INTEGER, mw) * 32 - 1));
- 3027             QbeGen.CopyOp(qt, q)
- 3028           ELSE
- 3029             IF SymTab.ArithCheck(t, t2,
- 3030                  (op = SymTab.OpDiv) OR (op = SymTab.OpMod),
- 3031                  res2) THEN
- 3032               lt := t; rt := t2; t := res2
- 3033             ELSE SemError(211); t := SymTab.InvalidType END;
- 3034             IF t # SymTab.InvalidType THEN
- 3035               isL := SymTab.IsLongFamily(t);
- 3036               isR := SymTab.ClassOf(t) = SymTab.ClReal;
- 3037               folded := FALSE;
- 3038               IF (NOT isL) AND (NOT isR)
- 3039    AND QbeGen.IsImm(q) AND QbeGen.IsImm(q2) THEN
- 3040                 IF op = SymTab.OpTimes THEN
- 3041                   folded := QbeGen.Fold2(2, q, q2, qf)
- 3042                 ELSIF op = SymTab.OpDiv THEN
- 3043                   folded := QbeGen.Fold2(3, q, q2, qf)
- 3044                 ELSIF op = SymTab.OpMod THEN
- 3045                   folded := QbeGen.Fold2(4, q, q2, qf)
- 3046                 END
- 3047               END;
- 3048               IF folded THEN QbeGen.CopyOp(qf, q)
- 3049               ELSE
- 3050               IF isL THEN
- 3051                 IF SymTab.IsIntFamily(lt) THEN
- 3052                   QbeGen.WidenLong(q, wq); QbeGen.CopyOp(wq, q)
- 3053                 END;
- 3054                 IF SymTab.IsIntFamily(rt) THEN
- 3055                   QbeGen.WidenLong(q2, wq); QbeGen.CopyOp(wq, q2)
+ 3008               QbeGen.EmitLabel(lFalse);
+ 3009               QbeGen.StoreW(qs, "0");
+ 3010               QbeGen.Jmp(lDone);
+ 3011               QbeGen.EmitLabel(lDone);
+ 3012               QbeGen.LoadW(qs, qr);
+ 3013               QbeGen.CopyOp(qr, q)
+ 3014             ELSE QbeGen.DelayFlush; QbeGen.CopyOp("0", q)
+ 3015             END
+ 3016           ELSIF (t # SymTab.InvalidType) AND (t2 # SymTab.InvalidType)
+ 3017   AND (SymTab.ClassOf(t) = SymTab.ClSet)
+ 3018   AND (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
+ 3019             lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
+ 3020             mw := lw;
+ 3021             IF rw > mw THEN mw := rw END;
+ 3022             IF op = SymTab.OpTimes THEN
+ 3023               QbeGen.SetBinOp(1, q, q2, lw, rw, qt)
+ 3024             ELSE
+ 3025               QbeGen.SetBinOp(3, q, q2, lw, rw, qt)
+ 3026             END;
+ 3027             t := SymTab.NewSet(
+ 3028                    SymTab.NewSubR(0,
+ 3029                      VAL(INTEGER, mw) * 32 - 1));
+ 3030             QbeGen.CopyOp(qt, q)
+ 3031           ELSE
+ 3032             IF SymTab.ArithCheck(t, t2,
+ 3033                  (op = SymTab.OpDiv) OR (op = SymTab.OpMod),
+ 3034                  res2) THEN
+ 3035               lt := t; rt := t2; t := res2
+ 3036             ELSE SemError(211); t := SymTab.InvalidType END;
+ 3037             IF t # SymTab.InvalidType THEN
+ 3038               isL := SymTab.IsLongFamily(t);
+ 3039               isR := SymTab.ClassOf(t) = SymTab.ClReal;
+ 3040               folded := FALSE;
+ 3041               IF (NOT isL) AND (NOT isR)
+ 3042    AND QbeGen.IsImm(q) AND QbeGen.IsImm(q2) THEN
+ 3043                 IF op = SymTab.OpTimes THEN
+ 3044                   folded := QbeGen.Fold2(2, q, q2, qf)
+ 3045                 ELSIF op = SymTab.OpDiv THEN
+ 3046                   folded := QbeGen.Fold2(3, q, q2, qf)
+ 3047                 ELSIF op = SymTab.OpMod THEN
+ 3048                   folded := QbeGen.Fold2(4, q, q2, qf)
+ 3049                 END
+ 3050               END;
+ 3051               IF folded THEN QbeGen.CopyOp(qf, q)
+ 3052               ELSE
+ 3053               IF isL THEN
+ 3054                 IF SymTab.IsIntFamily(lt) THEN
+ 3055                   QbeGen.WidenLong(q, wq); QbeGen.CopyOp(wq, q)
  3056                 END;
- 3057                 QbeGen.NewTemp(qt);
- 3058                 IF op = SymTab.OpTimes THEN
- 3059                   QbeGen.Op3L("mul", qt, q, q2)
- 3060                 ELSIF (op = SymTab.OpDiv)
- 3061                    OR (op = SymTab.OpSlash) THEN
- 3062                   QbeGen.Op3L("div", qt, q, q2)
- 3063                 ELSE
- 3064                   QbeGen.Op3L("rem", qt, q, q2)
- 3065                 END
- 3066               ELSE
- 3067                 QbeGen.NewTemp(qt);
- 3068                 IF op = SymTab.OpTimes THEN
- 3069                   QbeGen.Op3("mul", qt, q, q2, isR)
- 3070                 ELSIF (op = SymTab.OpDiv)
- 3071                    OR (op = SymTab.OpSlash) THEN
- 3072                   QbeGen.Op3("div", qt, q, q2, isR)
- 3073                 ELSE
- 3074                   QbeGen.Op3("rem", qt, q, q2, isR)
- 3075                 END
- 3076               END;
- 3077               QbeGen.CopyOp(qt, q)
- 3078               END
- 3079             ELSE QbeGen.CopyOp("0", q)
- 3080             END
- 3081           END; .) } .
- 3082    MulOp<VAR op: INTEGER>
- 3083      = "*"                               (. op := SymTab.OpTimes; .)
- 3084      | "/"                               (. op := SymTab.OpSlash; .)
- 3085      | "DIV"                             (. op := SymTab.OpDiv; .)
- 3086      | "MOD"                             (. op := SymTab.OpMod; .)
- 3087      | ( "AND" | "&" )                   (. op := SymTab.OpAnd; .) .
- 3088    Fact<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
- 3089                                          (. VAR s: ARRAY [0 .. 255] OF CHAR;
- 3090                                               et, dt, t2, st, ct2, et2:
- 3091                                                 SymTab.TypeIndex;
- 3092                                               dk: INTEGER;
- 3093                                               qd, q2, sq, qa, qm0, qr, qt:
- 3094                                                 QbeGen.QVal;
- 3095                                               qn, vn: SymTab.Name;
- 3096                                               vt: SymTab.TypeIndex;
- 3097                                               c1, c2: INTEGER;
- 3098                                               lo, hi: INTEGER;
- 3099                                               isMax: BOOLEAN;
- 3100                                               called, isHigh, sfx, isCh,
- 3101                                               isU, uok, isStr: BOOLEAN;
- 3102                                               ucp: INTEGER; astIsLit: BOOLEAN;
- 3103                                                astD: AST.Node;
- 3104                                                astCall: BOOLEAN;
- 3105                                                astNode, astNot: AST.Node;
- 3106                                                j: CARDINAL;
- 3107                                                astArg2: AST.Node;
- 3108                                                astBrace: AST.Node;
- 3109                                                astRes: AST.Node; .)
- 3110      = (. astIsLit := FALSE; .)
- 3111      ( integer                           (. LexString(s);
- 3112                                             QbeGen.NormInt(s, q); IF twoPhase THEN astIsLit := TRUE; astCur := AST.MakeLeaf(AST.NkIntLit, s) END;
- 3113                                             t := SymTab.IntType(); .)
- 3114      | charConst                         (. LexString(s);
- 3115                                             QbeGen.NormLit(s, q, isCh);
- 3116                                             IF twoPhase THEN
- 3117                                               astIsLit := TRUE;
- 3118                                               astCur := AST.MakeLeaf(
- 3119                                                 AST.NkCharLit, s)
- 3120                                             END;
- 3121                                             t := SymTab.CharType(); .)
- 3122      | real                              (. LexString(s);
- 3123                                             QbeGen.NormReal(s, q);
- 3124                                             IF twoPhase THEN
- 3125                                               astIsLit := TRUE;
- 3126                                               astCur := AST.MakeLeaf(
- 3127                                                 AST.NkRealLit, s)
- 3128                                             END;
- 3129                                             t := SymTab.RealType(); .)
- 3130      | string                            (. LexString(s);
- 3131                                             IF twoPhase THEN
- 3132                                               astIsLit := TRUE;
- 3133                                               astCur := AST.MakeLeaf(
- 3134                                                 AST.NkStrLit, s)
- 3135                                             END;
- 3136                                             IF SymTab.StrLen(s) = 3 THEN
- 3137                                               t := SymTab.CharType();
- 3138                                               QbeGen.IntStr(
- 3139                                                 QbeGen.CharVal(s), q)
- 3140                                             ELSE t := SymTab.NewStr();
- 3141                                               QbeGen.DeclStr(s, q);
- 3142                                               (* a literal's value IS its
- 3143                                                  static descriptor address *)
- 3144                                               QbeGen.NoteAddr(q, q)
- 3145                                             END; .)
- 3146      | ustring                           (. LexString(s);
- 3147                                             IF twoPhase THEN
- 3148                                               astIsLit := TRUE;
- 3149                                               astCur := AST.MakeLeaf(
- 3150                                                 AST.NkStrLit, s)
- 3151                                             END;
- 3152                                             QbeGen.DeclUStr(s, q, isU, ucp,
- 3153                                               uok);
- 3154                                             IF NOT uok THEN
- 3155                                               SemError(234);
- 3156                                               t := SymTab.InvalidType
- 3157                                             ELSIF isU THEN
- 3158                                               t := SymTab.UCharType();
- 3159                                               QbeGen.IntStr(ucp, q)
- 3160                                             ELSE
- 3161                                               t := SymTab.NewUStr();
- 3162                                               QbeGen.NoteAddr(q, q)
- 3163                                             END; .)
- 3164      | Design<dt, dk, qd, qn, sfx>       (. astD := astCur; astCall := FALSE; astBrace := AST.NoNode;
- 3165                                             astNArgs := 0; called := FALSE;
- 3166                                             t := dt;
- 3167                                             IF sfx THEN
- 3168                                               IF dt =
- 3169                                                  SymTab.InvalidType THEN
- 3170                                                 QbeGen.CopyOp("0", q)
- 3171                                               ELSIF (SymTab.ClassOf(dt) =
- 3172                                                      SymTab.ClRecord)
- 3173                                                  OR (SymTab.ClassOf(dt) =
- 3174                                                      SymTab.ClSet)
- 3175                                                  OR (SymTab.ClassOf(dt) =
- 3176                                                      SymTab.ClArray)
- 3177                                                  OR (SymTab.ClassOf(dt) =
- 3178                                                      SymTab.ClClass) THEN
- 3179                                                 QbeGen.CopyOp(qd, q)
- 3180                                               ELSE QbeGen.ElemLoad(qd, dt,
- 3181                                                 q)
- 3182                                               END
- 3183                                             ELSE QbeGen.CopyOp(qd, q)
- 3184                                             END;
- 3185                                             IF (dk = SymTab.KindVar)
- 3186                                                OR (dk = SymTab.KindParam)
- 3187                                                OR (dk =
- 3188                                                   SymTab.KindField) THEN
- 3189                                               IF sfx THEN
- 3190                                                 QbeGen.NoteAddr(q, qd)
- 3191                                               ELSE
- 3192                                                 QbeGen.AddrOf(qn, qa);
- 3193                                                 QbeGen.NoteAddr(q, qa)
- 3194                                               END
- 3195                                             ELSIF sfx
- 3196   AND (dt #
- 3197                                                   SymTab.InvalidType)
- 3198   AND ((SymTab.ClassOf(dt) =
- 3199                                                    SymTab.ClArray)
- 3200                                                   OR (SymTab.ClassOf(dt) =
- 3201                                                       SymTab.ClSet)
- 3202                                                   OR (SymTab.ClassOf(dt) =
- 3203                                                       SymTab.ClRecord)) THEN
- 3204                                               QbeGen.NoteAddr(qd, qd)
- 3205                                             END; .)
- 3206        [ TypedBraceLit<dt, q>            (. t := dt; astCall := TRUE;
- 3207                                               astBrace := astCur; .) ]
- 3208        [ ArgList<qn, dt, qd, TRUE, FALSE, methCls, ct2, q2, called>
- 3209                                          (. astCall := TRUE;
- 3210                                             astNode := AstCallNode(astD);
- 3211                                             astRes := astNode;
- 3212                                             t := ct2;
- 3213                                             QbeGen.CopyOp(q2, q);
- 3214                                             sfx := FALSE; .)
- 3215          { ResultComp<t, q, sfx, astRes> }
- 3216                                          (. IF sfx THEN
- 3217                                               IF t = SymTab.InvalidType THEN
- 3218                                                 QbeGen.CopyOp("0", q)
- 3219                                               ELSIF (SymTab.ClassOf(t) #
- 3220                                                      SymTab.ClRecord)
- 3221    AND (SymTab.ClassOf(t) # SymTab.ClSet)
- 3222    AND (SymTab.ClassOf(t) # SymTab.ClArray)
- 3223    AND (SymTab.ClassOf(t) # SymTab.ClClass) THEN
- 3224                                                 QbeGen.ElemLoad(q, t, q2);
- 3225                                                 QbeGen.CopyOp(q2, q)
- 3226                                               END
- 3227                                             END; .) ]
- 3228                                          (. IF called THEN
- 3229                                               astCur := astRes
- 3230                                             ELSIF astCall THEN
- 3231                                               astCur := astBrace
- 3232                                             ELSE astCur := astD
- 3233                                             END;
- 3234                                              astIsLit := TRUE;
- 3235                                              IF NOT called
- 3236   AND (dk = SymTab.KindProc) THEN
- 3237                                               (* bare zero-arg function
- 3238                                                  call (parentheses may be
- 3239                                                  omitted); a proper or
- 3240                                                  parameterised proc here
- 3241                                                  is 230 *)
- 3242                                               IF (SymTab.ProcNPar(qn) = 0)
- 3243   AND (SymTab.ProcRes(qn) #
- 3244                                                     SymTab.InvalidType) THEN
- 3245                                                 QbeGen.Mangled(qn,
- 3246                                                   SymTab.ProcUid(qn), qm0);
- 3247                                                 QbeGen.CallBegin(qm0,
- 3248                                                   SymTab.ProcRes(qn),
- 3249                                                   SymTab.ProcDepthOf(qn),
- 3250                                                   SymTab.IsExternal(qn));
- 3251                                                 QbeGen.CallEnd(TRUE, q);
- 3252                                                 t := SymTab.ProcRes(qn)
- 3253                                               ELSE
- 3254                                                 (* procedure used as a
- 3255                                                    value (assign to a
- 3256                                                    procedure variable):
- 3257                                                    its code address *)
- 3258                                                 t := SymTab.ProcTypeOf(qn);
- 3259                                                 QbeGen.Mangled(qn,
- 3260                                                   SymTab.ProcUid(qn), qm0);
- 3261                                                 QbeGen.ProcAddr(qm0, q)
- 3262                                               END
- 3263                                             END; .)
- 3264      | ( "HIGH"                          (. isHigh := TRUE; .)
- 3265        | ( "LEN" | "LENGTH" )            (. isHigh := FALSE; .) )
- 3266        "(" ( Design<dt, dk, qd, qn, sfx> (. isStr := FALSE;
- 3267                                              isU := FALSE; .)
- 3268            | string                       (. LexString(s); astCur := AST.MakeLeaf(AST.NkStrLit, s);
- 3269                                              isStr := TRUE;
- 3270                                              isU := FALSE;
- 3271                                              IF SymTab.StrLen(s) = 3 THEN
- 3272                                                dt := SymTab.CharType();
- 3273                                                QbeGen.IntStr(QbeGen.CharVal(s),
- 3274                                                  qd)
- 3275                                              ELSE
- 3276                                                dt := SymTab.NewStr();
- 3277                                                QbeGen.DeclStr(s, qd);
- 3278                                                QbeGen.NoteAddr(qd, qd)
- 3279                                              END;
- 3280                                              dk := -1;
- 3281                                              qn[0] := CHR(0); .)
- 3282            | ustring                      (. LexString(s); astCur := AST.MakeLeaf(AST.NkStrLit, s);
- 3283                                              QbeGen.DeclUStr(s, qd, isU, ucp,
- 3284                                                uok);
- 3285                                              isStr := FALSE;
- 3286                                              IF NOT uok THEN
- 3287                                                SemError(234);
- 3288                                                dt := SymTab.InvalidType
- 3289                                              ELSIF isU THEN
- 3290                                                (* one codepoint: a UCHAR;
- 3291                                                   LEN is 1, HIGH is 0 *)
- 3292                                                dt := SymTab.UCharType();
- 3293                                                QbeGen.IntStr(ucp, qd)
- 3294                                              ELSE
- 3295                                                dt := SymTab.NewUStr();
- 3296                                                QbeGen.NoteAddr(qd, qd)
- 3297                                              END;
- 3298                                              dk := -1;
- 3299                                              qn[0] := CHR(0); .) )
- 3300        ")"
- 3301                                          (. astNode := AST.MakeNode(AST.NkCall);
- 3302     IF isHigh THEN AST.SetChild(astNode, 0,
- 3303       AST.MakeLeaf(AST.NkIdent, "HIGH"))
- 3304     ELSE AST.SetChild(astNode, 0,
- 3305       AST.MakeLeaf(AST.NkIdent, "LEN")) END;
- 3306     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
- 3307     astCur := astNode; astIsLit := TRUE;
- 3308                                             IF (dt # SymTab.InvalidType)
- 3309    AND (SymTab.ClassOf(dt) = SymTab.ClUStr) THEN
- 3310                                               (* UString: the count is
- 3311                                                  the descriptor header *)
- 3312                                               IF isHigh THEN
- 3313                                                 QbeGen.UStrLen(qd, qr);
- 3314                                                 QbeGen.DecQ(qr)
- 3315                                               ELSE
- 3316                                                 QbeGen.UStrLen(qd, qr)
- 3317                                               END;
- 3318                                               t := SymTab.IntType();
- 3319                                               QbeGen.CopyOp(qr, q)
- 3320                                             ELSIF (dt # SymTab.InvalidType)
- 3321    AND (SymTab.ClassOf(dt) = SymTab.ClUChar) THEN
- 3322                                               (* single UCHAR codepoint *)
- 3323                                               IF isHigh THEN
- 3324                                                 QbeGen.CopyOp("0", qr)
- 3325                                               ELSE
- 3326                                                 QbeGen.CopyOp("1", qr)
- 3327                                               END;
- 3328                                               t := SymTab.IntType();
- 3329                                               QbeGen.CopyOp(qr, q)
- 3330                                             ELSIF isStr THEN
- 3331                                               (* fold: content length at
- 3332                                                  compile time *)
- 3333                                               IF SymTab.StrLen(s) = 3 THEN
- 3334                                                 c1 := 1
- 3335                                               ELSE
- 3336                                                 c1 :=
- 3337                                                   SymTab.StrLen(s) - 2
- 3338                                               END;
- 3339                                               IF isHigh THEN
- 3340                                                 DEC(c1)
+ 3057                 IF SymTab.IsIntFamily(rt) THEN
+ 3058                   QbeGen.WidenLong(q2, wq); QbeGen.CopyOp(wq, q2)
+ 3059                 END;
+ 3060                 QbeGen.NewTemp(qt);
+ 3061                 IF op = SymTab.OpTimes THEN
+ 3062                   QbeGen.Op3L("mul", qt, q, q2)
+ 3063                 ELSIF (op = SymTab.OpDiv)
+ 3064                    OR (op = SymTab.OpSlash) THEN
+ 3065                   QbeGen.Op3L("div", qt, q, q2)
+ 3066                 ELSE
+ 3067                   QbeGen.Op3L("rem", qt, q, q2)
+ 3068                 END
+ 3069               ELSE
+ 3070                 QbeGen.NewTemp(qt);
+ 3071                 IF op = SymTab.OpTimes THEN
+ 3072                   QbeGen.Op3("mul", qt, q, q2, isR)
+ 3073                 ELSIF (op = SymTab.OpDiv)
+ 3074                    OR (op = SymTab.OpSlash) THEN
+ 3075                   QbeGen.Op3("div", qt, q, q2, isR)
+ 3076                 ELSE
+ 3077                   QbeGen.Op3("rem", qt, q, q2, isR)
+ 3078                 END
+ 3079               END;
+ 3080               QbeGen.CopyOp(qt, q)
+ 3081               END
+ 3082             ELSE QbeGen.CopyOp("0", q)
+ 3083             END
+ 3084           END; .) } .
+ 3085    MulOp<VAR op: INTEGER>
+ 3086      = "*"                               (. op := SymTab.OpTimes; .)
+ 3087      | "/"                               (. op := SymTab.OpSlash; .)
+ 3088      | "DIV"                             (. op := SymTab.OpDiv; .)
+ 3089      | "MOD"                             (. op := SymTab.OpMod; .)
+ 3090      | ( "AND" | "&" )                   (. op := SymTab.OpAnd; .) .
+ 3091    Fact<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
+ 3092                                          (. VAR s: ARRAY [0 .. 255] OF CHAR;
+ 3093                                               et, dt, t2, st, ct2, et2:
+ 3094                                                 SymTab.TypeIndex;
+ 3095                                               dk: INTEGER;
+ 3096                                               qd, q2, sq, qa, qm0, qr, qt:
+ 3097                                                 QbeGen.QVal;
+ 3098                                               qn, vn: SymTab.Name;
+ 3099                                               vt: SymTab.TypeIndex;
+ 3100                                               c1, c2: INTEGER;
+ 3101                                               lo, hi: INTEGER;
+ 3102                                               isMax: BOOLEAN;
+ 3103                                               called, isHigh, sfx, isCh,
+ 3104                                               isU, uok, isStr: BOOLEAN;
+ 3105                                               ucp: INTEGER; astIsLit: BOOLEAN;
+ 3106                                                astD: AST.Node;
+ 3107                                                astCall: BOOLEAN;
+ 3108                                                astNode, astNot: AST.Node;
+ 3109                                                j: CARDINAL;
+ 3110                                                astArg2: AST.Node;
+ 3111                                                astBrace: AST.Node;
+ 3112                                                astRes: AST.Node; .)
+ 3113      = (. astIsLit := FALSE; .)
+ 3114      ( integer                           (. LexString(s);
+ 3115                                             QbeGen.NormInt(s, q); IF twoPhase THEN astIsLit := TRUE; astCur := AST.MakeLeaf(AST.NkIntLit, s) END;
+ 3116                                             t := SymTab.IntType(); .)
+ 3117      | charConst                         (. LexString(s);
+ 3118                                             QbeGen.NormLit(s, q, isCh);
+ 3119                                             IF twoPhase THEN
+ 3120                                               astIsLit := TRUE;
+ 3121                                               astCur := AST.MakeLeaf(
+ 3122                                                 AST.NkCharLit, s)
+ 3123                                             END;
+ 3124                                             t := SymTab.CharType(); .)
+ 3125      | real                              (. LexString(s);
+ 3126                                             QbeGen.NormReal(s, q);
+ 3127                                             IF twoPhase THEN
+ 3128                                               astIsLit := TRUE;
+ 3129                                               astCur := AST.MakeLeaf(
+ 3130                                                 AST.NkRealLit, s)
+ 3131                                             END;
+ 3132                                             t := SymTab.RealType(); .)
+ 3133      | string                            (. LexString(s);
+ 3134                                             IF twoPhase THEN
+ 3135                                               astIsLit := TRUE;
+ 3136                                               astCur := AST.MakeLeaf(
+ 3137                                                 AST.NkStrLit, s)
+ 3138                                             END;
+ 3139                                             IF SymTab.StrLen(s) = 3 THEN
+ 3140                                               t := SymTab.CharType();
+ 3141                                               QbeGen.IntStr(
+ 3142                                                 QbeGen.CharVal(s), q)
+ 3143                                             ELSE t := SymTab.NewStr();
+ 3144                                               QbeGen.DeclStr(s, q);
+ 3145                                               (* a literal's value IS its
+ 3146                                                  static descriptor address *)
+ 3147                                               QbeGen.NoteAddr(q, q)
+ 3148                                             END; .)
+ 3149      | ustring                           (. LexString(s);
+ 3150                                             IF twoPhase THEN
+ 3151                                               astIsLit := TRUE;
+ 3152                                               astCur := AST.MakeLeaf(
+ 3153                                                 AST.NkStrLit, s)
+ 3154                                             END;
+ 3155                                             QbeGen.DeclUStr(s, q, isU, ucp,
+ 3156                                               uok);
+ 3157                                             IF NOT uok THEN
+ 3158                                               SemError(234);
+ 3159                                               t := SymTab.InvalidType
+ 3160                                             ELSIF isU THEN
+ 3161                                               t := SymTab.UCharType();
+ 3162                                               QbeGen.IntStr(ucp, q)
+ 3163                                             ELSE
+ 3164                                               t := SymTab.NewUStr();
+ 3165                                               QbeGen.NoteAddr(q, q)
+ 3166                                             END; .)
+ 3167      | Design<dt, dk, qd, qn, sfx>       (. astD := astCur; astCall := FALSE; astBrace := AST.NoNode;
+ 3168                                             astNArgs := 0; called := FALSE;
+ 3169                                             t := dt;
+ 3170                                             IF sfx THEN
+ 3171                                               IF dt =
+ 3172                                                  SymTab.InvalidType THEN
+ 3173                                                 QbeGen.CopyOp("0", q)
+ 3174                                               ELSIF (SymTab.ClassOf(dt) =
+ 3175                                                      SymTab.ClRecord)
+ 3176                                                  OR (SymTab.ClassOf(dt) =
+ 3177                                                      SymTab.ClSet)
+ 3178                                                  OR (SymTab.ClassOf(dt) =
+ 3179                                                      SymTab.ClArray)
+ 3180                                                  OR (SymTab.ClassOf(dt) =
+ 3181                                                      SymTab.ClClass) THEN
+ 3182                                                 QbeGen.CopyOp(qd, q)
+ 3183                                               ELSE QbeGen.ElemLoad(qd, dt,
+ 3184                                                 q)
+ 3185                                               END
+ 3186                                             ELSE QbeGen.CopyOp(qd, q)
+ 3187                                             END;
+ 3188                                             IF (dk = SymTab.KindVar)
+ 3189                                                OR (dk = SymTab.KindParam)
+ 3190                                                OR (dk =
+ 3191                                                   SymTab.KindField) THEN
+ 3192                                               IF sfx THEN
+ 3193                                                 QbeGen.NoteAddr(q, qd)
+ 3194                                               ELSE
+ 3195                                                 QbeGen.AddrOf(qn, qa);
+ 3196                                                 QbeGen.NoteAddr(q, qa)
+ 3197                                               END
+ 3198                                             ELSIF sfx
+ 3199   AND (dt #
+ 3200                                                   SymTab.InvalidType)
+ 3201   AND ((SymTab.ClassOf(dt) =
+ 3202                                                    SymTab.ClArray)
+ 3203                                                   OR (SymTab.ClassOf(dt) =
+ 3204                                                       SymTab.ClSet)
+ 3205                                                   OR (SymTab.ClassOf(dt) =
+ 3206                                                       SymTab.ClRecord)) THEN
+ 3207                                               QbeGen.NoteAddr(qd, qd)
+ 3208                                             END; .)
+ 3209        [ TypedBraceLit<dt, q>            (. t := dt; astCall := TRUE;
+ 3210                                               astBrace := astCur; .) ]
+ 3211        [ ArgList<qn, dt, qd, TRUE, FALSE, methCls, ct2, q2, called>
+ 3212                                          (. astCall := TRUE;
+ 3213                                             astNode := AstCallNode(astD);
+ 3214                                             astRes := astNode;
+ 3215                                             t := ct2;
+ 3216                                             QbeGen.CopyOp(q2, q);
+ 3217                                             sfx := FALSE; .)
+ 3218          { ResultComp<t, q, sfx, astRes> }
+ 3219                                          (. IF sfx THEN
+ 3220                                               IF t = SymTab.InvalidType THEN
+ 3221                                                 QbeGen.CopyOp("0", q)
+ 3222                                               ELSIF (SymTab.ClassOf(t) #
+ 3223                                                      SymTab.ClRecord)
+ 3224    AND (SymTab.ClassOf(t) # SymTab.ClSet)
+ 3225    AND (SymTab.ClassOf(t) # SymTab.ClArray)
+ 3226    AND (SymTab.ClassOf(t) # SymTab.ClClass) THEN
+ 3227                                                 QbeGen.ElemLoad(q, t, q2);
+ 3228                                                 QbeGen.CopyOp(q2, q)
+ 3229                                               END
+ 3230                                             END; .) ]
+ 3231                                          (. IF called THEN
+ 3232                                               astCur := astRes
+ 3233                                             ELSIF astCall THEN
+ 3234                                               astCur := astBrace
+ 3235                                             ELSE astCur := astD
+ 3236                                             END;
+ 3237                                              astIsLit := TRUE;
+ 3238                                              IF NOT called
+ 3239   AND (dk = SymTab.KindProc) THEN
+ 3240                                               (* bare zero-arg function
+ 3241                                                  call (parentheses may be
+ 3242                                                  omitted); a proper or
+ 3243                                                  parameterised proc here
+ 3244                                                  is 230 *)
+ 3245                                               IF (SymTab.ProcNPar(qn) = 0)
+ 3246   AND (SymTab.ProcRes(qn) #
+ 3247                                                     SymTab.InvalidType) THEN
+ 3248                                                 QbeGen.Mangled(qn,
+ 3249                                                   SymTab.ProcUid(qn), qm0);
+ 3250                                                 QbeGen.CallBegin(qm0,
+ 3251                                                   SymTab.ProcRes(qn),
+ 3252                                                   SymTab.ProcDepthOf(qn),
+ 3253                                                   SymTab.IsExternal(qn));
+ 3254                                                 QbeGen.CallEnd(TRUE, q);
+ 3255                                                 t := SymTab.ProcRes(qn)
+ 3256                                               ELSE
+ 3257                                                 (* procedure used as a
+ 3258                                                    value (assign to a
+ 3259                                                    procedure variable):
+ 3260                                                    its code address *)
+ 3261                                                 t := SymTab.ProcTypeOf(qn);
+ 3262                                                 QbeGen.Mangled(qn,
+ 3263                                                   SymTab.ProcUid(qn), qm0);
+ 3264                                                 QbeGen.ProcAddr(qm0, q)
+ 3265                                               END
+ 3266                                             END; .)
+ 3267      | ( "HIGH"                          (. isHigh := TRUE; .)
+ 3268        | ( "LEN" | "LENGTH" )            (. isHigh := FALSE; .) )
+ 3269        "(" ( Design<dt, dk, qd, qn, sfx> (. isStr := FALSE;
+ 3270                                              isU := FALSE; .)
+ 3271            | string                       (. LexString(s); astCur := AST.MakeLeaf(AST.NkStrLit, s);
+ 3272                                              isStr := TRUE;
+ 3273                                              isU := FALSE;
+ 3274                                              IF SymTab.StrLen(s) = 3 THEN
+ 3275                                                dt := SymTab.CharType();
+ 3276                                                QbeGen.IntStr(QbeGen.CharVal(s),
+ 3277                                                  qd)
+ 3278                                              ELSE
+ 3279                                                dt := SymTab.NewStr();
+ 3280                                                QbeGen.DeclStr(s, qd);
+ 3281                                                QbeGen.NoteAddr(qd, qd)
+ 3282                                              END;
+ 3283                                              dk := -1;
+ 3284                                              qn[0] := CHR(0); .)
+ 3285            | ustring                      (. LexString(s); astCur := AST.MakeLeaf(AST.NkStrLit, s);
+ 3286                                              QbeGen.DeclUStr(s, qd, isU, ucp,
+ 3287                                                uok);
+ 3288                                              isStr := FALSE;
+ 3289                                              IF NOT uok THEN
+ 3290                                                SemError(234);
+ 3291                                                dt := SymTab.InvalidType
+ 3292                                              ELSIF isU THEN
+ 3293                                                (* one codepoint: a UCHAR;
+ 3294                                                   LEN is 1, HIGH is 0 *)
+ 3295                                                dt := SymTab.UCharType();
+ 3296                                                QbeGen.IntStr(ucp, qd)
+ 3297                                              ELSE
+ 3298                                                dt := SymTab.NewUStr();
+ 3299                                                QbeGen.NoteAddr(qd, qd)
+ 3300                                              END;
+ 3301                                              dk := -1;
+ 3302                                              qn[0] := CHR(0); .) )
+ 3303        ")"
+ 3304                                          (. astNode := AST.MakeNode(AST.NkCall);
+ 3305     IF isHigh THEN AST.SetChild(astNode, 0,
+ 3306       AST.MakeLeaf(AST.NkIdent, "HIGH"))
+ 3307     ELSE AST.SetChild(astNode, 0,
+ 3308       AST.MakeLeaf(AST.NkIdent, "LEN")) END;
+ 3309     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
+ 3310     astCur := astNode; astIsLit := TRUE;
+ 3311                                             IF (dt # SymTab.InvalidType)
+ 3312    AND (SymTab.ClassOf(dt) = SymTab.ClUStr) THEN
+ 3313                                               (* UString: the count is
+ 3314                                                  the descriptor header *)
+ 3315                                               IF isHigh THEN
+ 3316                                                 QbeGen.UStrLen(qd, qr);
+ 3317                                                 QbeGen.DecQ(qr)
+ 3318                                               ELSE
+ 3319                                                 QbeGen.UStrLen(qd, qr)
+ 3320                                               END;
+ 3321                                               t := SymTab.IntType();
+ 3322                                               QbeGen.CopyOp(qr, q)
+ 3323                                             ELSIF (dt # SymTab.InvalidType)
+ 3324    AND (SymTab.ClassOf(dt) = SymTab.ClUChar) THEN
+ 3325                                               (* single UCHAR codepoint *)
+ 3326                                               IF isHigh THEN
+ 3327                                                 QbeGen.CopyOp("0", qr)
+ 3328                                               ELSE
+ 3329                                                 QbeGen.CopyOp("1", qr)
+ 3330                                               END;
+ 3331                                               t := SymTab.IntType();
+ 3332                                               QbeGen.CopyOp(qr, q)
+ 3333                                             ELSIF isStr THEN
+ 3334                                               (* fold: content length at
+ 3335                                                  compile time *)
+ 3336                                               IF SymTab.StrLen(s) = 3 THEN
+ 3337                                                 c1 := 1
+ 3338                                               ELSE
+ 3339                                                 c1 :=
+ 3340                                                   SymTab.StrLen(s) - 2
  3341                                               END;
- 3342                                               QbeGen.IntStr(c1, qr);
- 3343                                               t := SymTab.IntType();
- 3344                                               QbeGen.CopyOp(qr, q)
- 3345                                             ELSIF dt = SymTab.InvalidType THEN
- 3346                                               t := SymTab.InvalidType;
- 3347                                               QbeGen.CopyOp("0", q)
- 3348                                             ELSIF SymTab.ClassOf(dt) #
- 3349                                                   SymTab.ClArray THEN
- 3350                                               SemError(217);
- 3351                                               t := SymTab.InvalidType;
- 3352                                               QbeGen.CopyOp("0", q)
- 3353                                             ELSE
- 3354                                               IF isHigh THEN
- 3355                                                 IF SymTab.IsOpenArray(dt) THEN
- 3356                                                   QbeGen.OpenHi(qd, qr)
- 3357                                                 ELSE
- 3358                                                   QbeGen.IntStr(
- 3359                                                     SymTab.ArrayHi(dt), qr)
- 3360                                                 END
- 3361                                               ELSE
- 3362                                                 IF SymTab.IsOpenArray(dt) THEN
- 3363                                                   QbeGen.LoadCount(qd, qr)
- 3364                                                 ELSE
- 3365                                                   QbeGen.IntStr(VAL(
- 3366                                                     INTEGER,
- 3367                                                     SymTab.ArrayLen(dt)),
- 3368                                                     qr)
- 3369                                                 END
- 3370                                               END;
- 3371                                                t := SymTab.IntType();
- 3372                                                QbeGen.CopyOp(qr, q)
- 3373                                              END; .)
- 3374      | ( "SIZE" | "TSIZE" ) "(" Design<dt, dk, qd, qn, sfx> ")"
- 3375      (. astNode := AST.MakeNode(AST.NkCall);
- 3376     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "SIZE"));
- 3377     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
- 3378     astCur := astNode; astIsLit := TRUE; .)
- 3379                                          (. IF dt = SymTab.InvalidType THEN
- 3380                                               t := SymTab.InvalidType;
- 3381                                               QbeGen.CopyOp("0", q)
- 3382                                             ELSE
- 3383                                               QbeGen.IntStr(VAL(INTEGER,
- 3384                                                 SymTab.ObjectSize(dt)), q);
- 3385                                               t := SymTab.IntType()
- 3386                                             END; .)
- 3387      | ( "SHIFT"                         (. isMax := FALSE; .)
- 3388        | "ROTATE"                        (. isMax := TRUE; .) )
- 3389        "(" Expr<et, q> (. astArg2 := astCur; .) "," Expr<et2, q2> ")"
- 3390                                          (. astNode := AST.MakeNode(AST.NkCall);
- 3391     IF isMax THEN AST.SetChild(astNode, 0,
- 3392       AST.MakeLeaf(AST.NkIdent, "ROTATE"))
- 3393     ELSE AST.SetChild(astNode, 0,
- 3394       AST.MakeLeaf(AST.NkIdent, "SHIFT")) END;
- 3395     IF astArg2 # AST.NoNode THEN AST.SetChild(astNode, 1, astArg2) END;
- 3396     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 2, astCur) END;
- 3397     astCur := astNode; astIsLit := TRUE;
- 3398                                             (* set shift/rotate: isMax
- 3399                                                doubles as "rotate" *)
- 3400                                             IF (et # SymTab.InvalidType)
- 3401                                                AND (SymTab.ClassOf(et) =
- 3402                                                   SymTab.ClSet) THEN
- 3403                                               QbeGen.SetShift(q, q2,
- 3404                                                 SymTab.SetWords(et),
- 3405                                                 SymTab.SetCount(et), isMax,
- 3406                                                 qt);
- 3407                                               t := et;
- 3408                                               QbeGen.CopyOp(qt, q)
- 3409                                             ELSE SemError(230);
- 3410                                               t := SymTab.InvalidType;
- 3411                                               QbeGen.CopyOp("0", q)
- 3412                                             END; .)
- 3413      | ( "MIN"                           (. isMax := FALSE; .)
- 3414        | "MAX"                           (. isMax := TRUE; .) )
- 3415        "(" Design<dt, dk, qd, qn, sfx> ")"
- 3416                                          (. astNode := AST.MakeNode(AST.NkCall);
- 3417     IF isMax THEN AST.SetChild(astNode, 0,
- 3418       AST.MakeLeaf(AST.NkIdent, "MAX"))
- 3419     ELSE AST.SetChild(astNode, 0,
- 3420       AST.MakeLeaf(AST.NkIdent, "MIN")) END;
- 3421     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
- 3422     astCur := astNode; astIsLit := TRUE;
- 3423                                             IF (dt # SymTab.InvalidType)
- 3424   AND (SymTab.ClassOf(dt) = SymTab.ClReal) THEN
- 3425                                               (* REAL/LONGREAL: the
- 3426                                                  implementation bounds *)
- 3427                                               IF isMax THEN
- 3428                                                 QbeGen.NormReal(
- 3429                                                   "3.402823e38", q)
- 3430                                               ELSE QbeGen.NormReal(
- 3431                                                   "-3.402823e38", q)
- 3432                                               END;
- 3433                                               t := SymTab.RealType()
- 3434                                             ELSIF (dt #
- 3435                                                SymTab.InvalidType)
- 3436   AND (SymTab.ClassOf(dt) =
- 3437                                                   SymTab.ClLong) THEN
- 3438                                               IF isMax THEN
- 3439                                                 QbeGen.CopyOp(
- 3440                                                   "9223372036854775807", q)
- 3441                                               ELSE QbeGen.CopyOp(
- 3442                                                   "-9223372036854775808", q)
- 3443                                               END;
- 3444                                               t := SymTab.LongType()
- 3445                                             ELSIF SymTab.TypeBounds(dt, lo,
- 3446                                                      hi) THEN
- 3447                                               IF isMax THEN
- 3448                                                 QbeGen.IntStr(hi, q)
- 3449                                               ELSE QbeGen.IntStr(lo, q)
- 3450                                               END;
- 3451                                               t := SymTab.IntType()
- 3452                                             ELSE SemError(230);
- 3453                                               t := SymTab.InvalidType;
- 3454                                               QbeGen.CopyOp("0", q)
- 3455                                             END; .)
- 3456      | "ADR" "(" Design<dt, dk, qd, qn, sfx> ")"
- 3457      (. astNode := AST.MakeNode(AST.NkCall);
- 3458     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "ADR"));
- 3459     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
- 3460     astCur := astNode; astIsLit := TRUE; .)
- 3461                                          (. IF dt = SymTab.InvalidType THEN
- 3462                                               t := SymTab.InvalidType;
- 3463                                               QbeGen.CopyOp("0", q)
- 3464                                             ELSE
- 3465                                               IF sfx THEN
- 3466                                                 QbeGen.CopyOp(qd, q)
- 3467                                               ELSIF (dk = SymTab.KindVar)
- 3468                                                  OR (dk = SymTab.KindParam) THEN
- 3469                                                 QbeGen.AddrOf(qn, q)
- 3470                                               ELSE SemError(230);
- 3471                                                 QbeGen.CopyOp("0", q)
- 3472                                               END;
- 3473                                               t := SymTab.AddrType()
- 3474                                             END; .)
- 3475      | "CHR" "(" Expr<et, q> ")"
- 3476      (. astNode := AST.MakeNode(AST.NkCall);
- 3477     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "CHR"));
- 3478     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
- 3479     astCur := astNode; astIsLit := TRUE; .)
- 3480                                          (. IF (et # SymTab.InvalidType)
- 3481   AND NOT SymTab.IsIntFamily(et) THEN
- 3482                                               SemError(211) END;
- 3483                                             t := SymTab.CharType(); .)
- 3484      | ( "ORD" | "ORDL" ) "(" Expr<et, q> ")"
- 3485      (. astNode := AST.MakeNode(AST.NkCall);
- 3486     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "ORD"));
- 3487     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
- 3488     astCur := astNode; astIsLit := TRUE; .)
- 3489                                          (. IF et # SymTab.InvalidType THEN
- 3490                                               IF (SymTab.ClassOf(et) #
- 3491                                                   SymTab.ClChar)
- 3492   AND (SymTab.ClassOf(et) #
- 3493                                                     SymTab.ClBool)
- 3494   AND (SymTab.ClassOf(et) #
- 3495                                                     SymTab.ClEnum)
- 3496   AND NOT SymTab.IsIntFamily(et) THEN
- 3497                                                 SemError(211) END
- 3498                                             END;
- 3499                                             t := SymTab.IntType(); .)
- 3500      | "CAP" "(" Expr<et, q> ")"
- 3501      (. astNode := AST.MakeNode(AST.NkCall);
- 3502     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "CAP"));
- 3503     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
- 3504     astCur := astNode; astIsLit := TRUE; .)
- 3505                                          (. QbeGen.CapQ(q, qa);
- 3506                                             QbeGen.CopyOp(qa, q);
- 3507                                             t := SymTab.CharType(); .)
- 3508      | "UCHR" "(" Expr<et, q> ")"
- 3509      (. astNode := AST.MakeNode(AST.NkCall);
- 3510     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "UCHR"));
- 3511     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
- 3512     astCur := astNode; astIsLit := TRUE; .)
- 3513                                          (. (* UCHR: the UCHAR constructor.
- 3514                                                CHAR -> UCHAR (identity);
- 3515                                                INTEGER familly -> UCHAR
- 3516                                                (codepoint value). *)
- 3517                                             IF (et # SymTab.InvalidType)
- 3518    AND (SymTab.ClassOf(et) # SymTab.ClChar)
- 3519    AND NOT SymTab.IsIntFamily(et) THEN
- 3520                                               SemError(211) END;
- 3521                                             t := SymTab.UCharType(); .)
- 3522      | "CHR8" "(" Expr<et, q> ")"
- 3523      (. astNode := AST.MakeNode(AST.NkCall);
- 3524     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "CHR8"));
- 3525     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
- 3526     astCur := astNode; astIsLit := TRUE; .)
- 3527                                          (. IF (et # SymTab.InvalidType)
- 3528    AND (SymTab.ClassOf(et) # SymTab.ClUChar) THEN
- 3529                                               SemError(211) END;
- 3530                                             QbeGen.WidenLong(q, qa);
- 3531                                             QbeGen.CheckRange(qa, "0", "255");
- 3532                                             t := SymTab.CharType(); .)
- 3533      | "UORD" "(" Expr<et, q> ")"
- 3534      (. astNode := AST.MakeNode(AST.NkCall);
- 3535     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "UORD"));
- 3536     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
- 3537     astCur := astNode; astIsLit := TRUE; .)
- 3538                                          (. (* UORD(u): the codepoint as a
- 3539                                                32-bit ordinal (INTEGER),
- 3540                                                cf. ORD for CHAR. *)
- 3541                                             IF (et # SymTab.InvalidType)
- 3542    AND (SymTab.ClassOf(et) # SymTab.ClUChar) THEN
- 3543                                               SemError(211) END;
- 3544                                             t := SymTab.IntType(); .)
- 3545      | "ABS" "(" Expr<et, q> ")"
- 3546      (. astNode := AST.MakeNode(AST.NkCall);
- 3547     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "ABS"));
- 3548     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
- 3549     astCur := astNode; astIsLit := TRUE; .)
- 3550                                          (. IF (et # SymTab.InvalidType)
- 3551   AND NOT SymTab.IsIntFamily(et)
- 3552   AND (SymTab.ClassOf(et) #
- 3553                                                  SymTab.ClReal) THEN
- 3554                                               SemError(211)
- 3555                                             ELSE QbeGen.AbsQ(q, qa,
- 3556                                                    SymTab.ClassOf(et) =
- 3557                                                      SymTab.ClReal);
- 3558                                               QbeGen.CopyOp(qa, q)
- 3559                                             END;
- 3560                                             t := et; .)
- 3561      | "VAL" "(" GetIdent<vn> (. astArg2 := AST.MakeLeaf(AST.NkIdent, vn); .) "," Expr<et, q> ")"
- 3562      (. astNode := AST.MakeNode(AST.NkCall);
- 3563     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "VAL"));
- 3564     IF astArg2 # AST.NoNode THEN AST.SetChild(astNode, 1, astArg2) END;
- 3565     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 2, astCur) END;
- 3566     astCur := astNode; astIsLit := TRUE; .)
- 3567                                          (. IF NOT SymTab.Lookup(vn) THEN
- 3568                                               SemError(201);
- 3569                                               t := SymTab.InvalidType
- 3570                                             ELSE vt := SymTab.SymType(vn);
- 3571                                               IF vt = SymTab.InvalidType THEN
- 3572                                                 t := SymTab.InvalidType
- 3573                                               ELSIF et =
- 3574                                                  SymTab.InvalidType THEN
- 3575                                                 t := vt
- 3576                                               ELSE
- 3577                                                 c1 := SymTab.ClassOf(et);
- 3578                                                 c2 := SymTab.ClassOf(vt);
- 3579                                                 IF (c1 = SymTab.ClInt)
- 3580    AND (c2 = SymTab.ClLong) THEN
- 3581                                                   QbeGen.WidenLong(q, qa);
- 3582                                                   QbeGen.CopyOp(qa, q);
- 3583                                                   t := vt
- 3584                                                 ELSIF (c1 = SymTab.ClLong)
- 3585    AND (c2 = SymTab.ClInt) THEN
- 3586                                                   QbeGen.NarrowLong(q, qa);
- 3587                                                   QbeGen.CopyOp(qa, q);
- 3588                                                   t := vt
- 3589                                                 ELSIF (c1 = SymTab.ClInt)
- 3590    AND (c2 = SymTab.ClReal) THEN
- 3591                                                   QbeGen.ConvIR(q, qa);
- 3592                                                   QbeGen.CopyOp(qa, q);
- 3593                                                   t := vt
- 3594                                                 ELSIF (c1 = SymTab.ClLong)
- 3595    AND (c2 = SymTab.ClReal) THEN
- 3596                                                   QbeGen.ConvLR(q, qa);
- 3597                                                   QbeGen.CopyOp(qa, q);
- 3598                                                   t := vt
- 3599                                                 ELSIF (c1 = SymTab.ClReal)
- 3600    AND (c2 = SymTab.ClInt) THEN
- 3601                                                   QbeGen.ConvRI(q, qa);
- 3602                                                   QbeGen.CopyOp(qa, q);
- 3603                                                   t := vt
- 3604                                                 ELSIF (c1 = SymTab.ClReal)
- 3605    AND (c2 = SymTab.ClLong) THEN
- 3606                                                   QbeGen.ConvRL(q, qa);
- 3607                                                   QbeGen.CopyOp(qa, q);
- 3608                                                   t := vt
- 3609                                                 ELSIF ((c1 = SymTab.ClInt)
- 3610                                                     OR (c1 =
- 3611                                                        SymTab.ClChar)
- 3612                                                     OR (c1 =
- 3613                                                        SymTab.ClBool)
- 3614                                                     OR (c1 =
- 3615                                                        SymTab.ClEnum))
- 3616   AND ((c2 = SymTab.ClInt)
- 3617                                                     OR (c2 =
- 3618                                                        SymTab.ClChar)
- 3619                                                     OR (c2 =
- 3620                                                        SymTab.ClBool)
- 3621                                                     OR (c2 =
- 3622                                                        SymTab.ClEnum)) THEN
- 3623                                                   t := vt
- 3624                                                 ELSIF (c1 = SymTab.ClPtr)
- 3625   AND (c2 = SymTab.ClPtr) THEN
+ 3342                                               IF isHigh THEN
+ 3343                                                 DEC(c1)
+ 3344                                               END;
+ 3345                                               QbeGen.IntStr(c1, qr);
+ 3346                                               t := SymTab.IntType();
+ 3347                                               QbeGen.CopyOp(qr, q)
+ 3348                                             ELSIF dt = SymTab.InvalidType THEN
+ 3349                                               t := SymTab.InvalidType;
+ 3350                                               QbeGen.CopyOp("0", q)
+ 3351                                             ELSIF SymTab.ClassOf(dt) #
+ 3352                                                   SymTab.ClArray THEN
+ 3353                                               SemError(217);
+ 3354                                               t := SymTab.InvalidType;
+ 3355                                               QbeGen.CopyOp("0", q)
+ 3356                                             ELSE
+ 3357                                               IF isHigh THEN
+ 3358                                                 IF SymTab.IsOpenArray(dt) THEN
+ 3359                                                   QbeGen.OpenHi(qd, qr)
+ 3360                                                 ELSE
+ 3361                                                   QbeGen.IntStr(
+ 3362                                                     SymTab.ArrayHi(dt), qr)
+ 3363                                                 END
+ 3364                                               ELSE
+ 3365                                                 IF SymTab.IsOpenArray(dt) THEN
+ 3366                                                   QbeGen.LoadCount(qd, qr)
+ 3367                                                 ELSE
+ 3368                                                   QbeGen.IntStr(VAL(
+ 3369                                                     INTEGER,
+ 3370                                                     SymTab.ArrayLen(dt)),
+ 3371                                                     qr)
+ 3372                                                 END
+ 3373                                               END;
+ 3374                                                t := SymTab.IntType();
+ 3375                                                QbeGen.CopyOp(qr, q)
+ 3376                                              END; .)
+ 3377      | ( "SIZE" | "TSIZE" ) "(" Design<dt, dk, qd, qn, sfx> ")"
+ 3378      (. astNode := AST.MakeNode(AST.NkCall);
+ 3379     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "SIZE"));
+ 3380     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
+ 3381     astCur := astNode; astIsLit := TRUE; .)
+ 3382                                          (. IF dt = SymTab.InvalidType THEN
+ 3383                                               t := SymTab.InvalidType;
+ 3384                                               QbeGen.CopyOp("0", q)
+ 3385                                             ELSE
+ 3386                                               QbeGen.IntStr(VAL(INTEGER,
+ 3387                                                 SymTab.ObjectSize(dt)), q);
+ 3388                                               t := SymTab.IntType()
+ 3389                                             END; .)
+ 3390      | ( "SHIFT"                         (. isMax := FALSE; .)
+ 3391        | "ROTATE"                        (. isMax := TRUE; .) )
+ 3392        "(" Expr<et, q> (. astArg2 := astCur; .) "," Expr<et2, q2> ")"
+ 3393                                          (. astNode := AST.MakeNode(AST.NkCall);
+ 3394     IF isMax THEN AST.SetChild(astNode, 0,
+ 3395       AST.MakeLeaf(AST.NkIdent, "ROTATE"))
+ 3396     ELSE AST.SetChild(astNode, 0,
+ 3397       AST.MakeLeaf(AST.NkIdent, "SHIFT")) END;
+ 3398     IF astArg2 # AST.NoNode THEN AST.SetChild(astNode, 1, astArg2) END;
+ 3399     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 2, astCur) END;
+ 3400     astCur := astNode; astIsLit := TRUE;
+ 3401                                             (* set shift/rotate: isMax
+ 3402                                                doubles as "rotate" *)
+ 3403                                             IF (et # SymTab.InvalidType)
+ 3404                                                AND (SymTab.ClassOf(et) =
+ 3405                                                   SymTab.ClSet) THEN
+ 3406                                               QbeGen.SetShift(q, q2,
+ 3407                                                 SymTab.SetWords(et),
+ 3408                                                 SymTab.SetCount(et), isMax,
+ 3409                                                 qt);
+ 3410                                               t := et;
+ 3411                                               QbeGen.CopyOp(qt, q)
+ 3412                                             ELSE SemError(230);
+ 3413                                               t := SymTab.InvalidType;
+ 3414                                               QbeGen.CopyOp("0", q)
+ 3415                                             END; .)
+ 3416      | ( "MIN"                           (. isMax := FALSE; .)
+ 3417        | "MAX"                           (. isMax := TRUE; .) )
+ 3418        "(" Design<dt, dk, qd, qn, sfx> ")"
+ 3419                                          (. astNode := AST.MakeNode(AST.NkCall);
+ 3420     IF isMax THEN AST.SetChild(astNode, 0,
+ 3421       AST.MakeLeaf(AST.NkIdent, "MAX"))
+ 3422     ELSE AST.SetChild(astNode, 0,
+ 3423       AST.MakeLeaf(AST.NkIdent, "MIN")) END;
+ 3424     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
+ 3425     astCur := astNode; astIsLit := TRUE;
+ 3426                                             IF (dt # SymTab.InvalidType)
+ 3427   AND (SymTab.ClassOf(dt) = SymTab.ClReal) THEN
+ 3428                                               (* REAL/LONGREAL: the
+ 3429                                                  implementation bounds *)
+ 3430                                               IF isMax THEN
+ 3431                                                 QbeGen.NormReal(
+ 3432                                                   "3.402823e38", q)
+ 3433                                               ELSE QbeGen.NormReal(
+ 3434                                                   "-3.402823e38", q)
+ 3435                                               END;
+ 3436                                               t := SymTab.RealType()
+ 3437                                             ELSIF (dt #
+ 3438                                                SymTab.InvalidType)
+ 3439   AND (SymTab.ClassOf(dt) =
+ 3440                                                   SymTab.ClLong) THEN
+ 3441                                               IF isMax THEN
+ 3442                                                 QbeGen.CopyOp(
+ 3443                                                   "9223372036854775807", q)
+ 3444                                               ELSE QbeGen.CopyOp(
+ 3445                                                   "-9223372036854775808", q)
+ 3446                                               END;
+ 3447                                               t := SymTab.LongType()
+ 3448                                             ELSIF SymTab.TypeBounds(dt, lo,
+ 3449                                                      hi) THEN
+ 3450                                               IF isMax THEN
+ 3451                                                 QbeGen.IntStr(hi, q)
+ 3452                                               ELSE QbeGen.IntStr(lo, q)
+ 3453                                               END;
+ 3454                                               t := SymTab.IntType()
+ 3455                                             ELSE SemError(230);
+ 3456                                               t := SymTab.InvalidType;
+ 3457                                               QbeGen.CopyOp("0", q)
+ 3458                                             END; .)
+ 3459      | "ADR" "(" Design<dt, dk, qd, qn, sfx> ")"
+ 3460      (. astNode := AST.MakeNode(AST.NkCall);
+ 3461     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "ADR"));
+ 3462     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
+ 3463     astCur := astNode; astIsLit := TRUE; .)
+ 3464                                          (. IF dt = SymTab.InvalidType THEN
+ 3465                                               t := SymTab.InvalidType;
+ 3466                                               QbeGen.CopyOp("0", q)
+ 3467                                             ELSE
+ 3468                                               IF sfx THEN
+ 3469                                                 QbeGen.CopyOp(qd, q)
+ 3470                                               ELSIF (dk = SymTab.KindVar)
+ 3471                                                  OR (dk = SymTab.KindParam) THEN
+ 3472                                                 QbeGen.AddrOf(qn, q)
+ 3473                                               ELSE SemError(230);
+ 3474                                                 QbeGen.CopyOp("0", q)
+ 3475                                               END;
+ 3476                                               t := SymTab.AddrType()
+ 3477                                             END; .)
+ 3478      | "CHR" "(" Expr<et, q> ")"
+ 3479      (. astNode := AST.MakeNode(AST.NkCall);
+ 3480     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "CHR"));
+ 3481     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
+ 3482     astCur := astNode; astIsLit := TRUE; .)
+ 3483                                          (. IF (et # SymTab.InvalidType)
+ 3484   AND NOT SymTab.IsIntFamily(et) THEN
+ 3485                                               SemError(211) END;
+ 3486                                             t := SymTab.CharType(); .)
+ 3487      | ( "ORD" | "ORDL" ) "(" Expr<et, q> ")"
+ 3488      (. astNode := AST.MakeNode(AST.NkCall);
+ 3489     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "ORD"));
+ 3490     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
+ 3491     astCur := astNode; astIsLit := TRUE; .)
+ 3492                                          (. IF et # SymTab.InvalidType THEN
+ 3493                                               IF (SymTab.ClassOf(et) #
+ 3494                                                   SymTab.ClChar)
+ 3495   AND (SymTab.ClassOf(et) #
+ 3496                                                     SymTab.ClBool)
+ 3497   AND (SymTab.ClassOf(et) #
+ 3498                                                     SymTab.ClEnum)
+ 3499   AND NOT SymTab.IsIntFamily(et) THEN
+ 3500                                                 SemError(211) END
+ 3501                                             END;
+ 3502                                             t := SymTab.IntType(); .)
+ 3503      | "CAP" "(" Expr<et, q> ")"
+ 3504      (. astNode := AST.MakeNode(AST.NkCall);
+ 3505     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "CAP"));
+ 3506     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
+ 3507     astCur := astNode; astIsLit := TRUE; .)
+ 3508                                          (. QbeGen.CapQ(q, qa);
+ 3509                                             QbeGen.CopyOp(qa, q);
+ 3510                                             t := SymTab.CharType(); .)
+ 3511      | "UCHR" "(" Expr<et, q> ")"
+ 3512      (. astNode := AST.MakeNode(AST.NkCall);
+ 3513     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "UCHR"));
+ 3514     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
+ 3515     astCur := astNode; astIsLit := TRUE; .)
+ 3516                                          (. (* UCHR: the UCHAR constructor.
+ 3517                                                CHAR -> UCHAR (identity);
+ 3518                                                INTEGER familly -> UCHAR
+ 3519                                                (codepoint value). *)
+ 3520                                             IF (et # SymTab.InvalidType)
+ 3521    AND (SymTab.ClassOf(et) # SymTab.ClChar)
+ 3522    AND NOT SymTab.IsIntFamily(et) THEN
+ 3523                                               SemError(211) END;
+ 3524                                             t := SymTab.UCharType(); .)
+ 3525      | "CHR8" "(" Expr<et, q> ")"
+ 3526      (. astNode := AST.MakeNode(AST.NkCall);
+ 3527     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "CHR8"));
+ 3528     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
+ 3529     astCur := astNode; astIsLit := TRUE; .)
+ 3530                                          (. IF (et # SymTab.InvalidType)
+ 3531    AND (SymTab.ClassOf(et) # SymTab.ClUChar) THEN
+ 3532                                               SemError(211) END;
+ 3533                                             QbeGen.WidenLong(q, qa);
+ 3534                                             QbeGen.CheckRange(qa, "0", "255");
+ 3535                                             t := SymTab.CharType(); .)
+ 3536      | "UORD" "(" Expr<et, q> ")"
+ 3537      (. astNode := AST.MakeNode(AST.NkCall);
+ 3538     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "UORD"));
+ 3539     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
+ 3540     astCur := astNode; astIsLit := TRUE; .)
+ 3541                                          (. (* UORD(u): the codepoint as a
+ 3542                                                32-bit ordinal (INTEGER),
+ 3543                                                cf. ORD for CHAR. *)
+ 3544                                             IF (et # SymTab.InvalidType)
+ 3545    AND (SymTab.ClassOf(et) # SymTab.ClUChar) THEN
+ 3546                                               SemError(211) END;
+ 3547                                             t := SymTab.IntType(); .)
+ 3548      | "ABS" "(" Expr<et, q> ")"
+ 3549      (. astNode := AST.MakeNode(AST.NkCall);
+ 3550     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "ABS"));
+ 3551     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 1, astCur) END;
+ 3552     astCur := astNode; astIsLit := TRUE; .)
+ 3553                                          (. IF (et # SymTab.InvalidType)
+ 3554   AND NOT SymTab.IsIntFamily(et)
+ 3555   AND (SymTab.ClassOf(et) #
+ 3556                                                  SymTab.ClReal) THEN
+ 3557                                               SemError(211)
+ 3558                                             ELSE QbeGen.AbsQ(q, qa,
+ 3559                                                    SymTab.ClassOf(et) =
+ 3560                                                      SymTab.ClReal);
+ 3561                                               QbeGen.CopyOp(qa, q)
+ 3562                                             END;
+ 3563                                             t := et; .)
+ 3564      | "VAL" "(" GetIdent<vn> (. astArg2 := AST.MakeLeaf(AST.NkIdent, vn); .) "," Expr<et, q> ")"
+ 3565      (. astNode := AST.MakeNode(AST.NkCall);
+ 3566     AST.SetChild(astNode, 0, AST.MakeLeaf(AST.NkIdent, "VAL"));
+ 3567     IF astArg2 # AST.NoNode THEN AST.SetChild(astNode, 1, astArg2) END;
+ 3568     IF astCur # AST.NoNode THEN AST.SetChild(astNode, 2, astCur) END;
+ 3569     astCur := astNode; astIsLit := TRUE; .)
+ 3570                                          (. IF NOT SymTab.Lookup(vn) THEN
+ 3571                                               SemError(201);
+ 3572                                               t := SymTab.InvalidType
+ 3573                                             ELSE vt := SymTab.SymType(vn);
+ 3574                                               IF vt = SymTab.InvalidType THEN
+ 3575                                                 t := SymTab.InvalidType
+ 3576                                               ELSIF et =
+ 3577                                                  SymTab.InvalidType THEN
+ 3578                                                 t := vt
+ 3579                                               ELSE
+ 3580                                                 c1 := SymTab.ClassOf(et);
+ 3581                                                 c2 := SymTab.ClassOf(vt);
+ 3582                                                 IF (c1 = SymTab.ClInt)
+ 3583    AND (c2 = SymTab.ClLong) THEN
+ 3584                                                   QbeGen.WidenLong(q, qa);
+ 3585                                                   QbeGen.CopyOp(qa, q);
+ 3586                                                   t := vt
+ 3587                                                 ELSIF (c1 = SymTab.ClLong)
+ 3588    AND (c2 = SymTab.ClInt) THEN
+ 3589                                                   QbeGen.NarrowLong(q, qa);
+ 3590                                                   QbeGen.CopyOp(qa, q);
+ 3591                                                   t := vt
+ 3592                                                 ELSIF (c1 = SymTab.ClInt)
+ 3593    AND (c2 = SymTab.ClReal) THEN
+ 3594                                                   QbeGen.ConvIR(q, qa);
+ 3595                                                   QbeGen.CopyOp(qa, q);
+ 3596                                                   t := vt
+ 3597                                                 ELSIF (c1 = SymTab.ClLong)
+ 3598    AND (c2 = SymTab.ClReal) THEN
+ 3599                                                   QbeGen.ConvLR(q, qa);
+ 3600                                                   QbeGen.CopyOp(qa, q);
+ 3601                                                   t := vt
+ 3602                                                 ELSIF (c1 = SymTab.ClReal)
+ 3603    AND (c2 = SymTab.ClInt) THEN
+ 3604                                                   QbeGen.ConvRI(q, qa);
+ 3605                                                   QbeGen.CopyOp(qa, q);
+ 3606                                                   t := vt
+ 3607                                                 ELSIF (c1 = SymTab.ClReal)
+ 3608    AND (c2 = SymTab.ClLong) THEN
+ 3609                                                   QbeGen.ConvRL(q, qa);
+ 3610                                                   QbeGen.CopyOp(qa, q);
+ 3611                                                   t := vt
+ 3612                                                 ELSIF ((c1 = SymTab.ClInt)
+ 3613                                                     OR (c1 =
+ 3614                                                        SymTab.ClChar)
+ 3615                                                     OR (c1 =
+ 3616                                                        SymTab.ClBool)
+ 3617                                                     OR (c1 =
+ 3618                                                        SymTab.ClEnum))
+ 3619   AND ((c2 = SymTab.ClInt)
+ 3620                                                     OR (c2 =
+ 3621                                                        SymTab.ClChar)
+ 3622                                                     OR (c2 =
+ 3623                                                        SymTab.ClBool)
+ 3624                                                     OR (c2 =
+ 3625                                                        SymTab.ClEnum)) THEN
  3626                                                   t := vt
- 3627                                                 ELSIF (c1 = SymTab.ClReal)
- 3628   AND (c2 = SymTab.ClReal) THEN
+ 3627                                                 ELSIF (c1 = SymTab.ClPtr)
+ 3628   AND (c2 = SymTab.ClPtr) THEN
  3629                                                   t := vt
- 3630                                                 ELSE SemError(230);
- 3631                                                   t := SymTab.InvalidType
- 3632                                                 END
- 3633                                               END
- 3634                                             END; .)
- 3635      | "(" Expr<et, q> ")"               (. t := et; astIsLit := TRUE; .)
- 3636      | SetLit<st, sq>                    (. astIsLit := TRUE; t := st;
- 3637                                             QbeGen.CopyOp(sq, q); .)
- 3638      | ( "NOT" | "~" ) Fact<t2, q2>      (. astNot := astCur;
- 3639                                             IF SymTab.BoolCheck(t2) THEN
- 3640                                               t := SymTab.BoolType()
- 3641                                             ELSE SemError(212);
- 3642                                               t := SymTab.InvalidType END;
- 3643                                             IF t # SymTab.InvalidType THEN
- 3644                                               QbeGen.NotQ(q2, q)
- 3645                                             ELSE QbeGen.CopyOp("0", q)
- 3646                                             END;
- 3647                                             astIsLit := TRUE;
- 3648                                             astCur := AST.MakeUn(
- 3649                                               AST.NkUnary, AST.OpNot, astNot); .)
- 3650      )
- 3651      (. IF NOT astIsLit THEN astCur := AST.NoNode END; .) .
- 3652    (* Set literals are SET OF [0..255] (8 words); elements validated
- 3653       0..255 statically when foldable (222 otherwise), runtime trap
- 3654       for computed elements. Ranges always lower via SetRange. *)
- 3655    SetLit<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
- 3656                                          (. VAR astNode: AST.Node; .)
- 3657      = "{"                               (. t := SymTab.NewSet(
- 3658                                               SymTab.NewSubR(0, 255));
- 3659                                             astNode := AST.MakeNode(AST.NkSetLit);
- 3660                                             QbeGen.NewSetTemp(8, q);
- 3661                                             QbeGen.SetZero(q, 8); .)
- 3662        [ SetElem<t, q, astNode> { "," SetElem<t, q, astNode> } ]
- 3663        "}"                               (. astCur := astNode; .) .
- 3664    (* Typed brace constructor: TypeName{ elems } — BITSET{0} (a set)
- 3665       or ArrayName{...} (an array constructor, GNU Modula-2).  The
- 3666       declared type sets the width (set) or element type (array). *)
- 3667    TypedBraceLit<vt: SymTab.TypeIndex; VAR q: QbeGen.QVal>
- 3668                                          (. VAR nw: CARDINAL;
- 3669                                               astNode: AST.Node;
- 3670                                               savedCls: INTEGER; .)
- 3671      = "{"                               (. savedCls := braceCls;
- 3672                                             astNode := AST.MakeNode(AST.NkBraceLit);
- 3673                                             IF vt = SymTab.InvalidType THEN
- 3674                                               braceCls := -1
- 3675                                             ELSE braceCls :=
- 3676                                                    SymTab.ClassOf(vt)
- 3677                                             END;
- 3678                                             IF braceCls = SymTab.ClSet THEN
- 3679                                               IF vt = SymTab.InvalidType THEN
- 3680                                                 nw := 8
- 3681                                               ELSE nw := SymTab.SetWords(vt);
- 3682                                                 IF nw = 0 THEN nw := 8 END
- 3683                                               END;
- 3684                                               QbeGen.NewSetTemp(nw, q);
- 3685                                               QbeGen.SetZero(q, nw)
- 3686                                             ELSIF (braceCls =
- 3687                                                    SymTab.ClArray)
- 3688                                                OR (braceCls =
- 3689                                                    SymTab.ClRecord)
- 3690                                                OR (braceCls =
- 3691                                                    SymTab.ClClass) THEN
- 3692                                               QbeGen.CtorBegin(vt)
- 3693                                             ELSE
- 3694                                               IF vt # SymTab.InvalidType THEN
- 3695                                                 SemError(230) END;
- 3696                                               braceCls := -1
- 3697                                             END; .)
- 3698        [ BraceElem<vt, q, astNode> { "," BraceElem<vt, q, astNode> } ]
- 3699        "}"                               (. IF (braceCls = SymTab.ClArray)
- 3700                                                OR (braceCls =
- 3701                                                   SymTab.ClRecord)
- 3702                                                OR (braceCls =
- 3703                                                   SymTab.ClClass) THEN
- 3704                                               QbeGen.CtorEnd(q)
- 3705                                             ELSIF braceCls # SymTab.ClSet THEN
- 3706                                               QbeGen.CopyOp("0", q)
- 3707                                             END;
- 3708                                             braceCls := savedCls; .)
- 3709                                          (. astCur := astNode; .) .
- 3710    BraceElem<vt: SymTab.TypeIndex; VAR sq: QbeGen.QVal; node: AST.Node>
- 3711                                          (. VAR et, et2: SymTab.TypeIndex;
- 3712                                               qe, q2: QbeGen.QVal;
- 3713                                               v, v2, reps, k: INTEGER;
- 3714                                               elem: SymTab.TypeIndex;
- 3715                                               lo: INTEGER;
- 3716                                               span: CARDINAL;
- 3717                                               cl, cl2: INTEGER;
- 3718                                               hasR, hasB: BOOLEAN;
- 3719                                               astEl: AST.Node; .)
- 3720      =                                   (. hasR := FALSE; hasB := FALSE; .)
- 3721        Expr<et, qe> (. astEl := astCur; .)
- 3722        [ ".." Expr<et2, q2>              (. astEl := AST.MakeBin(
- 3723                                               AST.NkSubrange, 0, astEl, astCur);
- 3724                                             hasR := TRUE; .) ]
- 3725        [ "BY" Expr<et2, q2>              (. hasB := TRUE; .) ]
- 3726                                          (. IF braceCls = SymTab.ClSet THEN
- 3727                                               IF hasB THEN SemError(230) END;
- 3728                                               lo := SymTab.SetBaseLo(vt);
- 3729                                               span := SymTab.SetCount(vt);
- 3730                                               IF (et = SymTab.InvalidType)
- 3731                                                  OR (hasR AND (et2 =
- 3732                                                     SymTab.InvalidType)) THEN
- 3733                                               ELSE cl :=
- 3734                                                      SymTab.ClassOf(et);
- 3735                                                 IF hasR THEN
- 3736                                                   cl2 :=
- 3737                                                     SymTab.ClassOf(et2)
- 3738                                                 ELSE cl2 := SymTab.ClInt
- 3739                                                 END;
- 3740                                                 IF NOT SymTab.SetElemClassOk(cl)
- 3741                                                    OR (hasR AND NOT
- 3742                                                       SymTab.SetElemClassOk(cl2))
- 3743                                                 THEN
- 3744                                                   SemError(222)
- 3745                                                 ELSIF hasR
- 3746   AND SymTab.ConstInt(qe, v)
- 3747   AND SymTab.ConstInt(q2,
- 3748                                                       v2)
- 3749   AND ((v < lo)
- 3750                                                       OR (v2 < lo)
- 3751                                                       OR (v >= lo +
- 3752                                                          VAL(INTEGER, span))
- 3753                                                       OR (v2 >= lo +
- 3754                                                          VAL(INTEGER, span))
- 3755                                                       OR (v > v2)) THEN
- 3756                                                   SemError(222)
- 3757                                                  ELSIF hasR THEN
- 3758                                                    QbeGen.SetRange(sq, qe, q2,
- 3759                                                      lo, span)
- 3760                                                  ELSIF SymTab.ConstInt(qe,
- 3761                                                          v)
- 3762   AND ((v < lo)
- 3763                                                        OR (v >= lo +
- 3764                                                           VAL(INTEGER,
- 3765                                                             span))) THEN
- 3766                                                    SemError(222)
- 3767                                                  ELSE QbeGen.SetBit(sq, qe,
- 3768                                                    lo, span)
- 3769                                                 END
- 3770                                               END
- 3771                                             ELSIF (braceCls = SymTab.ClArray)
- 3772                                                OR (braceCls =
- 3773                                                   SymTab.ClRecord)
- 3774                                                OR (braceCls =
- 3775                                                   SymTab.ClClass) THEN
- 3776                                               IF hasR THEN SemError(230) END;
- 3777                                               reps := 1;
- 3778                                               IF hasB THEN
- 3779                                                 IF SymTab.ConstInt(q2, v2)
- 3780   AND (v2 >= 1) THEN
- 3781                                                   reps := v2
- 3782                                                 ELSE SemError(230)
- 3783                                                 END
- 3784                                               END;
- 3785                                               k := 0;
- 3786                                               WHILE k < reps DO
- 3787                                                 QbeGen.CtorElem(qe);
- 3788                                                 INC(k)
- 3789                                               END
- 3790                                             END; .)
- 3791                                          (. AST.SetChild(node,
- 3792                                               AST.NChild(node), astEl); .) .
- 3793    SetElem<st: SymTab.TypeIndex; sq: QbeGen.QVal; node: AST.Node>         (. VAR et, et2: SymTab.TypeIndex;
- 3794                                               qe, q2: QbeGen.QVal;
- 3795                                               v, v2: INTEGER;
- 3796                                               lo: INTEGER;
- 3797                                               span: CARDINAL;
- 3798                                               cl, cl2: INTEGER;
- 3799                                               hasR: BOOLEAN;
- 3800                                               astEl: AST.Node; .)
- 3801      =                                   (. hasR := FALSE; .)
- 3802        Expr<et, qe> (. astEl := astCur; .)
- 3803        [ ".." Expr<et2, q2>              (. astEl := AST.MakeBin(
- 3804                                               AST.NkSubrange, 0, astEl, astCur);
- 3805                                             hasR := TRUE; .) ]
- 3806                                          (. lo := SymTab.SetBaseLo(st);
- 3807                                             span := SymTab.SetCount(st);
- 3808                                             IF (et = SymTab.InvalidType)
- 3809                                                OR (hasR AND (et2 =
- 3810                                                   SymTab.InvalidType)) THEN
- 3811                                             ELSE cl :=
- 3812                                                    SymTab.ClassOf(et);
- 3813                                               IF hasR THEN
- 3814                                                 cl2 :=
- 3815                                                   SymTab.ClassOf(et2)
- 3816                                               ELSE cl2 := SymTab.ClInt
- 3817                                               END;
- 3818                                               IF NOT SymTab.SetElemClassOk(cl)
- 3819                                                  OR (hasR AND NOT
- 3820                                                     SymTab.SetElemClassOk(cl2))
- 3821                                               THEN
- 3822                                                 SemError(222)
- 3823                                               ELSIF hasR
- 3824   AND SymTab.ConstInt(qe, v)
- 3825   AND SymTab.ConstInt(q2,
- 3826                                                     v2)
- 3827   AND ((v < lo)
- 3828                                                     OR (v2 < lo)
- 3829                                                     OR (v >= lo +
- 3830                                                        VAL(INTEGER, span))
- 3831                                                     OR (v2 >= lo +
- 3832                                                        VAL(INTEGER, span))
- 3833                                                     OR (v > v2)) THEN
- 3834                                                 SemError(222)
- 3835                                                ELSIF hasR THEN
- 3836                                                  QbeGen.SetRange(sq, qe, q2,
- 3837                                                    lo, span)
- 3838                                                ELSIF SymTab.ConstInt(qe,
- 3839                                                        v)
- 3840   AND ((v < lo)
- 3841                                                      OR (v >= lo +
- 3842                                                         VAL(INTEGER,
- 3843                                                           span))) THEN
- 3844                                                  SemError(222)
- 3845                                                ELSE QbeGen.SetBit(sq, qe,
- 3846                                                  lo, span)
- 3847                                               END
- 3848                                             END; .)
- 3849                                          (. AST.SetChild(node,
- 3850                                               AST.NChild(node), astEl); .) .
- 3851    GetIdent<VAR n: SymTab.Name>
- 3852      = ident                             (. LexName(n); .) .
- 3853  
- 3854  END M2.
+ 3630                                                 ELSIF (c1 = SymTab.ClReal)
+ 3631   AND (c2 = SymTab.ClReal) THEN
+ 3632                                                   t := vt
+ 3633                                                 ELSE SemError(230);
+ 3634                                                   t := SymTab.InvalidType
+ 3635                                                 END
+ 3636                                               END
+ 3637                                             END; .)
+ 3638      | "(" Expr<et, q> ")"               (. t := et; astIsLit := TRUE; .)
+ 3639      | SetLit<st, sq>                    (. astIsLit := TRUE; t := st;
+ 3640                                             QbeGen.CopyOp(sq, q); .)
+ 3641      | ( "NOT" | "~" ) Fact<t2, q2>      (. astNot := astCur;
+ 3642                                             IF SymTab.BoolCheck(t2) THEN
+ 3643                                               t := SymTab.BoolType()
+ 3644                                             ELSE SemError(212);
+ 3645                                               t := SymTab.InvalidType END;
+ 3646                                             IF t # SymTab.InvalidType THEN
+ 3647                                               QbeGen.NotQ(q2, q)
+ 3648                                             ELSE QbeGen.CopyOp("0", q)
+ 3649                                             END;
+ 3650                                             astIsLit := TRUE;
+ 3651                                             astCur := AST.MakeUn(
+ 3652                                               AST.NkUnary, AST.OpNot, astNot); .)
+ 3653      )
+ 3654      (. IF NOT astIsLit THEN astCur := AST.NoNode END; .) .
+ 3655    (* Set literals are SET OF [0..255] (8 words); elements validated
+ 3656       0..255 statically when foldable (222 otherwise), runtime trap
+ 3657       for computed elements. Ranges always lower via SetRange. *)
+ 3658    SetLit<VAR t: SymTab.TypeIndex; VAR q: QbeGen.QVal>
+ 3659                                          (. VAR astNode: AST.Node; .)
+ 3660      = "{"                               (. t := SymTab.NewSet(
+ 3661                                               SymTab.NewSubR(0, 255));
+ 3662                                             astNode := AST.MakeNode(AST.NkSetLit);
+ 3663                                             QbeGen.NewSetTemp(8, q);
+ 3664                                             QbeGen.SetZero(q, 8); .)
+ 3665        [ SetElem<t, q, astNode> { "," SetElem<t, q, astNode> } ]
+ 3666        "}"                               (. astCur := astNode; .) .
+ 3667    (* Typed brace constructor: TypeName{ elems } — BITSET{0} (a set)
+ 3668       or ArrayName{...} (an array constructor, GNU Modula-2).  The
+ 3669       declared type sets the width (set) or element type (array). *)
+ 3670    TypedBraceLit<vt: SymTab.TypeIndex; VAR q: QbeGen.QVal>
+ 3671                                          (. VAR nw: CARDINAL;
+ 3672                                               astNode: AST.Node;
+ 3673                                               savedCls: INTEGER; .)
+ 3674      = "{"                               (. savedCls := braceCls;
+ 3675                                             astNode := AST.MakeNode(AST.NkBraceLit);
+ 3676                                             IF vt = SymTab.InvalidType THEN
+ 3677                                               braceCls := -1
+ 3678                                             ELSE braceCls :=
+ 3679                                                    SymTab.ClassOf(vt)
+ 3680                                             END;
+ 3681                                             IF braceCls = SymTab.ClSet THEN
+ 3682                                               IF vt = SymTab.InvalidType THEN
+ 3683                                                 nw := 8
+ 3684                                               ELSE nw := SymTab.SetWords(vt);
+ 3685                                                 IF nw = 0 THEN nw := 8 END
+ 3686                                               END;
+ 3687                                               QbeGen.NewSetTemp(nw, q);
+ 3688                                               QbeGen.SetZero(q, nw)
+ 3689                                             ELSIF (braceCls =
+ 3690                                                    SymTab.ClArray)
+ 3691                                                OR (braceCls =
+ 3692                                                    SymTab.ClRecord)
+ 3693                                                OR (braceCls =
+ 3694                                                    SymTab.ClClass) THEN
+ 3695                                               QbeGen.CtorBegin(vt)
+ 3696                                             ELSE
+ 3697                                               IF vt # SymTab.InvalidType THEN
+ 3698                                                 SemError(230) END;
+ 3699                                               braceCls := -1
+ 3700                                             END; .)
+ 3701        [ BraceElem<vt, q, astNode> { "," BraceElem<vt, q, astNode> } ]
+ 3702        "}"                               (. IF (braceCls = SymTab.ClArray)
+ 3703                                                OR (braceCls =
+ 3704                                                   SymTab.ClRecord)
+ 3705                                                OR (braceCls =
+ 3706                                                   SymTab.ClClass) THEN
+ 3707                                               QbeGen.CtorEnd(q)
+ 3708                                             ELSIF braceCls # SymTab.ClSet THEN
+ 3709                                               QbeGen.CopyOp("0", q)
+ 3710                                             END;
+ 3711                                             braceCls := savedCls; .)
+ 3712                                          (. astCur := astNode; .) .
+ 3713    BraceElem<vt: SymTab.TypeIndex; VAR sq: QbeGen.QVal; node: AST.Node>
+ 3714                                          (. VAR et, et2: SymTab.TypeIndex;
+ 3715                                               qe, q2: QbeGen.QVal;
+ 3716                                               v, v2, reps, k: INTEGER;
+ 3717                                               elem: SymTab.TypeIndex;
+ 3718                                               lo: INTEGER;
+ 3719                                               span: CARDINAL;
+ 3720                                               cl, cl2: INTEGER;
+ 3721                                               hasR, hasB: BOOLEAN;
+ 3722                                               astEl: AST.Node; .)
+ 3723      =                                   (. hasR := FALSE; hasB := FALSE; .)
+ 3724        Expr<et, qe> (. astEl := astCur; .)
+ 3725        [ ".." Expr<et2, q2>              (. astEl := AST.MakeBin(
+ 3726                                               AST.NkSubrange, 0, astEl, astCur);
+ 3727                                             hasR := TRUE; .) ]
+ 3728        [ "BY" Expr<et2, q2>              (. hasB := TRUE; .) ]
+ 3729                                          (. IF braceCls = SymTab.ClSet THEN
+ 3730                                               IF hasB THEN SemError(230) END;
+ 3731                                               lo := SymTab.SetBaseLo(vt);
+ 3732                                               span := SymTab.SetCount(vt);
+ 3733                                               IF (et = SymTab.InvalidType)
+ 3734                                                  OR (hasR AND (et2 =
+ 3735                                                     SymTab.InvalidType)) THEN
+ 3736                                               ELSE cl :=
+ 3737                                                      SymTab.ClassOf(et);
+ 3738                                                 IF hasR THEN
+ 3739                                                   cl2 :=
+ 3740                                                     SymTab.ClassOf(et2)
+ 3741                                                 ELSE cl2 := SymTab.ClInt
+ 3742                                                 END;
+ 3743                                                 IF NOT SymTab.SetElemClassOk(cl)
+ 3744                                                    OR (hasR AND NOT
+ 3745                                                       SymTab.SetElemClassOk(cl2))
+ 3746                                                 THEN
+ 3747                                                   SemError(222)
+ 3748                                                 ELSIF hasR
+ 3749   AND SymTab.ConstInt(qe, v)
+ 3750   AND SymTab.ConstInt(q2,
+ 3751                                                       v2)
+ 3752   AND ((v < lo)
+ 3753                                                       OR (v2 < lo)
+ 3754                                                       OR (v >= lo +
+ 3755                                                          VAL(INTEGER, span))
+ 3756                                                       OR (v2 >= lo +
+ 3757                                                          VAL(INTEGER, span))
+ 3758                                                       OR (v > v2)) THEN
+ 3759                                                   SemError(222)
+ 3760                                                  ELSIF hasR THEN
+ 3761                                                    QbeGen.SetRange(sq, qe, q2,
+ 3762                                                      lo, span)
+ 3763                                                  ELSIF SymTab.ConstInt(qe,
+ 3764                                                          v)
+ 3765   AND ((v < lo)
+ 3766                                                        OR (v >= lo +
+ 3767                                                           VAL(INTEGER,
+ 3768                                                             span))) THEN
+ 3769                                                    SemError(222)
+ 3770                                                  ELSE QbeGen.SetBit(sq, qe,
+ 3771                                                    lo, span)
+ 3772                                                 END
+ 3773                                               END
+ 3774                                             ELSIF (braceCls = SymTab.ClArray)
+ 3775                                                OR (braceCls =
+ 3776                                                   SymTab.ClRecord)
+ 3777                                                OR (braceCls =
+ 3778                                                   SymTab.ClClass) THEN
+ 3779                                               IF hasR THEN SemError(230) END;
+ 3780                                               reps := 1;
+ 3781                                               IF hasB THEN
+ 3782                                                 IF SymTab.ConstInt(q2, v2)
+ 3783   AND (v2 >= 1) THEN
+ 3784                                                   reps := v2
+ 3785                                                 ELSE SemError(230)
+ 3786                                                 END
+ 3787                                               END;
+ 3788                                               k := 0;
+ 3789                                               WHILE k < reps DO
+ 3790                                                 QbeGen.CtorElem(qe);
+ 3791                                                 INC(k)
+ 3792                                               END
+ 3793                                             END; .)
+ 3794                                          (. AST.SetChild(node,
+ 3795                                               AST.NChild(node), astEl); .) .
+ 3796    SetElem<st: SymTab.TypeIndex; sq: QbeGen.QVal; node: AST.Node>         (. VAR et, et2: SymTab.TypeIndex;
+ 3797                                               qe, q2: QbeGen.QVal;
+ 3798                                               v, v2: INTEGER;
+ 3799                                               lo: INTEGER;
+ 3800                                               span: CARDINAL;
+ 3801                                               cl, cl2: INTEGER;
+ 3802                                               hasR: BOOLEAN;
+ 3803                                               astEl: AST.Node; .)
+ 3804      =                                   (. hasR := FALSE; .)
+ 3805        Expr<et, qe> (. astEl := astCur; .)
+ 3806        [ ".." Expr<et2, q2>              (. astEl := AST.MakeBin(
+ 3807                                               AST.NkSubrange, 0, astEl, astCur);
+ 3808                                             hasR := TRUE; .) ]
+ 3809                                          (. lo := SymTab.SetBaseLo(st);
+ 3810                                             span := SymTab.SetCount(st);
+ 3811                                             IF (et = SymTab.InvalidType)
+ 3812                                                OR (hasR AND (et2 =
+ 3813                                                   SymTab.InvalidType)) THEN
+ 3814                                             ELSE cl :=
+ 3815                                                    SymTab.ClassOf(et);
+ 3816                                               IF hasR THEN
+ 3817                                                 cl2 :=
+ 3818                                                   SymTab.ClassOf(et2)
+ 3819                                               ELSE cl2 := SymTab.ClInt
+ 3820                                               END;
+ 3821                                               IF NOT SymTab.SetElemClassOk(cl)
+ 3822                                                  OR (hasR AND NOT
+ 3823                                                     SymTab.SetElemClassOk(cl2))
+ 3824                                               THEN
+ 3825                                                 SemError(222)
+ 3826                                               ELSIF hasR
+ 3827   AND SymTab.ConstInt(qe, v)
+ 3828   AND SymTab.ConstInt(q2,
+ 3829                                                     v2)
+ 3830   AND ((v < lo)
+ 3831                                                     OR (v2 < lo)
+ 3832                                                     OR (v >= lo +
+ 3833                                                        VAL(INTEGER, span))
+ 3834                                                     OR (v2 >= lo +
+ 3835                                                        VAL(INTEGER, span))
+ 3836                                                     OR (v > v2)) THEN
+ 3837                                                 SemError(222)
+ 3838                                                ELSIF hasR THEN
+ 3839                                                  QbeGen.SetRange(sq, qe, q2,
+ 3840                                                    lo, span)
+ 3841                                                ELSIF SymTab.ConstInt(qe,
+ 3842                                                        v)
+ 3843   AND ((v < lo)
+ 3844                                                      OR (v >= lo +
+ 3845                                                         VAL(INTEGER,
+ 3846                                                           span))) THEN
+ 3847                                                  SemError(222)
+ 3848                                                ELSE QbeGen.SetBit(sq, qe,
+ 3849                                                  lo, span)
+ 3850                                               END
+ 3851                                             END; .)
+ 3852                                          (. AST.SetChild(node,
+ 3853                                               AST.NChild(node), astEl); .) .
+ 3854    GetIdent<VAR n: SymTab.Name>
+ 3855      = ident                             (. LexName(n); .) .
+ 3856  
+ 3857  END M2.
 
     0 errors