v3 step 8.1 — Redux sweep of compiler sources + lenient SYSTEM imports (103/103)

compiler/src/M2.atg

@@ -93,7 +93,7 @@ PRODUCTIONS
      table; imports materialize exported names. *)
   DefUnit                               (. VAR m1, m2, pn: SymTab.Name; .)
     = "DEFINITION" "MODULE"
-      GetIdent<m1>                      (. IF ~SymTab.BeginDef(m1) THEN
+      GetIdent<m1>                      (. IF NOT SymTab.BeginDef(m1) THEN
                                              SemError(200) END;
                                            QbeGen.SetModule(m1); .)
       ";"
@@ -102,12 +102,12 @@ PRODUCTIONS
       | ProcHeading<pn> ";"             (. SymTab.CloseProc;
                                              QbeGen.AbortFunc; .) }
       "END"
-      GetIdent<m2>                      (. IF ~SymTab.Equal(m1, m2) THEN
+      GetIdent<m2>                      (. IF NOT SymTab.Equal(m1, m2) THEN
                                              SemError(202) END;
                                            SymTab.EndUnit; .) .
   ImplUnit                              (. VAR m1, m2: SymTab.Name; .)
     = "IMPLEMENTATION" "MODULE"
-      GetIdent<m1>                      (. IF ~SymTab.BeginImpl(m1) THEN
+      GetIdent<m1>                      (. IF NOT SymTab.BeginImpl(m1) THEN
                                              SemError(201) END;
                                            QbeGen.SetModule(m1); .)
       ";"
@@ -116,12 +116,12 @@ PRODUCTIONS
       [ "BEGIN"                         (. QbeGen.BeginInit(m1); .)
         [ StatSeq ]                       (. QbeGen.EndInit; .) ]
       "END"
-      GetIdent<m2>                      (. IF ~SymTab.Equal(m1, m2) THEN
+      GetIdent<m2>                      (. IF NOT SymTab.Equal(m1, m2) THEN
                                              SemError(202) END;
                                            SymTab.EndUnit; .) .
   ProgModule                            (. VAR m1, m2: SymTab.Name; .)
     = "MODULE"
-      GetIdent<m1>                      (. IF ~SymTab.BeginProg(m1) THEN
+      GetIdent<m1>                      (. IF NOT SymTab.BeginProg(m1) THEN
                                              SemError(200) END;
                                            QbeGen.SetModule(m1); .)
       [ Priority ]
@@ -131,7 +131,7 @@ PRODUCTIONS
       [ "BEGIN"                         (. QbeGen.BeginBody; .)
         [ StatSeq ] ]
       "END"
-      GetIdent<m2>                      (. IF ~SymTab.Equal(m1, m2) THEN
+      GetIdent<m2>                      (. IF NOT SymTab.Equal(m1, m2) THEN
                                              SemError(202) END;
                                            QbeGen.EndModule(m1);
                                            SymTab.EndUnit; .) .
@@ -142,7 +142,7 @@ PRODUCTIONS
      lowering waits for step 4, marked by one 230 at END. *)
   NestedModule                          (. VAR m1, m2: SymTab.Name; .)
     = "MODULE"
-      GetIdent<m1>                      (. IF ~SymTab.Enter(m1,
+      GetIdent<m1>                      (. IF NOT SymTab.Enter(m1,
                                              SymTab.KindModule) THEN
                                              SemError(200) END;
                                            SymTab.PushScope; .)
@@ -154,7 +154,7 @@ PRODUCTIONS
       [ "BEGIN"
         [ StatSeq ] ]
       "END"
-      GetIdent<m2>                      (. IF ~SymTab.Equal(m1, m2) THEN
+      GetIdent<m2>                      (. IF NOT SymTab.Equal(m1, m2) THEN
                                              SemError(202) END;
                                            SymTab.PopScope;
                                            SemError(230); .) .
@@ -180,13 +180,16 @@ PRODUCTIONS
     | "IMPORT"
       ImpModList ";" .
   ImpList<mod: SymTab.Name>             (. VAR n: SymTab.Name; .)
+    = ImpName<mod>
+      { "," ImpName<mod> } .
+  (* Pervasive built-ins imported from SYSTEM (e.g. TSIZE) are
+     accepted and ignored: the built-in applies regardless. *)
+  ImpName<mod: SymTab.Name>             (. VAR n: SymTab.Name; .)
     = GetIdent<n>                       (. IF SymTab.ModKnown(mod)
-                                             & ~SymTab.ImportFrom(mod, n) THEN
+                                             AND NOT SymTab.ImportFrom(mod, n) THEN
                                              SemError(201) END; .)
-      { ","
-        GetIdent<n>                     (. IF SymTab.ModKnown(mod)
-                                             & ~SymTab.ImportFrom(mod, n) THEN
-                                             SemError(201) END; .) } .
+    | ( "TSIZE" | "SIZE" | "ADR" | "HIGH" | "LEN"
+      | "CHR" | "ORD" | "VAL" | "ABS" | "INC" | "DEC" ) .
   ImpModList                            (. VAR n: SymTab.Name; .)
     = GetIdent<n>
       { "," GetIdent<n> } .
@@ -201,7 +204,7 @@ PRODUCTIONS
                                              t, op: SymTab.TypeIndex; .)
     = GetIdent<n>                       (. op := SymTab.OpaqueBase(n);
                                            IF op = SymTab.InvalidType THEN
-                                             IF ~SymTab.Enter(n,
+                                             IF NOT SymTab.Enter(n,
                                                 SymTab.KindType) THEN
                                                SemError(200) END
                                            END; .)
@@ -211,7 +214,7 @@ PRODUCTIONS
                                            END; .)
       |                                 (. IF op # SymTab.InvalidType THEN
                                              (* stays opaque *)
-                                           ELSIF ~isDef THEN
+                                           ELSIF NOT isDef THEN
                                              SemError(231)
                                            ELSE SymTab.SetSymType(n,
                                              SymTab.NewAlias()) END; .) ) .
@@ -233,7 +236,7 @@ PRODUCTIONS
                                         (. VAR elem: SymTab.TypeIndex;
                                              ok: BOOLEAN; .)
     = "ARRAY"
-      ( "OF" Type<elem, FALSE>          (. IF ~allowOpen THEN
+      ( "OF" Type<elem, FALSE>          (. IF NOT allowOpen THEN
                                              SemError(230) END;
                                            t := SymTab.NewOpenArray(elem); .)
       | "["                             (. SymTab.BoundBegin; ok := TRUE; .)
@@ -255,15 +258,15 @@ PRODUCTIONS
                                          ELSE cl := SymTab.ClassOf(tlo);
                                            cl2 := SymTab.ClassOf(thi);
                                            IF ((cl # SymTab.ClInt)
-                                              & (cl # SymTab.ClChar))
+ AND (cl # SymTab.ClChar))
                                               OR ((cl2 # SymTab.ClInt)
-                                              & (cl2 # SymTab.ClChar)) THEN
+ AND (cl2 # SymTab.ClChar)) THEN
                                              SemError(230); ok := FALSE
-                                           ELSIF ~SymTab.ConstInt(qlo, lo)
-                                              OR ~SymTab.ConstInt(qhi, hi)
+                                           ELSIF NOT SymTab.ConstInt(qlo, lo)
+                                              OR NOT SymTab.ConstInt(qhi, hi)
                                               OR (lo > hi) THEN
                                              SemError(230); ok := FALSE
-                                            ELSIF ~SymTab.BoundAdd(lo, hi) THEN
+                                            ELSIF NOT SymTab.BoundAdd(lo, hi) THEN
                                               SemError(230); ok := FALSE
                                             END;
                                           END; .) .
@@ -306,15 +309,15 @@ PRODUCTIONS
                                              t2: SymTab.TypeIndex; .)
     = RecIdents<rec> ":" Type<t2, FALSE>(. SymTab.FixPendingF(rec, t2); .) .
   RecIdents<rec: SymTab.TypeIndex>      (. VAR n: SymTab.Name; .)
-    = GetIdent<n>                       (. IF ~SymTab.FieldPending(rec,
+    = GetIdent<n>                       (. IF NOT SymTab.FieldPending(rec,
                                              n) THEN
                                              SemError(200) END; .)
-      { "," GetIdent<n>                 (. IF ~SymTab.FieldPending(rec,
+      { "," GetIdent<n>                 (. IF NOT SymTab.FieldPending(rec,
                                              n) THEN
                                              SemError(200) END; .) } .
   TypeIdent<VAR t: SymTab.TypeIndex>    (. VAR n: SymTab.Name;
                                              k: INTEGER; .)
-    = GetIdent<n>                       (. IF ~SymTab.Lookup(n) THEN
+    = GetIdent<n>                       (. IF NOT SymTab.Lookup(n) THEN
                                              SemError(201);
                                              t := SymTab.InvalidType
                                            ELSE k := SymTab.SymKind(n);
@@ -340,8 +343,8 @@ PRODUCTIONS
                                                 SymTab.ClInt) THEN
                                            SemError(230);
                                            t := SymTab.InvalidType
-                                         ELSIF ~SymTab.ConstInt(qlo, lo)
-                                            OR ~SymTab.ConstInt(qhi, hi)
+                                         ELSIF NOT SymTab.ConstInt(qlo, lo)
+                                            OR NOT SymTab.ConstInt(qhi, hi)
                                             OR (lo > hi) THEN
                                            SemError(230);
                                            t := SymTab.InvalidType
@@ -350,11 +353,11 @@ PRODUCTIONS
       "]" .
   Enum<VAR t: SymTab.TypeIndex>         (. VAR n: SymTab.Name; .)
     = "("                               (. t := SymTab.NewEnum(); .)
-      GetIdent<n>                       (. IF ~SymTab.Enter(n,
+      GetIdent<n>                       (. IF NOT SymTab.Enter(n,
                                              SymTab.KindConst) THEN
                                              SemError(200) END;
                                            SymTab.SetSymType(n, t); .)
-      { "," GetIdent<n>                 (. IF ~SymTab.Enter(n,
+      { "," GetIdent<n>                 (. IF NOT SymTab.Enter(n,
                                              SymTab.KindConst) THEN
                                              SemError(200) END;
                                            SymTab.SetSymType(n, t); .) }
@@ -374,7 +377,7 @@ PRODUCTIONS
     = "CLASS" ( "IMPLEMENTATION" ClassImplRest | ClassRest ) .
   ClassRest                             (. VAR cn, m2, pn: SymTab.Name;
                                              ct: SymTab.TypeIndex; .)
-    = GetIdent<cn>                      (. IF ~SymTab.Enter(cn,
+    = GetIdent<cn>                      (. IF NOT SymTab.Enter(cn,
                                              SymTab.KindType) THEN
                                              SemError(200) END;
                                            ct := SymTab.NewClass();
@@ -386,7 +389,7 @@ PRODUCTIONS
       { MethodHeading<pn> ";"           (. SymTab.CloseProc;
                                              QbeGen.AbortFunc; .) }
       "END"
-      GetIdent<m2>                      (. IF ~SymTab.Equal(cn, m2) THEN
+      GetIdent<m2>                      (. IF NOT SymTab.Equal(cn, m2) THEN
                                              SemError(202) END;
                                            SymTab.PopScope;
                                            SemError(230); .) .
@@ -396,7 +399,7 @@ PRODUCTIONS
       ")" .
   Parent1<ct: SymTab.TypeIndex>         (. VAR p: SymTab.Name;
                                              pt: SymTab.TypeIndex; .)
-    = GetIdent<p>                       (. IF ~SymTab.Lookup(p) THEN
+    = GetIdent<p>                       (. IF NOT SymTab.Lookup(p) THEN
                                              SemError(201)
                                            ELSE pt := SymTab.SymType(p);
                                              IF SymTab.ClassOf(pt) #
@@ -408,17 +411,17 @@ PRODUCTIONS
   ClassField<ct: SymTab.TypeIndex>      (. VAR n, rhs: SymTab.Name;
                                              t: SymTab.TypeIndex; .)
     = GetIdent<n>
-      ( "=" GetIdent<rhs>               (. IF ~SymTab.Enter(n,
+      ( "=" GetIdent<rhs>               (. IF NOT SymTab.Enter(n,
                                              SymTab.KindConst) THEN
                                              SemError(200) END;
                                            IF SymTab.Lookup(rhs) THEN
                                              SymTab.SetSymType(n,
                                                SymTab.SymType(rhs))
                                            END; .)
-      |                                 (. IF ~SymTab.FieldPending(ct,
+      |                                 (. IF NOT SymTab.FieldPending(ct,
                                              n) THEN
                                              SemError(200) END; .)
-        { "," GetIdent<n>               (. IF ~SymTab.FieldPending(ct,
+        { "," GetIdent<n>               (. IF NOT SymTab.FieldPending(ct,
                                              n) THEN
                                              SemError(200) END; .) }
         ":" Type<t, FALSE>              (. SymTab.FixPendingF(ct, t); .) ) .
@@ -429,7 +432,7 @@ PRODUCTIONS
                                              SymTab.MarkVirtual END; .) .
   ClassImplRest                         (. VAR cn, m2: SymTab.Name;
                                              ct: SymTab.TypeIndex; .)
-    = GetIdent<cn>                      (. IF ~SymTab.Lookup(cn) THEN
+    = GetIdent<cn>                      (. IF NOT SymTab.Lookup(cn) THEN
                                              SemError(201);
                                              ct := SymTab.InvalidType
                                            ELSE ct := SymTab.SymType(cn);
@@ -441,7 +444,7 @@ PRODUCTIONS
                                            END;
                                            IF ct #
                                               SymTab.InvalidType THEN
-                                             IF ~SymTab.PushClassMembers(
+                                             IF NOT SymTab.PushClassMembers(
                                                     ct) THEN
                                                SemError(230) END
                                            END; .)
@@ -449,7 +452,7 @@ PRODUCTIONS
       [ "BEGIN"
         [ StatSeq ] ]
       "END"
-      GetIdent<m2>                      (. IF ~SymTab.Equal(cn, m2) THEN
+      GetIdent<m2>                      (. IF NOT SymTab.Equal(cn, m2) THEN
                                              SemError(202) END;
                                            SymTab.PopScope;
                                            SemError(230); .) .
@@ -458,7 +461,7 @@ PRODUCTIONS
       MethodHeading<pn> ";"
                                         (. IF (ct #
                                               SymTab.InvalidType)
-                                             & ~SymTab.MethodExists(ct,
+ AND NOT SymTab.MethodExists(ct,
                                                   pn) THEN
                                              SemError(201) END; .)
       ( "FORWARD"                       (. SymTab.MarkFwd;
@@ -473,7 +476,7 @@ PRODUCTIONS
                                              t: SymTab.TypeIndex;
                                              qv: QbeGen.QVal;
                                              cls: INTEGER; .)
-    = GetIdent<n>                       (. IF ~SymTab.Enter(n,
+    = GetIdent<n>                       (. IF NOT SymTab.Enter(n,
                                              SymTab.KindConst) THEN
                                              SemError(200) END; .)
       "="
@@ -481,7 +484,7 @@ PRODUCTIONS
                                            cls := SymTab.ClassOf(t);
                                            IF cls = SymTab.ClStr THEN
                                              SemError(230)
-                                           ELSIF ~QbeGen.IsImm(qv) THEN
+                                           ELSIF NOT QbeGen.IsImm(qv) THEN
                                              SemError(230) END;
                                            QbeGen.DeclConst(n, qv, t); .) .
   VarBlock
@@ -493,15 +496,15 @@ PRODUCTIONS
     = VarIdents ":"
       Type<t, FALSE>                    (. cls := SymTab.ClassOf(t);
                                            IF (t # SymTab.InvalidType)
-                                              & (cls # SymTab.ClInt)
-                                              & (cls # SymTab.ClBool)
-                                              & (cls # SymTab.ClChar)
-                                              & (cls # SymTab.ClReal)
-                                              & (cls # SymTab.ClArray)
-                                              & (cls # SymTab.ClSet)
-                                              & (cls # SymTab.ClRecord)
-                                              & (cls # SymTab.ClPtr)
-                                              & (cls # SymTab.ClLong) THEN
+ AND (cls # SymTab.ClInt)
+ AND (cls # SymTab.ClBool)
+ AND (cls # SymTab.ClChar)
+ AND (cls # SymTab.ClReal)
+ AND (cls # SymTab.ClArray)
+ AND (cls # SymTab.ClSet)
+ AND (cls # SymTab.ClRecord)
+ AND (cls # SymTab.ClPtr)
+ AND (cls # SymTab.ClLong) THEN
                                              SemError(230) END;
                                            IF QbeGen.LocFull() THEN
                                              SemError(233) END;
@@ -513,17 +516,17 @@ PRODUCTIONS
                                            END;
                                            SymTab.FixPending(t); .) .
   VarIdents                             (. VAR n: SymTab.Name; .)
-    = GetIdent<n>                       (. IF ~SymTab.EnterPending(n,
+    = GetIdent<n>                       (. IF NOT SymTab.EnterPending(n,
                                              SymTab.KindVar) THEN
                                              SemError(200) END; .)
       { ","
-        GetIdent<n>                     (. IF ~SymTab.EnterPending(n,
+        GetIdent<n>                     (. IF NOT SymTab.EnterPending(n,
                                              SymTab.KindVar) THEN
                                              SemError(200) END; .) } .
   ParIdents<isV: BOOLEAN>               (. VAR n: SymTab.Name; .)
-    = GetIdent<n>                       (. IF ~SymTab.EnterParam(n, isV) THEN
+    = GetIdent<n>                       (. IF NOT SymTab.EnterParam(n, isV) THEN
                                              SemError(200) END; .)
-      { "," GetIdent<n>                 (. IF ~SymTab.EnterParam(n, isV) THEN
+      { "," GetIdent<n>                 (. IF NOT SymTab.EnterParam(n, isV) THEN
                                              SemError(200) END; .) } .
   (* Procedure headings enter scopes/params/result and buffer the
      QBE header; bodies lower to functions (4.1, module level only).
@@ -532,9 +535,9 @@ PRODUCTIONS
   ProcHeading<VAR pn: SymTab.Name>      (. VAR t: SymTab.TypeIndex;
                                              mg: QbeGen.QVal; .)
     = "PROCEDURE"
-      GetIdent<pn>                      (. IF ~SymTab.EnterProc(pn) THEN
-                                           IF ~SymTab.ReenterProc(pn) THEN
-                                             IF ~SymTab.ResumeProc(pn) THEN
+      GetIdent<pn>                      (. IF NOT SymTab.EnterProc(pn) THEN
+                                           IF NOT SymTab.ReenterProc(pn) THEN
+                                             IF NOT SymTab.ResumeProc(pn) THEN
                                                SemError(200) END
                                              END
                                            END;
@@ -546,7 +549,7 @@ PRODUCTIONS
                                            QbeGen.SetFuncRes(t);
                                            IF (t #
                                               SymTab.InvalidType)
-                                              & ((SymTab.ClassOf(t)
+ AND ((SymTab.ClassOf(t)
                                                  = SymTab.ClArray)
                                               OR (SymTab.ClassOf(t)
                                                  = SymTab.ClRecord)
@@ -571,7 +574,7 @@ PRODUCTIONS
                                                 addresses (no copy):
                                                 same representation as
                                                 VAR formals *)
-                                             IF ~QbeGen.FuncParam(nm,
+                                             IF NOT QbeGen.FuncParam(nm,
                                                   isV
                                                   OR SymTab.IsOpenArray(t),
                                                   t) THEN
@@ -599,7 +602,7 @@ PRODUCTIONS
       [ "BEGIN"
         [ StatSeq ] ]
       "END"
-      GetIdent<m2>                      (. IF ~SymTab.Equal(pn, m2) THEN
+      GetIdent<m2>                      (. IF NOT SymTab.Equal(pn, m2) THEN
                                              SemError(202) END; .) .
   StatSeq
     = Statement { ";" Statement } .
@@ -635,10 +638,10 @@ PRODUCTIONS
       [ "," Expr<et2, qstep> ]
       ")"                               (. IF dt = SymTab.InvalidType THEN
                                            ELSIF (dk # SymTab.KindVar)
-                                              & (dk # SymTab.KindParam)
-                                              & (dk # SymTab.KindField) THEN
+ AND (dk # SymTab.KindParam)
+ AND (dk # SymTab.KindField) THEN
                                              SemError(210)
-                                           ELSIF ~SymTab.IsIntFamily(dt) THEN
+                                           ELSIF NOT SymTab.IsIntFamily(dt) THEN
                                              SemError(211)
                                            ELSE
                                              IF sfx
@@ -674,8 +677,8 @@ PRODUCTIONS
     = "NEW" "(" Design<dt, dk, qd, qn, sfx> ")"
                                         (. IF dt = SymTab.InvalidType THEN
                                            ELSIF (dk # SymTab.KindVar)
-                                              & (dk # SymTab.KindParam)
-                                              & (dk # SymTab.KindField) THEN
+ AND (dk # SymTab.KindParam)
+ AND (dk # SymTab.KindField) THEN
                                              SemError(210)
                                            ELSIF SymTab.ClassOf(dt) #
                                                  SymTab.ClPtr THEN
@@ -703,8 +706,8 @@ PRODUCTIONS
     = "DISPOSE" "(" Design<dt, dk, qd, qn, sfx> ")"
                                         (. IF dt = SymTab.InvalidType THEN
                                            ELSIF (dk # SymTab.KindVar)
-                                              & (dk # SymTab.KindParam)
-                                              & (dk # SymTab.KindField) THEN
+ AND (dk # SymTab.KindParam)
+ AND (dk # SymTab.KindField) THEN
                                              SemError(210)
                                            ELSIF SymTab.ClassOf(dt) #
                                                  SymTab.ClPtr THEN
@@ -747,7 +750,7 @@ PRODUCTIONS
                                         (. IF dt = SymTab.InvalidType THEN
                                            ELSIF (SymTab.ClassOf(dt) #
                                                   SymTab.ClRecord)
-                                              & (SymTab.ClassOf(dt) #
+ AND (SymTab.ClassOf(dt) #
                                                  SymTab.ClClass) THEN
                                              SemError(215)
                                            ELSIF SymTab.PushRecord(dt) THEN
@@ -767,33 +770,33 @@ PRODUCTIONS
     = Design<dt, dk, qd, qn, sfx>
       ( ":="
         Expr<et, qe>                    (. IF (dt # SymTab.InvalidType)
-                                           & (dk # SymTab.KindVar)
-                                           & (dk # SymTab.KindParam)
-                                           & (dk # SymTab.KindField) THEN
+ AND (dk # SymTab.KindVar)
+ AND (dk # SymTab.KindParam)
+ AND (dk # SymTab.KindField) THEN
                                            SemError(210)
-                                         ELSIF ~SymTab.Assignable(et,
+                                         ELSIF NOT SymTab.Assignable(et,
                                                   dt) THEN
                                            SemError(210)
                                          ELSIF (dt # SymTab.InvalidType)
-                                            & (SymTab.ClassOf(dt) =
+ AND (SymTab.ClassOf(dt) =
                                                SymTab.ClClass) THEN
                                            SemError(230) END;
                                          isR := (dt #
                                                  SymTab.InvalidType)
-                                                & (SymTab.ClassOf(dt)
+ AND (SymTab.ClassOf(dt)
                                                    = SymTab.ClReal);
                                          conv := isR
-                                                 & SymTab.IsIntFamily(et);
+ AND SymTab.IsIntFamily(et);
                                          wconv := (dt #
                                                    SymTab.InvalidType)
-                                                  & SymTab.IsLongFamily(dt)
-                                                  & SymTab.IsIntFamily(et);
+ AND SymTab.IsLongFamily(dt)
+ AND SymTab.IsIntFamily(et);
                                          IF ((dk = SymTab.KindVar)
                                              OR (dk = SymTab.KindParam)
                                              OR (dk = SymTab.KindField))
-                                            & (dt # SymTab.InvalidType)
-                                            & (et # SymTab.InvalidType)
-                                            & (SymTab.ClassOf(dt) #
+ AND (dt # SymTab.InvalidType)
+ AND (et # SymTab.InvalidType)
+ AND (SymTab.ClassOf(dt) #
                                                SymTab.ClClass) THEN
                                            IF sfx
                                               OR (dk = SymTab.KindField) THEN
@@ -858,7 +861,7 @@ PRODUCTIONS
                                             here is 233 (was a bare syntax
                                             error before 4.2) *)
                                         (. IF (dk = SymTab.KindProc)
-                                             & ~sfx THEN
+ AND NOT sfx THEN
                                              res0 := SymTab.ProcRes(qn);
                                              IF res0 #
                                                 SymTab.InvalidType THEN
@@ -907,7 +910,7 @@ PRODUCTIONS
                                                SemError(233); ok := FALSE
                                              END
                                            END;
-                                           IF ~ok THEN
+                                           IF NOT ok THEN
                                              t := SymTab.InvalidType;
                                              QbeGen.CopyOp("0", q)
                                            ELSIF want THEN
@@ -939,31 +942,31 @@ PRODUCTIONS
                                               OR (ft =
                                                  SymTab.InvalidType) THEN
                                            ELSIF isV THEN
-                                             IF ~QbeGen.AddrOfVal(qe,
+                                             IF NOT QbeGen.AddrOfVal(qe,
                                                   qa) THEN
                                                SemError(233)
-                                             ELSIF ~SymTab.VarParamOk(at,
+                                             ELSIF NOT SymTab.VarParamOk(at,
                                                       ft) THEN
                                                SemError(233)
-                                             ELSIF ~QbeGen.CallArg(qa,
+                                             ELSIF NOT QbeGen.CallArg(qa,
                                                       "l") THEN
                                                SemError(233)
                                              END
                                            ELSE
-                                             IF ~SymTab.Assignable(at,
+                                             IF NOT SymTab.Assignable(at,
                                                   ft) THEN
                                                SemError(233)
                                              ELSE
                                                conv := (SymTab.ClassOf(
                                                  ft) = SymTab.ClReal)
-                                                 & SymTab.IsIntFamily(at);
+ AND SymTab.IsIntFamily(at);
                                                IF conv THEN
                                                  QbeGen.ConvIR(qe, qt);
-                                                 IF ~QbeGen.CallArg(qt,
+                                                 IF NOT QbeGen.CallArg(qt,
                                                     "d") THEN
                                                    SemError(233)
                                                  END
-                                               ELSIF ~QbeGen.CallArg(qe,
+                                               ELSIF NOT QbeGen.CallArg(qe,
                                                  QbeGen.ArgClass(ft)) THEN
                                                  SemError(233)
                                                END
@@ -974,7 +977,7 @@ PRODUCTIONS
                                                QbeGen.QVal;
                                              hasElse: BOOLEAN; .)
     = "IF"                              (. hasElse := FALSE; .)
-      Expr<t, q>                        (. IF ~SymTab.BoolCheck(t) THEN
+      Expr<t, q>                        (. IF NOT SymTab.BoolCheck(t) THEN
                                              SemError(214) END;
                                            QbeGen.NewLabel(lThen);
                                            QbeGen.NewLabel(lElse);
@@ -984,7 +987,7 @@ PRODUCTIONS
       "THEN" StatSeq                    (. QbeGen.Jmp(lEnd); .)
       { "ELSIF"                         (. QbeGen.EmitLabel(lElse);
                                            QbeGen.NewLabel(lElse); .)
-        Expr<t, q>                      (. IF ~SymTab.BoolCheck(t) THEN
+        Expr<t, q>                      (. IF NOT SymTab.BoolCheck(t) THEN
                                              SemError(214) END;
                                            QbeGen.NewLabel(lThen);
                                            QbeGen.Jnz(q, lThen, lElse);
@@ -1005,7 +1008,7 @@ PRODUCTIONS
                                            QbeGen.NewLabel(lBody);
                                            QbeGen.NewLabel(lEnd);
                                            QbeGen.EmitLabel(lTop); .)
-      Expr<t, q>                        (. IF ~SymTab.BoolCheck(t) THEN
+      Expr<t, q>                        (. IF NOT SymTab.BoolCheck(t) THEN
                                              SemError(214) END;
                                            QbeGen.Jnz(q, lBody, lEnd);
                                            QbeGen.EmitLabel(lBody); .)
@@ -1017,7 +1020,7 @@ PRODUCTIONS
                                            QbeGen.NewLabel(lEnd);
                                            QbeGen.EmitLabel(lTop); .)
       StatSeq
-      "UNTIL" Expr<t, q>                (. IF ~SymTab.BoolCheck(t) THEN
+      "UNTIL" Expr<t, q>                (. IF NOT SymTab.BoolCheck(t) THEN
                                              SemError(214) END;
                                            QbeGen.Jnz(q, lEnd, lTop);
                                            QbeGen.EmitLabel(lEnd); .) .
@@ -1044,29 +1047,29 @@ PRODUCTIONS
                                              ok: BOOLEAN; .)
     = "FOR"                             (. by := 1; .)
       GetIdent<lv>                      (. ok := SymTab.Lookup(lv);
-                                           IF ~ok THEN
+                                           IF NOT ok THEN
                                              SemError(201)
                                            ELSIF (SymTab.SymKind(lv) #
                                                   SymTab.KindVar)
-                                              & (SymTab.SymKind(lv) #
+ AND (SymTab.SymKind(lv) #
                                                  SymTab.KindParam) THEN
                                              SemError(220); ok := FALSE
-                                           ELSIF ~SymTab.IsIntFamily(
+                                           ELSIF NOT SymTab.IsIntFamily(
                                                    SymTab.SymType(lv)) THEN
                                              SemError(220); ok := FALSE
                                            END; .)
-      ":=" Expr<tlo, qlo>               (. IF ~SymTab.IsIntFamily(tlo) THEN
+      ":=" Expr<tlo, qlo>               (. IF NOT SymTab.IsIntFamily(tlo) THEN
                                              SemError(220); ok := FALSE
                                            END; .)
-      "TO" Expr<thi, qhi>               (. IF ~SymTab.IsIntFamily(thi) THEN
+      "TO" Expr<thi, qhi>               (. IF NOT SymTab.IsIntFamily(thi) THEN
                                              SemError(220); ok := FALSE
                                            END; .)
       [ "BY" Expr<tby, qby>             (. IF (tby #
                                              SymTab.InvalidType)
-                                            & ~SymTab.IsIntFamily(tby) THEN
+ AND NOT SymTab.IsIntFamily(tby) THEN
                                              SemError(220); ok := FALSE
                                            END;
-                                           IF ~SymTab.ConstInt(qby, by) THEN
+                                           IF NOT SymTab.ConstInt(qby, by) THEN
                                              SemError(230); by := 1
                                            ELSIF by = 0 THEN
                                              SemError(220); by := 1
@@ -1128,21 +1131,21 @@ PRODUCTIONS
                                              lNext: QbeGen.QVal; .)
     = Expr<t2, q2>                      (. IF (t2 #
                                              SymTab.InvalidType)
-                                            & (tsel #
+ AND (tsel #
                                                SymTab.InvalidType)
-                                            & ((SymTab.ClassOf(t2) =
+ AND ((SymTab.ClassOf(t2) =
                                                 SymTab.ClSet)
                                                OR (SymTab.ClassOf(tsel) =
                                                    SymTab.ClSet)) THEN
                                              SemError(230)
                                            ELSIF (t2 #
                                              SymTab.InvalidType)
-                                            & (tsel #
+ AND (tsel #
                                                SymTab.InvalidType)
-                                            & ~SymTab.EqCheck(t2,
+ AND NOT SymTab.EqCheck(t2,
                                                  tsel) THEN
                                              SemError(213) END;
-                                           IF ~QbeGen.IsImm(q2) THEN
+                                           IF NOT QbeGen.IsImm(q2) THEN
                                              SemError(230);
                                              QbeGen.CopyOp("0", q2)
                                            END;
@@ -1153,12 +1156,12 @@ PRODUCTIONS
                                            QbeGen.EmitLabel(lNext); .)
       [ ".." Expr<t3, q3>               (. IF (t3 #
                                              SymTab.InvalidType)
-                                            & (tsel #
+ AND (tsel #
                                                SymTab.InvalidType)
-                                            & ~SymTab.EqCheck(t3,
+ AND NOT SymTab.EqCheck(t3,
                                                  tsel) THEN
                                              SemError(213) END;
-                                           IF ~QbeGen.IsImm(q3) THEN
+                                           IF NOT QbeGen.IsImm(q3) THEN
                                              SemError(230);
                                              QbeGen.CopyOp("0", q3)
                                            END;
@@ -1179,10 +1182,10 @@ PRODUCTIONS
     = "RETURN"                          (. hadE := FALSE; .)
       [ Expr<t, q>                      (. hadE := TRUE; .) ]
                                         (. conv := FALSE;
-                                           IF ~SymTab.InProc() THEN
+                                           IF NOT SymTab.InProc() THEN
                                              SemError(232)
                                            ELSE res := SymTab.CurRes();
-                                             IF ~hadE THEN
+                                             IF NOT hadE THEN
                                                IF res #
                                                   SymTab.InvalidType THEN
                                                  SemError(232)
@@ -1193,13 +1196,13 @@ PRODUCTIONS
                                                     SymTab.InvalidType)
                                                 OR (t #
                                                     SymTab.InvalidType)
-                                                & ~SymTab.Assignable(t,
+ AND NOT SymTab.Assignable(t,
                                                      res) THEN
                                                SemError(232)
                                              ELSE
                                                conv := (SymTab.ClassOf(
                                                  res) = SymTab.ClReal)
-                                                 & SymTab.IsIntFamily(t);
+ AND SymTab.IsIntFamily(t);
                                                IF conv THEN
                                                  QbeGen.ConvIR(q, qt);
                                                  QbeGen.EmitRet(qt, TRUE)
@@ -1226,7 +1229,7 @@ PRODUCTIONS
                                              qb: QbeGen.QVal; .)
     = GetIdent<n>                       (. QbeGen.CopyOp(n, qn);
                                            sfx := FALSE;
-                                           IF ~SymTab.Lookup(n) THEN
+                                           IF NOT SymTab.Lookup(n) THEN
                                              SemError(201);
                                              t := SymTab.InvalidType;
                                              k := -1;
@@ -1251,7 +1254,7 @@ PRODUCTIONS
                                                    SymTab.ClassOf(t);
                                                  IF (t #
                                                      SymTab.InvalidType)
-                                                    & ((cls = SymTab.ClInt)
+ AND ((cls = SymTab.ClInt)
                                                     OR (cls
                                                         = SymTab.ClChar)
                                                     OR (cls
@@ -1333,8 +1336,8 @@ PRODUCTIONS
                                                  SymTab.ClArray THEN
                                              SemError(217);
                                              t := SymTab.InvalidType
-                                           ELSIF ~SymTab.IsIntFamily(it)
-                                              & (SymTab.ClassOf(it) #
+                                           ELSIF NOT SymTab.IsIntFamily(it)
+ AND (SymTab.ClassOf(it) #
                                                  SymTab.ClChar) THEN
                                              SemError(218);
                                              t := SymTab.InvalidType
@@ -1369,8 +1372,8 @@ PRODUCTIONS
                                                  SymTab.ClArray THEN
                                              SemError(217);
                                              t := SymTab.InvalidType
-                                           ELSIF ~SymTab.IsIntFamily(it)
-                                              & (SymTab.ClassOf(it) #
+                                           ELSIF NOT SymTab.IsIntFamily(it)
+ AND (SymTab.ClassOf(it) #
                                                  SymTab.ClChar) THEN
                                              SemError(218);
                                              t := SymTab.InvalidType
@@ -1404,7 +1407,7 @@ PRODUCTIONS
                                         (. IF k = SymTab.KindModule THEN
                                              (* qualified L.x: materialize
                                                 the export, then load it *)
-                                             IF ~SymTab.MaterializeAlias(n,
+                                             IF NOT SymTab.MaterializeAlias(n,
                                                   fn, mal) THEN
                                                SemError(201);
                                                t := SymTab.InvalidType;
@@ -1418,7 +1421,7 @@ PRODUCTIONS
                                                  (* call: ArgList supplies
                                                     the value *)
                                                  QbeGen.CopyOp("0", q)
-                                               ELSIF ~QbeGen.LoadDesignator(
+                                               ELSIF NOT QbeGen.LoadDesignator(
                                                     mal, t, k, q) THEN
                                                  SemError(230);
                                                  QbeGen.CopyOp("0", q)
@@ -1427,11 +1430,11 @@ PRODUCTIONS
                                            ELSIF t = SymTab.InvalidType THEN
                                            ELSIF (SymTab.ClassOf(t) #
                                                   SymTab.ClRecord)
-                                              & (SymTab.ClassOf(t) #
+ AND (SymTab.ClassOf(t) #
                                                  SymTab.ClClass) THEN
                                              SemError(215);
                                              t := SymTab.InvalidType
-                                           ELSIF ~SymTab.FieldExists(t,
+                                           ELSIF NOT SymTab.FieldExists(t,
                                                     fn) THEN
                                              SemError(216);
                                              t := SymTab.InvalidType
@@ -1502,8 +1505,8 @@ PRODUCTIONS
                t := SymTab.BoolType(); QbeGen.CopyOp("0", q)
              ELSIF (SymTab.ClassOf(t) = SymTab.ClPtr)
                 OR (SymTab.ClassOf(t2) = SymTab.ClPtr) THEN
-               IF (op # SymTab.OpEq) & (op # SymTab.OpNeq1)
-                  & (op # SymTab.OpNeq2) THEN
+               IF (op # SymTab.OpEq) AND (op # SymTab.OpNeq1)
+ AND (op # SymTab.OpNeq2) THEN
                  SemError(213); t := SymTab.InvalidType;
                  QbeGen.CopyOp("0", q)
                ELSE
@@ -1563,7 +1566,7 @@ PRODUCTIONS
                                          END; .)
       { AddOp<op> Term<t2, q2>
         (. IF op = SymTab.OpOr THEN
-             IF SymTab.BoolCheck(t) & SymTab.BoolCheck(t2) THEN
+             IF SymTab.BoolCheck(t) AND SymTab.BoolCheck(t2) THEN
                t := SymTab.BoolType()
              ELSE SemError(212); t := SymTab.InvalidType END;
              IF t # SymTab.InvalidType THEN
@@ -1572,9 +1575,9 @@ PRODUCTIONS
                QbeGen.CopyOp(qt, q)
              ELSE QbeGen.CopyOp("0", q)
              END
-           ELSIF (t # SymTab.InvalidType) & (t2 # SymTab.InvalidType)
-              & (SymTab.ClassOf(t) = SymTab.ClSet)
-              & (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
+           ELSIF (t # SymTab.InvalidType) AND (t2 # SymTab.InvalidType)
+ AND (SymTab.ClassOf(t) = SymTab.ClSet)
+ AND (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
              lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
              mw := lw;
              IF rw > mw THEN mw := rw END;
@@ -1632,7 +1635,7 @@ PRODUCTIONS
                                              lw, rw, mw: CARDINAL; .)
     = Fact<t, q> { MulOp<op> Fact<t2, q2>
       (. IF op = SymTab.OpAnd THEN
-           IF SymTab.BoolCheck(t) & SymTab.BoolCheck(t2) THEN
+           IF SymTab.BoolCheck(t) AND SymTab.BoolCheck(t2) THEN
              t := SymTab.BoolType()
            ELSE SemError(212); t := SymTab.InvalidType END;
            IF t # SymTab.InvalidType THEN
@@ -1641,9 +1644,9 @@ PRODUCTIONS
              QbeGen.CopyOp(qt, q)
            ELSE QbeGen.CopyOp("0", q)
            END
-         ELSIF (t # SymTab.InvalidType) & (t2 # SymTab.InvalidType)
-            & (SymTab.ClassOf(t) = SymTab.ClSet)
-            & (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
+         ELSIF (t # SymTab.InvalidType) AND (t2 # SymTab.InvalidType)
+ AND (SymTab.ClassOf(t) = SymTab.ClSet)
+ AND (SymTab.ClassOf(t2) = SymTab.ClSet) THEN
            lw := SymTab.SetWords(t); rw := SymTab.SetWords(t2);
            mw := lw;
            IF rw > mw THEN mw := rw END;
@@ -1760,9 +1763,9 @@ PRODUCTIONS
                                                QbeGen.NoteAddr(q, qa)
                                              END
                                            ELSIF sfx
-                                              & (dt #
+ AND (dt #
                                                  SymTab.InvalidType)
-                                              & ((SymTab.ClassOf(dt) =
+ AND ((SymTab.ClassOf(dt) =
                                                   SymTab.ClArray)
                                                  OR (SymTab.ClassOf(dt) =
                                                      SymTab.ClSet)
@@ -1773,15 +1776,15 @@ PRODUCTIONS
       [ ArgList<qn, TRUE, ct2, q2, called>
                                         (. t := ct2;
                                            QbeGen.CopyOp(q2, q); .) ]
-                                        (. IF ~called
-                                             & (dk = SymTab.KindProc) THEN
+                                        (. IF NOT called
+ AND (dk = SymTab.KindProc) THEN
                                              (* bare zero-arg function
                                                 call (parentheses may be
                                                 omitted); a proper or
                                                 parameterised proc here
                                                 is 230 *)
                                              IF (SymTab.ProcNPar(qn) = 0)
-                                                & (SymTab.ProcRes(qn) #
+ AND (SymTab.ProcRes(qn) #
                                                    SymTab.InvalidType) THEN
                                                QbeGen.Mangled(qn,
                                                  SymTab.ProcUid(qn), qm0);
@@ -1850,25 +1853,25 @@ PRODUCTIONS
                                            END; .)
     | "CHR" "(" Expr<et, q> ")"
                                         (. IF (et # SymTab.InvalidType)
-                                             & ~SymTab.IsIntFamily(et) THEN
+ AND NOT SymTab.IsIntFamily(et) THEN
                                              SemError(211) END;
                                            t := SymTab.CharType(); .)
     | "ORD" "(" Expr<et, q> ")"
                                         (. IF et # SymTab.InvalidType THEN
                                              IF (SymTab.ClassOf(et) #
                                                  SymTab.ClChar)
-                                                & (SymTab.ClassOf(et) #
+ AND (SymTab.ClassOf(et) #
                                                    SymTab.ClBool)
-                                                & (SymTab.ClassOf(et) #
+ AND (SymTab.ClassOf(et) #
                                                    SymTab.ClEnum)
-                                                & ~SymTab.IsIntFamily(et) THEN
+ AND NOT SymTab.IsIntFamily(et) THEN
                                                SemError(211) END
                                            END;
                                            t := SymTab.IntType(); .)
     | "ABS" "(" Expr<et, q> ")"
                                         (. IF (et # SymTab.InvalidType)
-                                             & ~SymTab.IsIntFamily(et)
-                                             & (SymTab.ClassOf(et) #
+ AND NOT SymTab.IsIntFamily(et)
+ AND (SymTab.ClassOf(et) #
                                                 SymTab.ClReal) THEN
                                              SemError(211)
                                            ELSE QbeGen.AbsQ(q, qa,
@@ -1877,7 +1880,7 @@ PRODUCTIONS
                                            END;
                                            t := et; .)
     | "VAL" "(" GetIdent<vn> "," Expr<et, q> ")"
-                                        (. IF ~SymTab.Lookup(vn) THEN
+                                        (. IF NOT SymTab.Lookup(vn) THEN
                                              SemError(201);
                                              t := SymTab.InvalidType
                                            ELSE vt := SymTab.SymType(vn);
@@ -1896,7 +1899,7 @@ PRODUCTIONS
                                                       SymTab.ClBool)
                                                    OR (c1 =
                                                       SymTab.ClEnum))
-                                                  & ((c2 = SymTab.ClInt)
+ AND ((c2 = SymTab.ClInt)
                                                    OR (c2 =
                                                       SymTab.ClChar)
                                                    OR (c2 =
@@ -1905,10 +1908,10 @@ PRODUCTIONS
                                                       SymTab.ClEnum)) THEN
                                                  t := vt
                                                ELSIF (c1 = SymTab.ClPtr)
-                                                  & (c2 = SymTab.ClPtr) THEN
+ AND (c2 = SymTab.ClPtr) THEN
                                                  t := vt
                                                ELSIF (c1 = SymTab.ClReal)
-                                                  & (c2 = SymTab.ClReal) THEN
+ AND (c2 = SymTab.ClReal) THEN
                                                  t := vt
                                                ELSE SemError(230);
                                                  t := SymTab.InvalidType
@@ -1949,7 +1952,7 @@ PRODUCTIONS
                                         (. lo := SymTab.SetBaseLo(st);
                                            span := SymTab.SetCount(st);
                                            IF (et = SymTab.InvalidType)
-                                              OR (hasR & (et2 =
+                                              OR (hasR AND (et2 =
                                                  SymTab.InvalidType)) THEN
                                            ELSE cl :=
                                                   SymTab.ClassOf(et);
@@ -1959,21 +1962,21 @@ PRODUCTIONS
                                              ELSE cl2 := SymTab.ClInt
                                              END;
                                              IF ((cl # SymTab.ClInt)
-                                                & (cl # SymTab.ClChar)
-                                                & (cl # SymTab.ClBool))
-                                                OR (hasR &
+ AND (cl # SymTab.ClChar)
+ AND (cl # SymTab.ClBool))
+                                                OR (hasR AND 
                                                    ((cl2
                                                      # SymTab.ClInt)
-                                                   & (cl2
+ AND (cl2
                                                       # SymTab.ClChar)
-                                                   & (cl2
+ AND (cl2
                                                       # SymTab.ClBool))) THEN
                                                SemError(222)
                                              ELSIF hasR
-                                                & SymTab.ConstInt(qe, v)
-                                                & SymTab.ConstInt(q2,
+ AND SymTab.ConstInt(qe, v)
+ AND SymTab.ConstInt(q2,
                                                    v2)
-                                                & ((v < lo)
+ AND ((v < lo)
                                                    OR (v2 < lo)
                                                    OR (v >= lo +
                                                       VAL(INTEGER, span))
@@ -1986,7 +1989,7 @@ PRODUCTIONS
                                                   lo, span)
                                               ELSIF SymTab.ConstInt(qe,
                                                       v)
-                                                 & ((v < lo)
+ AND ((v < lo)
                                                     OR (v >= lo +
                                                        VAL(INTEGER,
                                                          span))) THEN

compiler/src/QbeGen.mod

@@ -76,7 +76,7 @@ PROCEDURE Len (s: ARRAY OF CHAR): CARDINAL;
   VAR i : CARDINAL;
   BEGIN
     i := 0;
-    WHILE (i < HIGH(s)) & (s[i] # 0C) DO INC(i) END;
+    WHILE (i < HIGH(s)) AND (s[i] # CHR(0)) DO INC(i) END;
     RETURN i
   END Len;
 
@@ -84,22 +84,22 @@ PROCEDURE Cpy (VAR d: ARRAY OF CHAR; s: ARRAY OF CHAR);
   VAR i : CARDINAL;
   BEGIN
     i := 0;
-    WHILE (i < HIGH(d)) & (i < HIGH(s)) & (s[i] # 0C) DO
+    WHILE (i < HIGH(d)) AND (i < HIGH(s)) AND (s[i] # CHR(0)) DO
       d[i] := s[i]; INC(i)
     END;
-    IF i <= HIGH(d) THEN d[i] := 0C END
+    IF i <= HIGH(d) THEN d[i] := CHR(0) END
   END Cpy;
 
 PROCEDURE App (VAR d: ARRAY OF CHAR; s: ARRAY OF CHAR);
   VAR i, j : CARDINAL;
   BEGIN
     i := 0;
-    WHILE (i <= HIGH(d)) & (d[i] # 0C) DO INC(i) END;
+    WHILE (i <= HIGH(d)) AND (d[i] # CHR(0)) DO INC(i) END;
     j := 0;
-    WHILE (i < HIGH(d)) & (j < HIGH(s)) & (s[j] # 0C) DO
+    WHILE (i < HIGH(d)) AND (j < HIGH(s)) AND (s[j] # CHR(0)) DO
       d[i] := s[j]; INC(i); INC(j)
     END;
-    IF i <= HIGH(d) THEN d[i] := 0C END
+    IF i <= HIGH(d) THEN d[i] := CHR(0) END
   END App;
 
 PROCEDURE BufApp (VAR buf: ARRAY OF CHAR; VAR used: CARDINAL;
@@ -107,13 +107,13 @@ PROCEDURE BufApp (VAR buf: ARRAY OF CHAR; VAR used: CARDINAL;
   VAR j : CARDINAL;
   BEGIN
     j := 0;
-    WHILE (used < HIGH(buf)) & (j <= HIGH(s)) & (s[j] # 0C) DO
+    WHILE (used < HIGH(buf)) AND (j <= HIGH(s)) AND (s[j] # CHR(0)) DO
       buf[used] := s[j]; INC(used); INC(j)
     END;
-    IF eol & (used < HIGH(buf)) THEN
+    IF eol AND (used < HIGH(buf)) THEN
       buf[used] := CHR(10); INC(used)
     END;
-    IF used <= HIGH(buf) THEN buf[used] := 0C END
+    IF used <= HIGH(buf) THEN buf[used] := CHR(0) END
   END BufApp;
 
 PROCEDURE WEmit (s: ARRAY OF CHAR; eol: BOOLEAN);
@@ -122,7 +122,7 @@ PROCEDURE WEmit (s: ARRAY OF CHAR; eol: BOOLEAN);
    functions, so nested bodies hoist until EndModule). *)
   VAR b, u, j : CARDINAL;
   BEGIN
-    IF ~opened OR noEmit THEN RETURN END;
+    IF NOT opened OR noEmit THEN RETURN END;
     IF outSel = 0 THEN
       BufApp(sessBuf, sessUsed, s, eol);
       RETURN
@@ -131,13 +131,13 @@ PROCEDURE WEmit (s: ARRAY OF CHAR; eol: BOOLEAN);
     IF b > HIGH(nestBufs) THEN b := HIGH(nestBufs) END;
     u := nestUsed[b];
     j := 0;
-    WHILE (u < HIGH(nestBufs[b])) & (j <= HIGH(s)) & (s[j] # 0C) DO
+    WHILE (u < HIGH(nestBufs[b])) AND (j <= HIGH(s)) AND (s[j] # CHR(0)) DO
       nestBufs[b][u] := s[j]; INC(u); INC(j)
     END;
-    IF eol & (u < HIGH(nestBufs[b])) THEN
+    IF eol AND (u < HIGH(nestBufs[b])) THEN
       nestBufs[b][u] := CHR(10); INC(u)
     END;
-    IF u <= HIGH(nestBufs[b]) THEN nestBufs[b][u] := 0C END;
+    IF u <= HIGH(nestBufs[b]) THEN nestBufs[b][u] := CHR(0) END;
     nestUsed[b] := u
   END WEmit;
 
@@ -178,7 +178,7 @@ PROCEDURE Wc (c: CHAR);
 (* Writes a single class character (w/d/l). *)
   VAR s : ARRAY [0 .. 1] OF CHAR;
   BEGIN
-    s[0] := c; s[1] := 0C;
+    s[0] := c; s[1] := CHR(0);
     W(s)
   END Wc;
 
@@ -189,14 +189,14 @@ PROCEDURE AppNum (VAR d: ARRAY OF CHAR; v: CARDINAL);
   BEGIN
     n := 0;
     IF v = 0 THEN buf[0] := "0"; n := 1 END;
-    WHILE (v > 0) & (n <= HIGH(buf)) DO
+    WHILE (v > 0) AND (n <= HIGH(buf)) DO
       buf[n] := CHR(ORD("0") + v MOD 10); v := v DIV 10; INC(n)
     END;
     i := n;
     WHILE i > 0 DO
       DEC(i);
       L := Len(d);
-      IF L < HIGH(d) THEN d[L] := buf[i]; d[L + 1] := 0C END
+      IF L < HIGH(d) THEN d[L] := buf[i]; d[L + 1] := CHR(0) END
     END
   END AppNum;
 
@@ -263,28 +263,28 @@ PROCEDURE IntStr (v: INTEGER; VAR s: QVal);
     IF neg THEN mag := VAL(CARDINAL, -v) ELSE mag := VAL(CARDINAL, v) END;
     n := 0;
     IF mag = 0 THEN buf[0] := "0"; n := 1 END;
-    WHILE (mag > 0) & (n < HIGH(buf)) DO
+    WHILE (mag > 0) AND (n < HIGH(buf)) DO
       buf[n] := CHR(ORD("0") + mag MOD 10); mag := mag DIV 10; INC(n)
     END;
     i := 0;
     WHILE i < n DIV 2 DO
       t := buf[i]; buf[i] := buf[n - 1 - i]; buf[n - 1 - i] := t; INC(i)
     END;
-    s[0] := 0C;
+    s[0] := CHR(0);
     IF neg THEN App(s, "-") END;
     i := 0;
     WHILE i < n DO
       L := Len(s);
-      IF L < HIGH(s) THEN s[L] := buf[i]; s[L + 1] := 0C END;
+      IF L < HIGH(s) THEN s[L] := buf[i]; s[L + 1] := CHR(0) END;
       INC(i)
     END
   END IntStr;
 
 PROCEDURE HexVal (ch: CHAR): INTEGER;
   BEGIN
-    IF (ch >= "0") & (ch <= "9") THEN RETURN ORD(ch) - ORD("0") END;
-    IF (ch >= "A") & (ch <= "F") THEN RETURN ORD(ch) - ORD("A") + 10 END;
-    IF (ch >= "a") & (ch <= "f") THEN RETURN ORD(ch) - ORD("a") + 10 END;
+    IF (ch >= "0") AND (ch <= "9") THEN RETURN ORD(ch) - ORD("0") END;
+    IF (ch >= "A") AND (ch <= "F") THEN RETURN ORD(ch) - ORD("A") + 10 END;
+    IF (ch >= "a") AND (ch <= "f") THEN RETURN ORD(ch) - ORD("a") + 10 END;
     RETURN 0
   END HexVal;
 
@@ -294,8 +294,8 @@ PROCEDURE NormInt (s: ARRAY OF CHAR; VAR d: QVal);
     v : INTEGER;
   BEGIN
     n := Len(s);
-    IF (n > 2) & (s[0] = "0")
-       & ((s[1] = "x") OR (s[1] = "X")) THEN
+    IF (n > 2) AND (s[0] = "0")
+ AND ((s[1] = "x") OR (s[1] = "X")) THEN
       v := 0; i := 2;
       WHILE i < n DO v := v * 16 + HexVal(s[i]); INC(i) END;
       IntStr(v, d)
@@ -318,7 +318,7 @@ PROCEDURE NormLit (s: ARRAY OF CHAR; VAR d: QVal; VAR isCh: BOOLEAN);
     isCh := FALSE;
     IF n = 0 THEN Cpy(d, "0"); RETURN END;
     i := 0;
-    IF (n >= 3) & (s[0] = "0") & ((s[1] = "x") OR (s[1] = "X")) THEN
+    IF (n >= 3) AND (s[0] = "0") AND ((s[1] = "x") OR (s[1] = "X")) THEN
       base := 16; hi := n; i := 2
     ELSE
       ch := s[n - 1];
@@ -361,16 +361,16 @@ PROCEDURE NegFold (a: ARRAY OF CHAR; VAR q: QVal);
     IF Len(tmp) = 0 THEN Cpy(q, "0"); RETURN END;
     IF tmp[0] = "-" THEN
       i := 1; j := 0;
-      WHILE (tmp[i] # 0C) & (j < HIGH(q)) DO
+      WHILE (tmp[i] # CHR(0)) AND (j < HIGH(q)) DO
         q[j] := tmp[i]; INC(i); INC(j)
       END;
-      IF j <= HIGH(q) THEN q[j] := 0C END
-    ELSIF (tmp[0] = "d") & (Len(tmp) > 1) & (tmp[1] = "_") THEN
+      IF j <= HIGH(q) THEN q[j] := CHR(0) END
+    ELSIF (tmp[0] = "d") AND (Len(tmp) > 1) AND (tmp[1] = "_") THEN
       Cpy(q, "d_-");
       i := 2;
-      WHILE tmp[i] # 0C DO
+      WHILE tmp[i] # CHR(0) DO
         L := Len(q);
-        IF L < HIGH(q) THEN q[L] := tmp[i]; q[L + 1] := 0C END;
+        IF L < HIGH(q) THEN q[L] := tmp[i]; q[L + 1] := CHR(0) END;
         INC(i)
       END
     ELSE
@@ -382,7 +382,7 @@ PROCEDURE NegFold (a: ARRAY OF CHAR; VAR q: QVal);
 PROCEDURE IsImm (s: ARRAY OF CHAR): BOOLEAN;
   BEGIN
     IF Len(s) = 0 THEN RETURN FALSE END;
-    RETURN ((s[0] >= "0") & (s[0] <= "9")) OR (s[0] = "-")
+    RETURN ((s[0] >= "0") AND (s[0] <= "9")) OR (s[0] = "-")
            OR (s[0] = "d")
   END IsImm;
 
@@ -401,10 +401,10 @@ PROCEDURE OpenModule (name: ARRAY OF CHAR);
     funcDepth := 0; scopeTop := 0; scopeBase[0] := 0;
     nInit := 0;
     outSel := 0;
-    sessUsed := 0; sessBuf[0] := 0C;
+    sessUsed := 0; sessBuf[0] := CHR(0);
     i := 0;
     WHILE i <= HIGH(nestBufs) DO
-      nestBufs[i][0] := 0C; nestUsed[i] := 0; INC(i)
+      nestBufs[i][0] := CHR(0); nestUsed[i] := 0; INC(i)
     END;
     WL("# QBE IR generated by the V3 step-1 backend");
     WL("")
@@ -413,7 +413,7 @@ PROCEDURE OpenModule (name: ARRAY OF CHAR);
 PROCEDURE DataLine (name: ARRAY OF CHAR; isReal: BOOLEAN;
                    init: ARRAY OF CHAR);
   BEGIN
-    IF ~opened THEN RETURN END;
+    IF NOT opened THEN RETURN END;
     W("data $"); W(name);
     IF isReal THEN W(" = { d ") ELSE W(" = { w ") END;
     W(init);
@@ -422,7 +422,7 @@ PROCEDURE DataLine (name: ARRAY OF CHAR; isReal: BOOLEAN;
 
 PROCEDURE DataLineL (name: ARRAY OF CHAR; init: ARRAY OF CHAR);
   BEGIN
-    IF ~opened THEN RETURN END;
+    IF NOT opened THEN RETURN END;
     W("data $"); W(name);
     W(" = { l ");
     W(init);
@@ -462,16 +462,16 @@ PROCEDURE IsZeroReal (val: ARRAY OF CHAR): BOOLEAN;
     ch : CHAR;
   BEGIN
     i := 0;
-    IF (Len(val) > 1) & (val[0] = "d") & (val[1] = "_") THEN i := 2 END;
-    IF (Len(val) > i) & (val[i] = "-") THEN INC(i) END;
+    IF (Len(val) > 1) AND (val[0] = "d") AND (val[1] = "_") THEN i := 2 END;
+    IF (Len(val) > i) AND (val[i] = "-") THEN INC(i) END;
     seen := FALSE;
-    WHILE val[i] # 0C DO
+    WHILE val[i] # CHR(0) DO
       ch := val[i];
-      IF (ch >= "0") & (ch <= "9") THEN
+      IF (ch >= "0") AND (ch <= "9") THEN
         seen := TRUE;
         IF ch # "0" THEN RETURN FALSE END
-      ELSIF (ch # ".") & (ch # "E") & (ch # "e")
-            & (ch # "+") & (ch # "-") THEN
+      ELSIF (ch # ".") AND (ch # "E") AND (ch # "e")
+ AND (ch # "+") AND (ch # "-") THEN
         RETURN FALSE
       END;
       INC(i)
@@ -490,14 +490,14 @@ PROCEDURE DeclConst (name: ARRAY OF CHAR; val: ARRAY OF CHAR; t: INTEGER);
     ELSE
       Cpy(mang, curModName); App(mang, "_"); App(mang, name)
     END;
-    IF (cls = SymTab.ClStr) OR ~IsImm(val) THEN
+    IF (cls = SymTab.ClStr) OR NOT IsImm(val) THEN
       DataLine(mang, FALSE, "0"); RETURN
     END;
     IF cls = SymTab.ClReal THEN
       (* This qbe accepts only integer/zero literals in "data":
          non-zero REALs flush at BeginBody. *)
       DataLine(mang, TRUE, "0");
-      IF ~IsZeroReal(val) & (nR <= HIGH(rNames)) THEN
+      IF NOT IsZeroReal(val) AND (nR <= HIGH(rNames)) THEN
         Cpy(rNames[nR], mang); Cpy(rVals[nR], val); INC(nR)
       END
     ELSE DataLine(mang, FALSE, val)
@@ -510,7 +510,7 @@ PROCEDURE BeginInit (mod: ARRAY OF CHAR);
 (* Module BEGIN body as `<mod>_init`; main calls it at startup. *)
   VAR sym : QVal;
   BEGIN
-    IF ~opened THEN RETURN END;
+    IF NOT opened THEN RETURN END;
     Cpy(sym, mod);
     App(sym, "_init");
     WL("");
@@ -532,7 +532,7 @@ PROCEDURE BeginBody;
   VAR i : CARDINAL;
     t : QVal;
   BEGIN
-    IF ~opened OR inBody THEN RETURN END;
+    IF NOT opened OR inBody THEN RETURN END;
     WL("");
     WL("export function w $main() {");
     WL("@start");
@@ -553,7 +553,7 @@ PROCEDURE BeginBody;
 
 PROCEDURE CloseModule;
   BEGIN
-    IF ~opened THEN RETURN END;
+    IF NOT opened THEN RETURN END;
     WL("# no code: unit lowering waits for step 4");
     FileIO.Close(out);
     opened := FALSE
@@ -564,11 +564,11 @@ PROCEDURE EndModule (name: ARRAY OF CHAR);
     fname : ARRAY [0 .. 127] OF CHAR;
     ref : QVal;
   BEGIN
-    IF ~opened THEN RETURN END;
-    IF ~inBody THEN BeginBody END;
+    IF NOT opened THEN RETURN END;
+    IF NOT inBody THEN BeginBody END;
     IF SymTab.Lookup("ExitCode")
-       & (SymTab.SymKind("ExitCode") = SymTab.KindVar)
-       & SymTab.IsIntFamily(SymTab.SymType("ExitCode")) THEN
+ AND (SymTab.SymKind("ExitCode") = SymTab.KindVar)
+ AND SymTab.IsIntFamily(SymTab.SymType("ExitCode")) THEN
       Cpy(ref, "$"); App(ref, name); App(ref, "_ExitCode");
       W("  %ec =w loadw "); WL(ref);
       WL("  ret %ec")
@@ -586,7 +586,7 @@ PROCEDURE EndModule (name: ARRAY OF CHAR);
     END;
     FlushStrings;
     (* the image is named after the program module *)
-    fname[0] := 0C;
+    fname[0] := CHR(0);
     App(fname, "gen_ssa/");
     App(fname, name);
     App(fname, ".ssa");
@@ -736,7 +736,7 @@ PROCEDURE Mangled (pname: ARRAY OF CHAR; uid: CARDINAL; VAR q: QVal);
       Cpy(q, link);
       RETURN
     END;
-    IF ~SymTab.SymBase(pname, base) THEN Cpy(base, pname) END;
+    IF NOT SymTab.SymBase(pname, base) THEN Cpy(base, pname) END;
     Cpy(q, base);
     App(q, "_");
     AppNum(q, uid)
@@ -791,7 +791,7 @@ PROCEDURE BeginFunc (mangled: ARRAY OF CHAR);
     nPar := 0;
     funcRes := "w";
     Cpy(funcName, mangled);
-    hbuf[0] := 0C;
+    hbuf[0] := CHR(0);
     NewTemp(slTmp);
     HApp("l ");
     HApp(slTmp);
@@ -816,12 +816,12 @@ PROCEDURE HApp (s: ARRAY OF CHAR);
   VAR i, j : CARDINAL;
   BEGIN
     i := 0;
-    WHILE (i <= HIGH(hbuf)) & (hbuf[i] # 0C) DO INC(i) END;
+    WHILE (i <= HIGH(hbuf)) AND (hbuf[i] # CHR(0)) DO INC(i) END;
     j := 0;
-    WHILE (i < HIGH(hbuf)) & (j <= HIGH(s)) & (s[j] # 0C) DO
+    WHILE (i < HIGH(hbuf)) AND (j <= HIGH(s)) AND (s[j] # CHR(0)) DO
       hbuf[i] := s[j]; INC(i); INC(j)
     END;
-    IF i <= HIGH(hbuf) THEN hbuf[i] := 0C END
+    IF i <= HIGH(hbuf) THEN hbuf[i] := CHR(0) END
   END HApp;
 
 PROCEDURE FuncParam (name: ARRAY OF CHAR; isVar: BOOLEAN;
@@ -841,7 +841,7 @@ PROCEDURE FuncParam (name: ARRAY OF CHAR; isVar: BOOLEAN;
     parTyp[nPar] := t;
     IF hdrComma THEN HApp(", ") END;
     hdrComma := TRUE;
-    buf[0] := c; buf[1] := " "; buf[2] := 0C;
+    buf[0] := c; buf[1] := " "; buf[2] := CHR(0);
     App(buf, tmp);
     HApp(buf);
     INC(nPar);
@@ -950,7 +950,7 @@ PROCEDURE CallBegin (mangled: ARRAY OF CHAR; resT: INTEGER;
     Cpy(stkName[callDepth], mangled);
     stkRes[callDepth] := ResClass(resT);
     stkExt[callDepth] := isExt;
-    stkArg[callDepth][0] := 0C;
+    stkArg[callDepth][0] := CHR(0);
     stkN[callDepth] := 0;
     IF isExt THEN
       Cpy(stkLink[callDepth], "0")
@@ -986,12 +986,12 @@ PROCEDURE CallArg (q: ARRAY OF CHAR; cls: CHAR): BOOLEAN;
     i := have; j := 0;
     stkArg[d][i] := cls; INC(i);
     stkArg[d][i] := " "; INC(i);
-    WHILE q[j] # 0C DO
+    WHILE q[j] # CHR(0) DO
       stkArg[d][i] := q[j]; INC(i); INC(j)
     END;
     stkArg[d][i] := ","; INC(i);
     stkArg[d][i] := " "; INC(i);
-    stkArg[d][i] := 0C;
+    stkArg[d][i] := CHR(0);
     INC(stkN[d]);
     RETURN TRUE
   END CallArg;
@@ -1008,13 +1008,13 @@ PROCEDURE CallEnd (wantRes: BOOLEAN; VAR q: QVal);
     Cpy(funcName, stkName[d]);
     rc := stkRes[d];
     i := 0;
-    WHILE (stkArg[d][i] # 0C) & (i < HIGH(body)) DO
+    WHILE (stkArg[d][i] # CHR(0)) AND (i < HIGH(body)) DO
       body[i] := stkArg[d][i]; INC(i)
     END;
-    IF (i >= 2) & (body[i-2] = ",") THEN
-      body[i-2] := 0C
+    IF (i >= 2) AND (body[i-2] = ",") THEN
+      body[i-2] := CHR(0)
     ELSE
-      body[i] := 0C
+      body[i] := CHR(0)
     END;
     Revive;
     IF wantRes THEN
@@ -1028,7 +1028,7 @@ PROCEDURE CallEnd (wantRes: BOOLEAN; VAR q: QVal);
       W(body)                       (* C callee: no static link *)
     ELSE
       W("l "); W(stkLink[d]);
-      IF body[0] # 0C THEN W(", "); W(body) END
+      IF body[0] # CHR(0) THEN W(", "); W(body) END
     END;
     WL(")")
   END CallEnd;
@@ -1261,7 +1261,7 @@ PROCEDURE CmpLong (op: INTEGER; l, r: ARRAY OF CHAR; VAR q: QVal);
 (* 64-bit comparison (result w). *)
   VAR mn : ARRAY [0 .. 7] OF CHAR;
   BEGIN
-    mn[0] := 0C;
+    mn[0] := CHR(0);
     IF op = SymTab.OpEq THEN Cpy(mn, "ceql")
     ELSIF (op = SymTab.OpNeq1) OR (op = SymTab.OpNeq2) THEN Cpy(mn, "cnel")
     ELSIF op = SymTab.OpLt THEN Cpy(mn, "csltl")
@@ -1370,7 +1370,7 @@ PROCEDURE Revive;
    chains whose compares follow a Jmp. Counter-driven: fixpoint-safe. *)
   VAR b: QVal;
   BEGIN
-    IF opened & dead THEN
+    IF opened AND dead THEN
       NewLabel(b);
       WL(b);
       dead := FALSE
@@ -1403,7 +1403,7 @@ PROCEDURE Cmp (op: INTEGER; l, r: ARRAY OF CHAR; VAR q: QVal;
                isReal: BOOLEAN);
   VAR mn : ARRAY [0 .. 7] OF CHAR;
   BEGIN
-    mn[0] := 0C;
+    mn[0] := CHR(0);
     IF isReal THEN
       IF op = SymTab.OpEq THEN Cpy(mn, "ceqd")
       ELSIF (op = SymTab.OpNeq1) OR (op = SymTab.OpNeq2) THEN Cpy(mn, "cned")
@@ -1543,7 +1543,7 @@ PROCEDURE RecItems (t: SymTab.TypeIndex; prefix: ARRAY OF CHAR;
 PROCEDURE DeclRec (name: ARRAY OF CHAR; t: INTEGER);
   VAR first: BOOLEAN;
   BEGIN
-    IF ~opened THEN RETURN END;
+    IF NOT opened THEN RETURN END;
     RecStatics(name, t);
     W("data $"); W(name);
     W(" = { ");
@@ -1627,7 +1627,7 @@ PROCEDURE WordsBytes (words: CARDINAL): CARDINAL;
 PROCEDURE DeclSet (name: ARRAY OF CHAR; t: INTEGER);
   VAR w, i: CARDINAL;
   BEGIN
-    IF ~opened THEN RETURN END;
+    IF NOT opened THEN RETURN END;
     w := SymTab.SetWords(t);
     IF w = 0 THEN w := 1 END;
     W("data $"); W(name);
@@ -2117,7 +2117,7 @@ PROCEDURE FlushStrings;
   VAR k, i, L: CARDINAL;
     bv: QVal;
   BEGIN
-    IF ~opened THEN RETURN END;
+    IF NOT opened THEN RETURN END;
     k := 0;
     WHILE k < nStr DO
       L := Len(strTexts[k]);
@@ -2148,7 +2148,7 @@ PROCEDURE ArrData (name: ARRAY OF CHAR; t: SymTab.TypeIndex);
     bv: QVal;
     sub: QVal;
   BEGIN
-    IF ~opened THEN RETURN END;
+    IF NOT opened THEN RETURN END;
     n := SymTab.ArrayLen(t);
     elem := SymTab.ArrayElem(t);
     ecls := SymTab.ClassOf(elem);
@@ -2218,7 +2218,7 @@ PROCEDURE TopLoop (VAR exit: QVal): BOOLEAN;
 PROCEDURE CmpL (op: INTEGER; l, r: ARRAY OF CHAR; VAR q: QVal);
   VAR mn : ARRAY [0 .. 7] OF CHAR;
   BEGIN
-    mn[0] := 0C;
+    mn[0] := CHR(0);
     IF op = SymTab.OpEq THEN Cpy(mn, "ceql")
     ELSE Cpy(mn, "cnel")
     END;

compiler/src/SymTab.mod

@@ -2,7 +2,6 @@ IMPLEMENTATION MODULE SymTab;
 
 IMPORT FileIO;
 FROM Storage IMPORT ALLOCATE;
-FROM SYSTEM IMPORT TSIZE;
 
 CONST
   MaxTypes  = 256;
@@ -101,10 +100,10 @@ PROCEDURE Assign (VAR dest: ARRAY OF CHAR; src: ARRAY OF CHAR);
   VAR i : CARDINAL;
   BEGIN
     i := 0;
-    WHILE (i < HIGH(dest)) & (src[i] # 0C) DO
+    WHILE (i < HIGH(dest)) AND (src[i] # CHR(0)) DO
       dest[i] := src[i]; INC(i)
     END;
-    dest[i] := 0C
+    dest[i] := CHR(0)
   END Assign;
 
 PROCEDURE Equal (a, b: ARRAY OF CHAR): BOOLEAN;
@@ -113,7 +112,7 @@ PROCEDURE Equal (a, b: ARRAY OF CHAR): BOOLEAN;
     i := 0;
     LOOP
       IF a[i] # b[i] THEN RETURN FALSE END;
-      IF a[i] = 0C THEN RETURN TRUE END;
+      IF a[i] = CHR(0) THEN RETURN TRUE END;
       INC(i)
     END
   END Equal;
@@ -125,7 +124,7 @@ PROCEDURE Less (a, b: ARRAY OF CHAR): BOOLEAN;
     i := 0;
     LOOP
       IF a[i] # b[i] THEN RETURN ORD(a[i]) < ORD(b[i]) END;
-      IF a[i] = 0C THEN RETURN FALSE END;
+      IF a[i] = CHR(0) THEN RETURN FALSE END;
       INC(i)
     END
   END Less;
@@ -134,7 +133,7 @@ PROCEDURE StrLen (s: ARRAY OF CHAR): CARDINAL;
   VAR i : CARDINAL;
   BEGIN
     i := 0;
-    WHILE (i < HIGH(s)) & (s[i] # 0C) DO INC(i) END;
+    WHILE (i < HIGH(s)) AND (s[i] # CHR(0)) DO INC(i) END;
     RETURN i
   END StrLen;
 
@@ -144,8 +143,8 @@ PROCEDURE ConstInt (q: ARRAY OF CHAR; VAR v: INTEGER): BOOLEAN;
   BEGIN
     v := 0; i := 0; neg := FALSE;
     IF q[0] = "-" THEN neg := TRUE; i := 1 END;
-    IF (i >= HIGH(q)) OR (q[i] = 0C) THEN RETURN FALSE END;
-    WHILE (i < HIGH(q)) & (q[i] # 0C) DO
+    IF (i >= HIGH(q)) OR (q[i] = CHR(0)) THEN RETURN FALSE END;
+    WHILE (i < HIGH(q)) AND (q[i] # CHR(0)) DO
       d := ORD(q[i]);
       IF (d < ORD("0")) OR (d > ORD("9")) THEN RETURN FALSE END;
       v := v * 10 + VAL(INTEGER, d - ORD("0")); INC(i)
@@ -226,7 +225,7 @@ PROCEDURE SetNodeMod (node: SymPtr);
 (* Records the defining module for global-symbol naming. *)
   BEGIN
     IF curMod >= 0 THEN Assign(node^.mod, modNames[curMod])
-    ELSE node^.mod[0] := 0C
+    ELSE node^.mod[0] := CHR(0)
     END
   END SetNodeMod;
 
@@ -244,7 +243,7 @@ PROCEDURE RawEnter (name: ARRAY OF CHAR; kind: INTEGER): SymPtr;
     node^.scope := curScope;
     node^.left := NIL;
     node^.right := NIL;
-    IF ~TreeInsert(curScope, node) THEN RETURN NIL END;
+    IF NOT TreeInsert(curScope, node) THEN RETURN NIL END;
     RETURN node
   END RawEnter;
 
@@ -257,7 +256,7 @@ PROCEDURE EnterPending (name: ARRAY OF CHAR; kind: INTEGER): BOOLEAN;
   VAR node: SymPtr;
   BEGIN
     node := RawEnter(name, kind);
-    IF (node # NIL) & (nPend < MaxPend) THEN
+    IF (node # NIL) AND (nPend < MaxPend) THEN
       pend[nPend] := node; INC(nPend)
     END;
     RETURN node # NIL
@@ -281,7 +280,7 @@ PROCEDURE PendCount (): CARDINAL;
 PROCEDURE PendName (i: CARDINAL; VAR n: Name);
   BEGIN
     IF i < nPend THEN Assign(n, pend[i]^.name)
-    ELSE n[0] := 0C
+    ELSE n[0] := CHR(0)
     END
   END PendName;
 
@@ -289,10 +288,10 @@ PROCEDURE FindField (rec: TypeIndex; name: ARRAY OF CHAR): FieldPtr;
   VAR f: FieldPtr;
   BEGIN
     IF (rec < 0) OR (rec >= VAL(INTEGER, nTypes)) THEN RETURN NIL END;
-    IF (tform[rec] # FRecord) & (tform[rec] # FClass) THEN RETURN NIL END;
+    IF (tform[rec] # FRecord) AND (tform[rec] # FClass) THEN RETURN NIL END;
     f := fields;
     WHILE f # NIL DO
-      IF (f^.owner = rec) & Equal(f^.name, name) THEN RETURN f END;
+      IF (f^.owner = rec) AND Equal(f^.name, name) THEN RETURN f END;
       f := f^.next
     END;
     RETURN NIL
@@ -308,7 +307,7 @@ PROCEDURE FieldPending (rec: TypeIndex; name: ARRAY OF CHAR): BOOLEAN;
     f^.owner := rec;
     f^.next := fields;
     fields := f;
-    IF (rec >= 0) & (rec < VAL(INTEGER, nTypes)) THEN
+    IF (rec >= 0) AND (rec < VAL(INTEGER, nTypes)) THEN
       tdone[rec] := FALSE
     END;
     IF nPendF < MaxPend THEN
@@ -477,7 +476,7 @@ PROCEDURE NewClass (): TypeIndex;
 
 PROCEDURE SetParent (t, p: TypeIndex);
   BEGIN
-    IF (t >= 0) & (t < VAL(INTEGER, nTypes)) & (tform[t] = FClass) THEN
+    IF (t >= 0) AND (t < VAL(INTEGER, nTypes)) AND (tform[t] = FClass) THEN
       tparent[t] := p
     END
   END SetParent;
@@ -493,7 +492,7 @@ PROCEDURE PushClassScope (t: TypeIndex);
 
 PROCEDURE SetTarget (t, base: TypeIndex);
   BEGIN
-    IF (t >= 0) & (t < VAL(INTEGER, nTypes)) & (tform[t] = FAlias) THEN
+    IF (t >= 0) AND (t < VAL(INTEGER, nTypes)) AND (tform[t] = FAlias) THEN
       tref[t] := base
     END
   END SetTarget;
@@ -502,8 +501,8 @@ PROCEDURE Resolve (t: TypeIndex): TypeIndex;
   VAR n: CARDINAL;
   BEGIN
     n := 0;
-    WHILE (n < ResDepth) & (t >= 0) & (t < VAL(INTEGER, nTypes))
-          & (tform[t] = FAlias) DO
+    WHILE (n < ResDepth) AND (t >= 0) AND (t < VAL(INTEGER, nTypes))
+ AND (tform[t] = FAlias) DO
       t := tref[t]; INC(n)
     END;
     IF (t < 0) OR (t >= VAL(INTEGER, nTypes)) THEN
@@ -587,7 +586,7 @@ PROCEDURE ArrayElem (t: TypeIndex): TypeIndex;
   BEGIN
     r := Resolve(t);
     IF (r = InvalidType) OR ((tform[r] # FArray)
-       & (tform[r] # FOpenArr)) THEN
+ AND (tform[r] # FOpenArr)) THEN
       RETURN InvalidType
     END;
     RETURN tref[r]
@@ -633,7 +632,7 @@ PROCEDURE ArrayDepth (t: TypeIndex): CARDINAL;
     d: CARDINAL;
   BEGIN
     d := 0; r := Resolve(t);
-    WHILE (r # InvalidType) & ((tform[r] = FArray)
+    WHILE (r # InvalidType) AND ((tform[r] = FArray)
            OR (tform[r] = FOpenArr)) DO
       INC(d); r := Resolve(tref[r])
     END;
@@ -675,9 +674,9 @@ PROCEDURE SetSpan (t: TypeIndex; VAR lo, n: INTEGER): BOOLEAN;
     IF r = InvalidType THEN RETURN FALSE END;
     IF tform[r] = FBool THEN lo := 0; n := 2; RETURN TRUE END;
     IF tform[r] = FChar THEN lo := 0; n := 256; RETURN TRUE END;
-    IF (tform[r] = FSub) & (tref[r] = InvalidType)
-       & SubBounds(b, blo, bhi) & (bhi >= blo)
-       & (bhi - blo < 256) THEN
+    IF (tform[r] = FSub) AND (tref[r] = InvalidType)
+ AND SubBounds(b, blo, bhi) AND (bhi >= blo)
+ AND (bhi - blo < 256) THEN
       lo := blo; n := bhi - blo + 1; RETURN TRUE
     END;
     RETURN FALSE
@@ -686,21 +685,21 @@ PROCEDURE SetSpan (t: TypeIndex; VAR lo, n: INTEGER): BOOLEAN;
 PROCEDURE SetWords (t: TypeIndex): CARDINAL;
   VAR lo, n: INTEGER;
   BEGIN
-    IF ~SetSpan(t, lo, n) THEN RETURN 0 END;
+    IF NOT SetSpan(t, lo, n) THEN RETURN 0 END;
     RETURN VAL(CARDINAL, (n + 31) DIV 32)
   END SetWords;
 
 PROCEDURE SetBaseLo (t: TypeIndex): INTEGER;
   VAR lo, n: INTEGER;
   BEGIN
-    IF ~SetSpan(t, lo, n) THEN RETURN 0 END;
+    IF NOT SetSpan(t, lo, n) THEN RETURN 0 END;
     RETURN lo
   END SetBaseLo;
 
 PROCEDURE SetCount (t: TypeIndex): CARDINAL;
   VAR lo, n: INTEGER;
   BEGIN
-    IF ~SetSpan(t, lo, n) THEN RETURN 0 END;
+    IF NOT SetSpan(t, lo, n) THEN RETURN 0 END;
     RETURN VAL(CARDINAL, n)
   END SetCount;
 
@@ -773,7 +772,7 @@ PROCEDURE ObjectSize (t: TypeIndex): CARDINAL;
   VAR r: TypeIndex;
   BEGIN
     r := Resolve(t);
-    IF (r # InvalidType) & ((tform[r] = FArray)
+    IF (r # InvalidType) AND ((tform[r] = FArray)
        OR (tform[r] = FOpenArr)) THEN
       RETURN 8 + ArrayLen(t) * ElemBytes(t)
     END;
@@ -818,10 +817,10 @@ PROCEDURE FieldOffset (rec: TypeIndex; name: ARRAY OF CHAR): INTEGER;
   BEGIN
     r := Resolve(rec);
     IF (r = InvalidType) OR ((tform[r] # FRecord)
-       & (tform[r] # FClass)) THEN
+ AND (tform[r] # FClass)) THEN
       RETURN -1
     END;
-    IF ~tdone[r] THEN ComputeOffsets(r) END;
+    IF NOT tdone[r] THEN ComputeOffsets(r) END;
     f := FindField(r, name);
     IF f = NIL THEN RETURN -1 END;
     RETURN f^.off
@@ -846,7 +845,7 @@ PROCEDURE FieldCount (rec: TypeIndex): CARDINAL;
     n := 0;
     r := Resolve(rec);
     IF (r = InvalidType) OR ((tform[r] # FRecord)
-       & (tform[r] # FClass)) THEN
+ AND (tform[r] # FClass)) THEN
       RETURN 0
     END;
     f := fields;
@@ -862,16 +861,16 @@ PROCEDURE FieldName (rec: TypeIndex; i: CARDINAL; VAR name: Name);
   VAR r: TypeIndex;
     f: FieldPtr;
   BEGIN
-    name[0] := 0C;
+    name[0] := CHR(0);
     r := Resolve(rec);
     IF (r = InvalidType) OR ((tform[r] # FRecord)
-       & (tform[r] # FClass)) THEN
+ AND (tform[r] # FClass)) THEN
       RETURN
     END;
-    IF ~tdone[r] THEN ComputeOffsets(r) END;
+    IF NOT tdone[r] THEN ComputeOffsets(r) END;
     f := fields;
     WHILE f # NIL DO
-      IF (f^.owner = r) & (f^.ord = i) THEN
+      IF (f^.owner = r) AND (f^.ord = i) THEN
         Assign(name, f^.name); RETURN
       END;
       f := f^.next
@@ -886,7 +885,7 @@ PROCEDURE PushRecord (t: TypeIndex): BOOLEAN;
     f: FieldPtr;
   BEGIN
     r := Resolve(t);
-    IF (r < 0) OR ((tform[r] # FRecord) & (tform[r] # FClass)) THEN
+    IF (r < 0) OR ((tform[r] # FRecord) AND (tform[r] # FClass)) THEN
       RETURN FALSE
     END;
     PushScope;
@@ -915,7 +914,7 @@ PROCEDURE MethodExists (t: TypeIndex; name: ARRAY OF CHAR): BOOLEAN;
     s := tscope[r];
     IF s = NIL THEN RETURN FALSE END;
     node := TreeFind(s^.root, name);
-    RETURN (node # NIL) & (node^.kind = KindProc)
+    RETURN (node # NIL) AND (node^.kind = KindProc)
   END MethodExists;
 
 PROCEDURE PushClassMembers (t: TypeIndex): BOOLEAN;
@@ -971,7 +970,7 @@ PROCEDURE EnterProc (name: ARRAY OF CHAR): BOOLEAN;
     node^.fwd := FALSE;
     node^.virt := FALSE;
     node^.ext := FALSE;
-    node^.link[0] := 0C;
+    node^.link[0] := CHR(0);
     node^.uid := nextUid; INC(nextUid);
     node^.fdep := nProc;
     curProc := node;
@@ -999,7 +998,7 @@ PROCEDURE ReenterProc (name: ARRAY OF CHAR): BOOLEAN;
   VAR node: SymPtr;
   BEGIN
     node := TreeFind(curScope^.root, name);
-    IF (node = NIL) OR (node^.kind # KindProc) OR ~node^.fwd THEN
+    IF (node = NIL) OR (node^.kind # KindProc) OR NOT node^.fwd THEN
       RETURN FALSE
     END;
     node^.fwd := FALSE;
@@ -1056,7 +1055,7 @@ PROCEDURE MarkExternal (link: ARRAY OF CHAR);
   BEGIN
     IF curProc = NIL THEN RETURN END;
     curProc^.ext := TRUE;
-    IF link[0] = 0C THEN Assign(curProc^.link, curProc^.name)
+    IF link[0] = CHR(0) THEN Assign(curProc^.link, curProc^.name)
     ELSE Assign(curProc^.link, link)
     END
   END MarkExternal;
@@ -1065,14 +1064,14 @@ PROCEDURE IsExternal (name: ARRAY OF CHAR): BOOLEAN;
   VAR node: SymPtr;
   BEGIN
     node := Find(name);
-    RETURN (node # NIL) & node^.ext
+    RETURN (node # NIL) AND node^.ext
   END IsExternal;
 
 PROCEDURE ProcLink (name: ARRAY OF CHAR; VAR link: Name): BOOLEAN;
   VAR node: SymPtr;
   BEGIN
     node := Find(name);
-    IF (node = NIL) OR ~node^.ext THEN RETURN FALSE END;
+    IF (node = NIL) OR NOT node^.ext THEN RETURN FALSE END;
     Assign(link, node^.link);
     RETURN TRUE
   END ProcLink;
@@ -1118,7 +1117,7 @@ PROCEDURE ProcUid (name: ARRAY OF CHAR): CARDINAL;
 PROCEDURE NthParam (node: SymPtr; i: CARDINAL): SymPtr;
   BEGIN
     node := node^.plink;
-    WHILE (i > 0) & (node # NIL) DO
+    WHILE (i > 0) AND (node # NIL) DO
       node := node^.plink; DEC(i)
     END;
     RETURN node
@@ -1168,18 +1167,18 @@ PROCEDURE VarParamOk (actual, formal: TypeIndex): BOOLEAN;
     END;
     IF SameType(actual, formal) THEN RETURN TRUE END;
     (* ADDRESS is interchangeable with any pointer for VAR params *)
-    IF (Resolve(formal) = dAddr) & (ClassOf(actual) = ClPtr) THEN
+    IF (Resolve(formal) = dAddr) AND (ClassOf(actual) = ClPtr) THEN
       RETURN TRUE
     END;
-    IF (Resolve(actual) = dAddr) & (ClassOf(formal) = ClPtr) THEN
+    IF (Resolve(actual) = dAddr) AND (ClassOf(formal) = ClPtr) THEN
       RETURN TRUE
     END;
     IF IsOpenArray(formal)
-       & (ClassOf(actual) = ClArray) & (ArrayDepth(actual) = 1) THEN
+ AND (ClassOf(actual) = ClArray) AND (ArrayDepth(actual) = 1) THEN
       fa := ArrayElem(actual); fe := ArrayElem(formal);
       IF SameType(fa, fe) THEN RETURN TRUE END
     END;
-    IF IsOpenArray(formal) & (ClassOf(actual) = ClStr) THEN
+    IF IsOpenArray(formal) AND (ClassOf(actual) = ClStr) THEN
       fe := ArrayElem(formal);
       IF ClassOf(fe) = ClChar THEN RETURN TRUE END
     END;
@@ -1195,7 +1194,7 @@ PROCEDURE EnterIn (s: ScopePtr; name: ARRAY OF CHAR;
     ALLOCATE(node, TSIZE(SymNode));
     Assign(node^.name, name);
     Assign(node^.sym, name);
-    node^.mod[0] := 0C;
+    node^.mod[0] := CHR(0);
     node^.kind := kind;
     node^.typ := InvalidType;
     node^.scope := s;
@@ -1207,10 +1206,10 @@ PROCEDURE EnterIn (s: ScopePtr; name: ARRAY OF CHAR;
     node^.fwd := FALSE;
     node^.virt := FALSE;
     node^.ext := FALSE;
-    node^.link[0] := 0C;
+    node^.link[0] := CHR(0);
     node^.fdep := 0;
     node^.uid := 0;
-    IF ~TreeInsert(s, node) THEN RETURN FALSE END;
+    IF NOT TreeInsert(s, node) THEN RETURN FALSE END;
     RETURN TRUE
   END EnterIn;
 
@@ -1239,7 +1238,7 @@ PROCEDURE NewMod (name: ARRAY OF CHAR; kind: INTEGER): BOOLEAN;
     modImpl[idx] := FALSE;
     INC(nMods);
     (* the module name lives in the global scope *)
-    IF ~EnterIn(globScope, name, KindModule) THEN
+    IF NOT EnterIn(globScope, name, KindModule) THEN
       DEC(nMods); RETURN FALSE
     END;
     curMod := VAL(INTEGER, idx);
@@ -1293,7 +1292,7 @@ PROCEDURE CurUnit (): INTEGER;
 
 PROCEDURE CurModule (VAR name: Name);
   BEGIN
-    IF curMod < 0 THEN name[0] := 0C
+    IF curMod < 0 THEN name[0] := CHR(0)
     ELSE Assign(name, modNames[curMod])
     END
   END CurModule;
@@ -1307,14 +1306,14 @@ PROCEDURE ModDefined (name: ARRAY OF CHAR): BOOLEAN;
   VAR i : INTEGER;
   BEGIN
     i := FindMod(name);
-    RETURN (i # -1) & (modKind[i] # UnitProg)
+    RETURN (i # -1) AND (modKind[i] # UnitProg)
   END ModDefined;
 
 PROCEDURE ModImplemented (name: ARRAY OF CHAR): BOOLEAN;
   VAR i : INTEGER;
   BEGIN
     i := FindMod(name);
-    RETURN (i # -1) & modImpl[i]
+    RETURN (i # -1) AND modImpl[i]
   END ModImplemented;
 
 PROCEDURE OpaqueBase (name: ARRAY OF CHAR): TypeIndex;
@@ -1329,7 +1328,7 @@ PROCEDURE OpaqueBase (name: ARRAY OF CHAR): TypeIndex;
     IF (r < 0) OR (r >= VAL(INTEGER, nTypes)) THEN
       RETURN InvalidType
     END;
-    IF (tform[r] = FAlias) & (tref[r] = InvalidType) THEN RETURN r END;
+    IF (tform[r] = FAlias) AND (tref[r] = InvalidType) THEN RETURN r END;
     RETURN InvalidType
   END OpaqueBase;
 
@@ -1373,7 +1372,7 @@ PROCEDURE QualProcUid (mod, name: ARRAY OF CHAR): CARDINAL;
 PROCEDURE QualNthParam (n: SymPtr; i: CARDINAL): SymPtr;
   BEGIN
     n := n^.plink;
-    WHILE (i > 0) & (n # NIL) DO
+    WHILE (i > 0) AND (n # NIL) DO
       n := n^.plink; DEC(i)
     END;
     RETURN n
@@ -1438,7 +1437,7 @@ PROCEDURE Materialize (mod, name: ARRAY OF CHAR): BOOLEAN;
     node^.left := NIL;
     node^.right := NIL;
     node^.scope := curScope;
-    IF ~TreeInsert(curScope, node) THEN RETURN FALSE END;
+    IF NOT TreeInsert(curScope, node) THEN RETURN FALSE END;
     RETURN TRUE
   END Materialize;
 
@@ -1447,15 +1446,15 @@ PROCEDURE BuildAlias (mod, name: ARRAY OF CHAR; VAR alias: Name);
   VAR i, j : CARDINAL;
   BEGIN
     i := 0;
-    WHILE (i < HIGH(alias)) & (mod[i] # 0C) DO
+    WHILE (i < HIGH(alias)) AND (mod[i] # CHR(0)) DO
       alias[i] := mod[i]; INC(i)
     END;
     IF i < HIGH(alias) THEN alias[i] := "$"; INC(i) END;
     j := 0;
-    WHILE (i < HIGH(alias)) & (name[j] # 0C) DO
+    WHILE (i < HIGH(alias)) AND (name[j] # CHR(0)) DO
       alias[i] := name[j]; INC(i); INC(j)
     END;
-    IF i <= HIGH(alias) THEN alias[i] := 0C END
+    IF i <= HIGH(alias) THEN alias[i] := CHR(0) END
   END BuildAlias;
 
 PROCEDURE MaterializeAlias (mod, name: ARRAY OF CHAR;
@@ -1477,7 +1476,7 @@ PROCEDURE MaterializeAlias (mod, name: ARRAY OF CHAR;
       node^.left := NIL;
       node^.right := NIL;
       node^.scope := curScope;
-      IF ~TreeInsert(curScope, node) THEN RETURN FALSE END
+      IF NOT TreeInsert(curScope, node) THEN RETURN FALSE END
     END;
     RETURN TRUE
   END MaterializeAlias;
@@ -1500,17 +1499,17 @@ PROCEDURE GlobalRef (name: ARRAY OF CHAR; VAR g: Name): BOOLEAN;
     i, j : CARDINAL;
   BEGIN
     node := Find(name);
-    IF (node = NIL) OR (node^.mod[0] = 0C) THEN RETURN FALSE END;
+    IF (node = NIL) OR (node^.mod[0] = CHR(0)) THEN RETURN FALSE END;
     i := 0;
-    WHILE (i < HIGH(g)) & (node^.mod[i] # 0C) DO
+    WHILE (i < HIGH(g)) AND (node^.mod[i] # CHR(0)) DO
       g[i] := node^.mod[i]; INC(i)
     END;
     IF i < HIGH(g) THEN g[i] := "_"; INC(i) END;
     j := 0;
-    WHILE (i < HIGH(g)) & (node^.sym[j] # 0C) DO
+    WHILE (i < HIGH(g)) AND (node^.sym[j] # CHR(0)) DO
       g[i] := node^.sym[j]; INC(i); INC(j)
     END;
-    IF i <= HIGH(g) THEN g[i] := 0C END;
+    IF i <= HIGH(g) THEN g[i] := CHR(0) END;
     RETURN TRUE
   END GlobalRef;
 
@@ -1530,8 +1529,8 @@ PROCEDURE BaseSpanOk (b: TypeIndex): BOOLEAN;
     IF r = InvalidType THEN RETURN TRUE END;
     IF tform[r] = FBool THEN RETURN TRUE END;
     IF tform[r] = FChar THEN RETURN TRUE END;
-    IF (tform[r] = FSub) & (tref[r] = InvalidType)
-       & SubBounds(b, lo, hi) & (hi >= lo) & (hi - lo < 256) THEN
+    IF (tform[r] = FSub) AND (tref[r] = InvalidType)
+ AND SubBounds(b, lo, hi) AND (hi >= lo) AND (hi - lo < 256) THEN
       RETURN TRUE
     END;
     RETURN FALSE
@@ -1542,7 +1541,7 @@ PROCEDURE SetBasesOk (a, b: TypeIndex): BOOLEAN;
    (masks compare over min words + zero-check extras) *)
   BEGIN
     IF SameType(a, b) THEN RETURN TRUE END;
-    RETURN BaseSpanOk(a) & BaseSpanOk(b)
+    RETURN BaseSpanOk(a) AND BaseSpanOk(b)
   END SetBasesOk;
 
 PROCEDURE Assignable (src, dst: TypeIndex): BOOLEAN;
@@ -1552,38 +1551,38 @@ PROCEDURE Assignable (src, dst: TypeIndex): BOOLEAN;
     rs := Resolve(src); rd := Resolve(dst);
     IF rs = rd THEN RETURN TRUE END;
     IF (rs = InvalidType) OR (rd = InvalidType) THEN RETURN TRUE END;
-    IF (tform[rs] = FSet) & (tform[rd] = FSet) THEN
+    IF (tform[rs] = FSet) AND (tform[rd] = FSet) THEN
       RETURN SetBasesOk(tref[rs], tref[rd])
     END;
-    IF (ClassOf(src) = ClArray) & (ClassOf(dst) = ClArray) THEN
+    IF (ClassOf(src) = ClArray) AND (ClassOf(dst) = ClArray) THEN
       (* a fixed 1-D array is compatible with an open formal of the
          same element type (value or VAR) *)
-      IF IsOpenArray(dst) & (ArrayDepth(src) = 1) THEN
+      IF IsOpenArray(dst) AND (ArrayDepth(src) = 1) THEN
         RETURN SameType(ArrayElem(src), ArrayElem(dst))
       END;
       RETURN SameType(src, dst)
     END;
-    IF (ClassOf(src) = ClStr) & (ClassOf(dst) = ClArray) THEN
+    IF (ClassOf(src) = ClStr) AND (ClassOf(dst) = ClArray) THEN
       RETURN (ArrayDepth(dst) = 1)
-             & (ClassOf(ArrayElem(dst)) = ClChar)
+ AND (ClassOf(ArrayElem(dst)) = ClChar)
     END;
     IF ClassOf(src) = ClNil THEN
       RETURN ClassOf(dst) = ClPtr
     END;
     (* ADDRESS assigns to/from any pointer *)
-    IF (Resolve(src) = dAddr) & (ClassOf(dst) = ClPtr) THEN
+    IF (Resolve(src) = dAddr) AND (ClassOf(dst) = ClPtr) THEN
       RETURN TRUE
     END;
-    IF (Resolve(dst) = dAddr) & (ClassOf(src) = ClPtr) THEN
+    IF (Resolve(dst) = dAddr) AND (ClassOf(src) = ClPtr) THEN
       RETURN TRUE
     END;
-    IF (ClassOf(src) = ClInt) & (ClassOf(dst) = ClInt) THEN
+    IF (ClassOf(src) = ClInt) AND (ClassOf(dst) = ClInt) THEN
       RETURN TRUE
     END;
-    IF (ClassOf(src) = ClInt) & (ClassOf(dst) = ClLong) THEN
+    IF (ClassOf(src) = ClInt) AND (ClassOf(dst) = ClLong) THEN
       RETURN TRUE
     END;
-    IF (ClassOf(src) = ClInt) & (ClassOf(dst) = ClReal) THEN
+    IF (ClassOf(src) = ClInt) AND (ClassOf(dst) = ClReal) THEN
       RETURN TRUE
     END;
     RETURN FALSE
@@ -1594,15 +1593,15 @@ PROCEDURE ArithCheck (l, r: TypeIndex; divmod: BOOLEAN;
   BEGIN
     res := InvalidType;
     IF (l = InvalidType) OR (r = InvalidType) THEN RETURN TRUE END;
-    IF (IsLongFamily(l) & IsLongFamily(r))
-       OR (IsLongFamily(l) & IsIntFamily(r))
-       OR (IsIntFamily(l) & IsLongFamily(r)) THEN
+    IF (IsLongFamily(l) AND IsLongFamily(r))
+       OR (IsLongFamily(l) AND IsIntFamily(r))
+       OR (IsIntFamily(l) AND IsLongFamily(r)) THEN
       res := dLong; RETURN TRUE
     END;
-    IF IsIntFamily(l) & IsIntFamily(r) THEN
+    IF IsIntFamily(l) AND IsIntFamily(r) THEN
       res := dInt; RETURN TRUE
     END;
-    IF ~divmod & (ClassOf(l) = ClReal) & (ClassOf(r) = ClReal) THEN
+    IF NOT divmod AND (ClassOf(l) = ClReal) AND (ClassOf(r) = ClReal) THEN
       res := dReal; RETURN TRUE
     END;
     RETURN FALSE
@@ -1643,22 +1642,22 @@ PROCEDURE EqCheck (l, r: TypeIndex): BOOLEAN;
       END;
       RETURN TRUE
     END;
-    IF IsIntFamily(l) & IsIntFamily(r) THEN RETURN TRUE END;
-    IF (ClassOf(l) = ClLong) & (ClassOf(r) = ClLong) THEN
+    IF IsIntFamily(l) AND IsIntFamily(r) THEN RETURN TRUE END;
+    IF (ClassOf(l) = ClLong) AND (ClassOf(r) = ClLong) THEN
       RETURN TRUE
     END;
-    IF (ClassOf(l) = ClReal) & (ClassOf(r) = ClReal) THEN
+    IF (ClassOf(l) = ClReal) AND (ClassOf(r) = ClReal) THEN
       RETURN TRUE
     END;
-    IF (ClassOf(l) = ClChar) & (ClassOf(r) = ClChar) THEN
+    IF (ClassOf(l) = ClChar) AND (ClassOf(r) = ClChar) THEN
       RETURN TRUE
     END;
-    IF (ClassOf(l) = ClBool) & (ClassOf(r) = ClBool) THEN
+    IF (ClassOf(l) = ClBool) AND (ClassOf(r) = ClBool) THEN
       RETURN TRUE
     END;
     rl := Resolve(l); rr := Resolve(r);
     IF (rl = InvalidType) OR (rr = InvalidType) THEN RETURN TRUE END;
-    IF (tform[rl] = FSet) & (tform[rr] = FSet) THEN
+    IF (tform[rl] = FSet) AND (tform[rr] = FSet) THEN
       RETURN SetBasesOk(tref[rl], tref[rr])
     END;
     RETURN FALSE
@@ -1667,17 +1666,17 @@ PROCEDURE EqCheck (l, r: TypeIndex): BOOLEAN;
 PROCEDURE OrdCheck (l, r: TypeIndex): BOOLEAN;
   BEGIN
     IF (l = InvalidType) OR (r = InvalidType) THEN RETURN TRUE END;
-    IF IsIntFamily(l) & IsIntFamily(r) THEN RETURN TRUE END;
-    IF (ClassOf(l) = ClLong) & (ClassOf(r) = ClLong) THEN
+    IF IsIntFamily(l) AND IsIntFamily(r) THEN RETURN TRUE END;
+    IF (ClassOf(l) = ClLong) AND (ClassOf(r) = ClLong) THEN
       RETURN TRUE
     END;
-    IF (ClassOf(l) = ClReal) & (ClassOf(r) = ClReal) THEN
+    IF (ClassOf(l) = ClReal) AND (ClassOf(r) = ClReal) THEN
       RETURN TRUE
     END;
-    IF (ClassOf(l) = ClChar) & (ClassOf(r) = ClChar) THEN
+    IF (ClassOf(l) = ClChar) AND (ClassOf(r) = ClChar) THEN
       RETURN TRUE
     END;
-    IF (ClassOf(l) = ClEnum) & SameType(l, r) THEN RETURN TRUE END;
+    IF (ClassOf(l) = ClEnum) AND SameType(l, r) THEN RETURN TRUE END;
     RETURN FALSE
   END OrdCheck;
 
@@ -1689,14 +1688,14 @@ PROCEDURE InCheck (l, set: TypeIndex): BOOLEAN;
     IF (rs = InvalidType) OR (tform[rs] # FSet) THEN RETURN FALSE END;
     b := tref[rs];
     IF SameType(l, b) THEN RETURN TRUE END;
-    IF IsIntFamily(l) & IsIntFamily(b) THEN RETURN TRUE END;
-    IF (ClassOf(l) = ClChar) & (ClassOf(b) = ClChar) THEN
+    IF IsIntFamily(l) AND IsIntFamily(b) THEN RETURN TRUE END;
+    IF (ClassOf(l) = ClChar) AND (ClassOf(b) = ClChar) THEN
       RETURN TRUE
     END;
     (* lenient: small int/char/bool tested against suitable sets;
        the span trap decides out-of-range at runtime *)
     IF ((ClassOf(l) = ClInt) OR (ClassOf(l) = ClChar)
-        OR (ClassOf(l) = ClBool)) & (SetWords(set) > 0) THEN
+        OR (ClassOf(l) = ClBool)) AND (SetWords(set) > 0) THEN
       RETURN TRUE
     END;
     RETURN FALSE
@@ -1718,7 +1717,7 @@ PROCEDURE SetElemCheck (first, elem: TypeIndex): BOOLEAN;
       RETURN TRUE
     END;
     IF SameType(first, elem) THEN RETURN TRUE END;
-    IF IsIntFamily(first) & IsIntFamily(elem) THEN RETURN TRUE END;
+    IF IsIntFamily(first) AND IsIntFamily(elem) THEN RETURN TRUE END;
     RETURN FALSE
   END SetElemCheck;
 

compiler/src/compiler.frm

@@ -31,7 +31,7 @@ MODULE -->Grammar;
       END;
 
     CONST
-      tab = 11C;
+      tab = CHR(9);
 
     VAR
       firstErr, lastErr: Err;
@@ -62,10 +62,10 @@ MODULE -->Grammar;
         i: CARDINAL;
       BEGIN
         i := 0; eof := FALSE; ch := CharAt(pos); INC(pos);
-        WHILE (ch # CR) & (ch # LF) & (ch # EOF) DO
+        WHILE (ch # CR) AND (ch # LF) AND (ch # EOF) DO
           line[i] := ch; INC(i); ch := CharAt(pos); INC(pos);
         END;
-        eof := (i = 0) & (ch = EOF); line[i] := 0C;
+        eof := (i = 0) AND (ch = EOF); line[i] := CHR(0);
         IF ch = CR THEN (* check for MsDos *)
           ch := CharAt(pos);
           IF ch = LF THEN INC(pos); Extra := 0 END
@@ -148,10 +148,10 @@ MODULE -->Grammar;
         WriteLn(lst); WriteLn(lst);
         srcPos := 0; nextErr := firstErr;
         GetLine(srcPos, line, eof); lnr := 1; errC := 0;
-        WHILE ~ eof DO
+        WHILE NOT eof DO
           WriteInt(lst, lnr, 5); WriteString(lst, "  ");
           WriteString(lst, line); WriteLn(lst);
-          WHILE (nextErr # NIL) & (nextErr^.line = lnr) DO
+          WHILE (nextErr # NIL) AND (nextErr^.line = lnr) DO
             PrintErr(line, nextErr^.nr, nextErr^.col); INC(errC);
             nextErr := nextErr^.next
           END;
@@ -184,7 +184,7 @@ MODULE -->Grammar;
           IF n < 0 THEN Write(StdOut, "-"); n := -n END;
           i := 0;
           IF n = 0 THEN buf[0] := "0"; i := 1 END;
-          WHILE (n > 0) & (i <= HIGH(buf)) DO
+          WHILE (n > 0) AND (i <= HIGH(buf)) DO
             buf[i] := CHR(ORD("0") + VAL(CARDINAL, n MOD 10));
             n := n DIV 10; INC(i)
           END;
@@ -233,11 +233,11 @@ MODULE -->Grammar;
     BEGIN
       Strings.Assign(oldName, newName);
       i := LENGTH(oldName); l := i;
-      WHILE (i > 0) & (oldName[i -1] # '.')
-            & (oldName[i -1] # '\') & (oldName[i -1] # '/') DO
+      WHILE (i > 0) AND (oldName[i -1] # '.')
+ AND (oldName[i -1] # '\') AND (oldName[i -1] # '/') DO
         DEC(i)
       END;
-      IF (i > 0) & (oldName[i-1] = '.') THEN
+      IF (i > 0) AND (oldName[i-1] = '.') THEN
         Strings.Delete(newName, i - 1, l + 1 - i)
       END;
       IF Ext[0] = '.' THEN Strings.Delete(Ext, 0, 1) END;
@@ -251,15 +251,15 @@ MODULE -->Grammar;
       i, j, k: CARDINAL;
     BEGIN
       i := 0; j := 0;
-      WHILE (i <= HIGH(path)) & (path[i] # 0C) DO
+      WHILE (i <= HIGH(path)) AND (path[i] # CHR(0)) DO
         IF (path[i] = '/') OR (path[i] = '\') THEN j := i + 1 END;
         INC(i)
       END;
       k := j;
-      WHILE (k < i) & (path[k] # '.') DO INC(k) END;
+      WHILE (k < i) AND (path[k] # '.') DO INC(k) END;
       i := 0;
       WHILE j < k DO name[i] := path[j]; INC(i); INC(j) END;
-      name[i] := 0C
+      name[i] := CHR(0)
     END BaseName;
 
   VAR
@@ -274,7 +274,7 @@ MODULE -->Grammar;
     nFiles := 0;
     LOOP
       FileIO.NextParameter(sourceName);
-      IF (sourceName[0] = 0C) OR (nFiles > HIGH(files)) THEN EXIT END;
+      IF (sourceName[0] = CHR(0)) OR (nFiles > HIGH(files)) THEN EXIT END;
       Strings.Assign(sourceName, files[nFiles]);
       INC(nFiles)
     END;
@@ -293,14 +293,14 @@ MODULE -->Grammar;
     WHILE f < nFiles DO
       Strings.Assign(files[f], sourceName);
       FileIO.Open(src, sourceName, FALSE);
-      IF ~ FileIO.Okay THEN
+      IF NOT FileIO.Okay THEN
         FileIO.WriteString(FileIO.StdOut, "Could not open input file");
         FileIO.WriteLn(FileIO.StdOut);
         HALT
       END;
       ChangeExtension(sourceName, ".LST", listName);
       FileIO.Open(lst, listName, TRUE);
-      IF ~ FileIO.Okay THEN lst := FileIO.StdOut END;
+      IF NOT FileIO.Okay THEN lst := FileIO.StdOut END;
       ResetErrors;
 
       FileIO.WriteString(FileIO.StdOut, "Parsing");

compiler/src/parser.frm

@@ -63,7 +63,7 @@ PROCEDURE ExpectWeak (n, follow: CARDINAL);
   BEGIN
     IF sym = n
       THEN Get
-      ELSE SynError(n); WHILE ~ In(symSet[follow], sym) DO Get END
+      ELSE SynError(n); WHILE NOT In(symSet[follow], sym) DO Get END
     END
   END ExpectWeak;
 
@@ -80,7 +80,7 @@ PROCEDURE WeakSeparator (n, syFol, repFol: CARDINAL): BOOLEAN;
         WHILE i <= maxT DIV setsize DO
           s[i] := symSet[0, i] + symSet[syFol, i] + symSet[repFol, i]; INC(i)
         END;
-        SynError(n); WHILE ~ In(s, sym) DO Get END;
+        SynError(n); WHILE NOT In(s, sym) DO Get END;
         RETURN In(symSet[syFol], sym)
     END
   END WeakSeparator;

compiler/src/scanner.frm

@@ -7,11 +7,11 @@ IMPORT FileIO, Storage;
 CONST
   noSYMB  = -->unknownsym; (*error token code*)
   (* not only for errors but also for not finished states of scanner analysis *)
-  eof     = 32C (* MS-DOS Keyboard eof char *);
-  EOF     = 0C;
-  EOL     = 15C;
-  CR      = 15C;
-  LF      = 12C;
+  eof     = CHR(26) (* MS-DOS Keyboard eof char *);
+  EOF     = CHR(0);
+  EOL     = CHR(13);
+  CR      = CHR(13);
+  LF      = CHR(10);
   Long0   = 0;
   Long1   = 1;
   BlkSize = 16384;
@@ -106,7 +106,7 @@ PROCEDURE GetString (pos: INT32; len: CARDINAL; VAR s: ARRAY OF CHAR);
     WHILE i < len DO
       s[i] := CharAt(p); INC(i); INC(p)
     END;
-    s[len] := 0C;
+    s[len] := CHR(0);
   END GetString;
 
 PROCEDURE GetName (pos: INT32; len: CARDINAL; VAR s: ARRAY OF CHAR);
@@ -119,7 +119,7 @@ PROCEDURE GetName (pos: INT32; len: CARDINAL; VAR s: ARRAY OF CHAR);
     WHILE i < len DO
       s[i] := CurrentCh(p); INC(i); INC(p)
     END;
-    s[len] := 0C;
+    s[len] := CHR(0);
   END GetName;
 
 PROCEDURE CharAt (pos: INT32): CHAR;

docs/summary_step8.1.md

@@ -0,0 +1,54 @@
+# V3 step 8.1 — Redux sweep of the compiler sources (done 2026-09-22)
+
+Step-8 prep: make V3 able to compile the compiler's own sources by
+removing gm2-dialect syntax from them (Kowarsch/Redux cleanups).
+Suite 103/103, build warning-free.
+
+## The sweep
+
+A scripted conversion (skipping string literals and `(* *)` comments)
+applied to `M2.atg`, `SymTab.mod`, `QbeGen.mod`, `compiler.frm`,
+`parser.frm`, `scanner.frm`:
+
+- `&` → `AND`, `~` → `NOT`, `<>` → `#`.
+- Octal char-code literals `NNC` → `CHR(decimal)`
+  (`0C`→`CHR(0)`, `15C`→`CHR(13)`, `32C`→`CHR(26)`, `177C`→`CHR(127)`, …).
+
+(`FileIO.def/.mod` untouched — it stays the host library for the
+stage-1 build.)
+
+Result: the sources are Redux-clean and still compile under gm2; the
+full suite is green. Generated `M2S`/`M2P`/`M2` are regenerated from
+the swept frames/grammar.
+
+## V3 grammar: lenient SYSTEM imports
+
+`FROM SYSTEM IMPORT TSIZE;` (and any pervasive name) now parses:
+`TSIZE`/`SIZE`/`ADR`/`HIGH`/`LEN`/`CHR`/`ORD`/`VAL`/`ABS`/`INC`/`DEC`
+are accepted as import items and ignored (the built-in applies). gm2
+still needs the import, V3 ignores it — one source, both compilers.
+
+## Gap analysis: V3 compiling `SymTab` (still fails)
+
+Running V3 over `SymTab.def` + `SymTab.mod` (with `Storage`,
+`SysShim`, `FileIO`) surfaces the next work:
+
+1. **Named-CONST folding.** Array/subrange bounds like
+   `ARRAY [0 .. MaxPend - 1]` are "not supported yet": the grammar
+   only folds literals (`ConstInt` on an immediate), while a named
+   `CONST` loads as a temporary. V3 must fold constant expressions
+   (named CONSTs, `+`/`-`) at compile time. This is the dominant
+   cause of the mass of 230s.
+2. **Type-operand `TSIZE`/`SIZE`.** `TSIZE(ScopeNode)` passes a type
+   name, not a designator; V3's built-in takes a designator.
+3. Cascading parser errors (`ident expected` at `END` of records,
+   stray 201s) that clear once the above are fixed.
+
+These are the core of step 8 proper (plus cross-stage `FileIO`
+selection and the fixpoint script).
+
+## Files
+
+`compiler/src/M2.atg` (lenient imports; swept actions),
+`SymTab.mod`, `QbeGen.mod`, `compiler.frm`, `parser.frm`,
+`scanner.frm` (Redux-clean). Harness/suite unchanged (103/103).