feat(compiler): rename params/locals in MOD bodies

All paramN/localN in COMPILER/SCANNER/ERRORS/CODEGEN bodies now
meaningful (kind/typeDesc/mode/size/mark/sym/slot/bit/shown/...).
Fixes FindFileOnDrives startDrive/currentDrive shadowing collision.
Verified: no numbered identifiers remain in src/compiler.

src/compiler/CODEGEN.MOD

@@ -190,10 +190,10 @@ EXCEPTION errorfound;
 
 (* $[+ remove procedure names *)
 
-PROCEDURE CodeAssert(param1: BOOLEAN);
+PROCEDURE CodeAssert(cond: BOOLEAN);
 EXCEPTION CE;
 BEGIN
-  IF NOT param1 THEN RAISE CE END;
+  IF NOT cond THEN RAISE CE END;
 END CodeAssert;
 
 PROCEDURE FlushCodeWindow;
@@ -207,41 +207,41 @@ END FlushCodeWindow;
 
 PROCEDURE SeekCodeWindow;
 VAR
-    local2 : CARDINAL;
-    local3 : CARDINAL;
-    local4 : CARDINAL;
+    baseSec : CARDINAL;
+    alignedBase : CARDINAL;
+    needBytes : CARDINAL;
 BEGIN
-  local2 := nextEmitPos DIV 512;
-  local3 := (local2 - ORD(local2 <> 0)) * 512;
-  IF local3 < windowBase THEN
-    local4 := windowBase - local3;
+  baseSec := nextEmitPos DIV 512;
+  alignedBase := (baseSec - ORD(baseSec <> 0)) * 512;
+  IF alignedBase < windowBase THEN
+    needBytes := windowBase - alignedBase;
     IF nextEmitPos > windowBase THEN
-      MOVE(ADDRESS(codeWindow), ADDRESS(codeWindow)+local4, nextEmitPos-windowBase);
+      MOVE(ADDRESS(codeWindow), ADDRESS(codeWindow)+needBytes, nextEmitPos-windowBase);
     END;
-    Files.SetPos(Scanner.codeFile, LONG(local3));
-    CodeAssert(Files.ReadBytes(Scanner.codeFile, ADDRESS(codeWindow), local4) = local4);
-    windowBase := local3;
+    Files.SetPos(Scanner.codeFile, LONG(alignedBase));
+    CodeAssert(Files.ReadBytes(Scanner.codeFile, ADDRESS(codeWindow), needBytes) = needBytes);
+    windowBase := alignedBase;
     windowLimit := windowBase + 4096;
   END;
 END SeekCodeWindow;
 
-PROCEDURE PeekCodeByte(param1: CARDINAL): CARDINAL;
+PROCEDURE PeekCodeByte(pos: CARDINAL): CARDINAL;
 VAR byte: BYTE;
 BEGIN
-  IF param1 >= windowBase THEN RETURN CARDINAL(codeWindow^[param1-windowBase]) END;
-  Files.SetPos(Scanner.codeFile, LONG(param1));
+  IF pos >= windowBase THEN RETURN CARDINAL(codeWindow^[pos-windowBase]) END;
+  Files.SetPos(Scanner.codeFile, LONG(pos));
   Files.ReadByte(Scanner.codeFile, byte);
   RETURN CARDINAL(byte)
 END PeekCodeByte;
 
-PROCEDURE PokeCodeByte(param2: BYTE; param1: CARDINAL);
+PROCEDURE PokeCodeByte(value: BYTE; pos: CARDINAL);
 BEGIN
-  IF param1 >= windowBase THEN
-    codeWindow^[param1-windowBase] := param2;
+  IF pos >= windowBase THEN
+    codeWindow^[pos-windowBase] := value;
     RETURN
   END;
-  Files.SetPos(Scanner.codeFile, LONG(param1));
-  Files.WriteByte(Scanner.codeFile, param2);
+  Files.SetPos(Scanner.codeFile, LONG(pos));
+  Files.WriteByte(Scanner.codeFile, value);
 END PokeCodeByte;
 
 PROCEDURE CheckCodeOverflow;
@@ -249,37 +249,37 @@ BEGIN
   IF nextEmitPos >= codepos THEN RAISE errorfound END;
 END CheckCodeOverflow;
 
-PROCEDURE Emit1(param1: BYTE); 
+PROCEDURE Emit1(op: BYTE); 
 BEGIN 
   IF nextEmitPos >= windowLimit THEN FlushCodeWindow END;
-  codeWindow^[nextEmitPos-windowBase] := param1;
+  codeWindow^[nextEmitPos-windowBase] := op;
   INC(nextEmitPos);
   IF checkOverflow THEN CheckCodeOverflow END;
 END Emit1;
 
-PROCEDURE Emit2(param2, param1: BYTE);
+PROCEDURE Emit2(op2, op1: BYTE);
 BEGIN 
   IF nextEmitPos + 1 >= windowLimit THEN FlushCodeWindow END;
-  codeWindow^[nextEmitPos - windowBase] := param2;
-  codeWindow^[nextEmitPos + 1 - windowBase] := param1;
+  codeWindow^[nextEmitPos - windowBase] := op2;
+  codeWindow^[nextEmitPos + 1 - windowBase] := op1;
   INC(nextEmitPos, 2);
   IF checkOverflow THEN CheckCodeOverflow END;
 END Emit2;
 
-PROCEDURE EmitWord(param1: WORD);
+PROCEDURE EmitWord(w: WORD);
 VAR ptr: ADDRESS;
 BEGIN
   IF nextEmitPos + 1 >= windowLimit THEN FlushCodeWindow END;
   ptr := ADDRESS(codeWindow) + (nextEmitPos - windowBase);
-  ptr^ := param1;
+  ptr^ := w;
   INC(nextEmitPos, 2);
   IF checkOverflow THEN CheckCodeOverflow END;
 END EmitWord;
 
-PROCEDURE EmitString(param1: ADDRESS);
+PROCEDURE EmitString(s: ADDRESS);
 VAR ptr : POINTER TO ARRAY [0..1] OF BYTE;
 BEGIN 
-  ptr := param1;
+  ptr := s;
   REPEAT
     Emit1(ptr^[0]);
     ptr := ADDRESS(ptr) + 1;
@@ -288,10 +288,10 @@ BEGIN
 END EmitString;
 
 PROCEDURE FlushPendingOp;
-VAR local2: CARDINAL;
-  PROCEDURE BaseOpCode(param1: CARDINAL): CARDINAL;
+VAR base: CARDINAL;
+  PROCEDURE BaseOpCode(mode: CARDINAL): CARDINAL;
   BEGIN
-    CASE param1 OF
+    CASE mode OF
     | 8    : RETURN  60H
     | 9    : RETURN 0ECH
     | 1, 5 : RETURN  2CH
@@ -301,10 +301,10 @@ VAR local2: CARDINAL;
   END BaseOpCode;
 BEGIN
   pendActive := FALSE;
-  local2 := 0;
+  base := 0;
   IF pendMode <> 9 THEN
     pendOffset := pendOffset DIV 2;
-    local2 := pendMode DIV 4 * (ORD((pendMode MOD 4) <> 3) * 12 + 4);
+    base := pendMode DIV 4 * (ORD((pendMode MOD 4) <> 3) * 12 + 4);
   END;
   IF pendSize = 4 THEN
     IF pendDisp = 1 
@@ -321,18 +321,18 @@ BEGIN
   IF pendSize = 5 THEN
     IF pendMode IN {3,7} 
     THEN Emit2(pendMode DIV 4 + 8, 0)
-    ELSE Emit1(pendMode MOD 4 + local2 + 13)
+    ELSE Emit1(pendMode MOD 4 + base + 13)
     END;
   ELSE
     IF pendMode IN {0,4} THEN INC(pendMode) END;
     IF pendSize = 3 THEN
       IF (pendOffset <= 15) AND (pendDisp <= 15) AND (pendMode IN {1,5,9})
       THEN 
-        IF pendMode = 9 THEN local2 := 0E4H END;
-        Emit2(local2 + 12, pendDisp * 16 + pendOffset);
+        IF pendMode = 9 THEN base := 0E4H END;
+        Emit2(base + 12, pendDisp * 16 + pendOffset);
         RETURN
       END;
-      Emit2(BaseOpCode(pendMode)+local2+3, pendDisp);
+      Emit2(BaseOpCode(pendMode)+base+3, pendDisp);
       Emit1(pendOffset);
     ELSE
       CASE pendMode OF
@@ -346,26 +346,26 @@ BEGIN
           IF (pendSize <> 2) OR NOT Compiler.rangeCheckEnabled THEN
             IF pendSize = 0 THEN
               IF pendOffset <= 7 THEN
-                Emit1(pendOffset + local2);
+                Emit1(pendOffset + base);
                 RETURN
               ELSIF pendOffset >= 245 THEN
-                Emit1(local2 + 288 - pendOffset);
+                Emit1(base + 288 - pendOffset);
                 RETURN
               END;
             ELSE
               IF (pendOffset >= (4 - pendSize * 2)) AND (pendOffset <= 15) THEN
-                Emit1((pendSize + 1) * 32 + pendOffset + local2);
+                Emit1((pendSize + 1) * 32 + pendOffset + base);
                 RETURN
               END;
             END;
           END;
       | 2, 6:
           IF (pendSize = 2) AND (pendOffset = 0) THEN
-            Emit1(local2 + (OPLGW2 - 1));
+            Emit1(base + (OPLGW2 - 1));
             RETURN
           END;
       END;
-      Emit2(BaseOpCode(pendMode) + pendSize + local2, pendOffset);
+      Emit2(BaseOpCode(pendMode) + pendSize + base, pendOffset);
       IF Compiler.rangeCheckEnabled AND (pendMode = 8) AND (pendSize <= 1) THEN
         Emit1(pendDisp)
       END;
@@ -375,79 +375,79 @@ END FlushPendingOp;
 
 PROCEDURE FlushConstQueue;
 VAR
-    local2 : CARDINAL;
-    local3 : CARDINAL;
-    local4 : CARDINAL;
-    local5 : POINTER TO Record;
+    idx : CARDINAL;
+    k : CARDINAL;
+    w : CARDINAL;
+    entry : POINTER TO Record;
 BEGIN
   IF pendActive THEN FlushPendingOp
   ELSE
     IF fixupCount <> 0 THEN
-      local2 := 0;
-      WHILE local2 < fixupCount DO
-        local5 := ADR(fixupQueue[local2]);
-        CASE local5^.word0 OF
+      idx := 0;
+      WHILE idx < fixupCount DO
+        entry := ADR(fixupQueue[idx]);
+        CASE entry^.word0 OF
         | 0: (* 02EE *)
-            IF local5^.word2 <> 0 THEN Emit2(2, local5^.word2)
-            ELSE Emit2(OPCALLREL, Scanner.StrLenHelper(local5^.word1, 128));
-                 EmitString(local5^.word1);
+            IF entry^.word2 <> 0 THEN Emit2(2, entry^.word2)
+            ELSE Emit2(OPCALLREL, Scanner.StrLenHelper(entry^.word1, 128));
+                 EmitString(entry^.word1);
             END;
         | 1: (* 0308 *)
-            IF local5^.word1 <= 255 THEN
-              IF local5^.word1 <= 15
-              THEN Emit1(local5^.word1 + OPLI0)
-              ELSE Emit2(OPLIB, local5^.word1)
+            IF entry^.word1 <= 255 THEN
+              IF entry^.word1 <= 15
+              THEN Emit1(entry^.word1 + OPLI0)
+              ELSE Emit2(OPLIB, entry^.word1)
               END;
             ELSE (* 0323 *)
               Emit1(OPLIW);
-              EmitWord(local5^.word1)
+              EmitWord(entry^.word1)
             END; (* 0329 *)
         | 2: (* 032A *)
             Emit1(OPLID);
-            EmitWord(local5^.word1);
-            EmitWord(local5^.word2);
+            EmitWord(entry^.word1);
+            EmitWord(entry^.word2);
         | 3: (* 0334 *)
-            local4 := 8;
+            w := 8;
             REPEAT (* 0336 *)
-              DEC(local4, 4);
+              DEC(w, 4);
               Emit1(OPLID);
-              local3 := 0;
+              k := 0;
               REPEAT (* 033F *)
-                Emit1(local5^.ptr1^[local4 + local3]);
-                INC(local3);
-              UNTIL local3 > 3;
-            UNTIL local4 = 0;
+                Emit1(entry^.ptr1^[w + k]);
+                INC(k);
+              UNTIL k > 3;
+            UNTIL w = 0;
             IF Compiler.rangeCheckEnabled THEN Emit2(0, 22) END;
         | 4: (* 035B *)
-            IF CARDINAL(ABS(INTEGER(local5^.word1))) <= 255 THEN
-              IF local5^.word1 <> NIL THEN
-                IF ABS(INTEGER(local5^.word1)) = 1 THEN
-                  Emit1(ORD(INTEGER(local5^.word1) < 0) + OPINC)
+            IF CARDINAL(ABS(INTEGER(entry^.word1))) <= 255 THEN
+              IF entry^.word1 <> NIL THEN
+                IF ABS(INTEGER(entry^.word1)) = 1 THEN
+                  Emit1(ORD(INTEGER(entry^.word1) < 0) + OPINC)
                 ELSE (* 0378 *)
-                  Emit2(ORD(INTEGER(local5^.word1) < 0) + OPADDN,
-                        ABS(INTEGER(local5^.word1)));
+                  Emit2(ORD(INTEGER(entry^.word1) < 0) + OPADDN,
+                        ABS(INTEGER(entry^.word1)));
                 END;
               END; (* 0382 *)
             ELSE (* 0384 *)
               Emit1(OPLIW);
-              EmitWord(local5^.word1);
+              EmitWord(entry^.word1);
               Emit1(OPADD);
             END; (* 038d *)
 (* $T+ generates ELSE RAISE CaseSelectError *)
         END; (* CASE *)
-        INC(local2);
+        INC(idx);
       END; (* 03A8 *)
       fixupCount := 0;
     END (* 03AA *)
   END (* 03aa *);
 END FlushConstQueue;
 
-PROCEDURE Reserved33(param1: WORD);
+PROCEDURE Reserved33(dummy: WORD);
 BEGIN
   (* commented contents ? *)
 END Reserved33;
 
-PROCEDURE Reserved34(param2, param1: WORD);
+PROCEDURE Reserved34(a, b: WORD);
 VAR unused: WORD;
 BEGIN
   (* commented contents ? *)
@@ -462,22 +462,22 @@ BEGIN
   END;
 END DiscardPending;
 
-PROCEDURE SetPendingOp(param4, param3, param2, param1: CARDINAL);
+PROCEDURE SetPendingOp(mode, size, disp, off: CARDINAL);
 BEGIN 
   IF emitEnabled THEN
     FlushConstQueue;
-    pendMode  := param4;
-    pendSize  := param3;
-    pendDisp  := param2;
-    pendOffset := param1;
+    pendMode  := mode;
+    pendSize  := size;
+    pendDisp  := disp;
+    pendOffset := off;
     pendActive := TRUE;
-    IF param4 IN {4,5,6,7,9} THEN FlushPendingOp END;
+    IF mode IN {4,5,6,7,9} THEN FlushPendingOp END;
   END;
 END SetPendingOp;
 
 (* $T- *)
 
-PROCEDURE QueueConst(param1: CARDINAL);
+PROCEDURE QueueConst(value: CARDINAL);
 VAR ptr : POINTER TO Record;
 BEGIN 
   IF emitEnabled THEN
@@ -485,30 +485,30 @@ BEGIN
     IF fixupCount >= 16 THEN Scanner.ScannerError(90) END;
     ptr := ADR(fixupQueue[fixupCount]);
     ptr^.word0 := 1;
-    ptr^.word1 := param1;
+    ptr^.word1 := value;
     INC(fixupCount);
   END;
 END QueueConst;
 
-PROCEDURE QueueLongConst(param3: CARDINAL; param1: LONGINT);
+PROCEDURE QueueLongConst(kind: CARDINAL; value: LONGINT);
 VAR ptr : POINTER TO Record;
 BEGIN 
   IF emitEnabled THEN
     IF pendActive THEN FlushPendingOp END;
     IF fixupCount >= 16 THEN Scanner.ScannerError(90) END;
     ptr := ADR(fixupQueue[fixupCount]);
-    ptr^.word0 := param3;
-    ptr^.long1 := param1;
+    ptr^.word0 := kind;
+    ptr^.long1 := value;
     INC(fixupCount);
   END;
 END QueueLongConst;
 
-PROCEDURE EmitTypedOp(param2, param1 : CARDINAL);
-VAR ptr: POINTER TO Record;
-    local3 : CARDINAL;
-    ptr2: POINTER TO Record;  
+PROCEDURE EmitTypedOp(subOp, typeKind : CARDINAL);
+VAR lastEntry: POINTER TO Record;
+    extBase : CARDINAL;
+    prevEntry: POINTER TO Record;  
 
-  PROCEDURE IsPowerOfTwo(param1: CARDINAL): BOOLEAN;
+  PROCEDURE IsPowerOfTwo(target: CARDINAL): BOOLEAN;
   VAR
     i: CARDINAL;
     j: CARDINAL;
@@ -516,7 +516,7 @@ VAR ptr: POINTER TO Record;
     j := 1;
     i := 0;
     REPEAT
-      IF j = param1 THEN ptr := ADDRESS(i); RETURN TRUE END;
+      IF j = target THEN lastEntry := ADDRESS(i); RETURN TRUE END;
       j := j * 2;
       INC(i);
     UNTIL i > 14;
@@ -531,36 +531,36 @@ VAR ptr: POINTER TO Record;
 BEGIN
   IF emitEnabled THEN
     IF fixupCount <> 0 THEN
-      ptr2 := ADR(fixupQueue[fixupCount - 1]);
-      IF ptr2^.word0 = 1 THEN
-        IF (param2 IN {6,7}) AND (param1 <= 1) THEN
-          IF param2 = 7 THEN ptr2^.word1 := -INTEGER(ptr2^.word1) END;
+      prevEntry := ADR(fixupQueue[fixupCount - 1]);
+      IF prevEntry^.word0 = 1 THEN
+        IF (subOp IN {6,7}) AND (typeKind <= 1) THEN
+          IF subOp = 7 THEN prevEntry^.word1 := -INTEGER(prevEntry^.word1) END;
           IF fixupCount > 1 THEN
             IF fixupQueue[fixupCount - 2].word0 IN {1,4} THEN
-              INC(fixupQueue[fixupCount - 2].word1, ptr2^.word1);
+              INC(fixupQueue[fixupCount - 2].word1, prevEntry^.word1);
               DEC(fixupCount); 
             END; (* 04A9 *)
           END; (* 04A9 *)
-          ptr2^.word0 := 4;
+          prevEntry^.word0 := 4;
           RETURN;
         ELSE (* 04AF *)
-          IF (param2 IN {8,9}) AND (param1 = 0) AND IsPowerOfTwo(ptr2^.word1) THEN
+          IF (subOp IN {8,9}) AND (typeKind = 0) AND IsPowerOfTwo(prevEntry^.word1) THEN
             DEC(fixupCount);
             FlushConstQueue;
-            IF ptr <> NIL THEN Emit2(param2 + OPMUL, ptr) END; (* 04CE *)
+            IF lastEntry <> NIL THEN Emit2(subOp + OPMUL, lastEntry) END; (* 04CE *)
             RETURN
           ELSE (* 04D1 *)
-            IF (param2 = 10) AND (param1 <= 1) AND IsPowerOfTwo(ptr2^.word1) THEN
-              DEC(ptr2^.word1);
+            IF (subOp = 10) AND (typeKind <= 1) AND IsPowerOfTwo(prevEntry^.word1) THEN
+              DEC(prevEntry^.word1);
               FlushConstQueue;
               Emit1(OPBITAND);
               RETURN
             ELSE (* 04EE *)
-              IF (NOT Compiler.rangeCheckEnabled) AND (ptr2^.word1 = 0) 
-              AND (param2 IN {0,1,3}) AND (param1 <= ORD(param2 <> 3)) THEN
+              IF (NOT Compiler.rangeCheckEnabled) AND (prevEntry^.word1 = 0) 
+              AND (subOp IN {0,1,3}) AND (typeKind <= ORD(subOp <> 3)) THEN
                 DEC(fixupCount);
                 FlushConstQueue;
-                Emit1(OPEQ0 + ORD(param2 <> 0) * 32);
+                Emit1(OPEQ0 + ORD(subOp <> 0) * 32);
                 RETURN
               END; (* 0512 *)
             END; (* 0512 *)
@@ -569,37 +569,37 @@ BEGIN
       END; (* 0512 *)
     END; (* 0512 *)
     FlushConstQueue;
-    IF (param1 = 5) OR (param2 = 18) THEN
-      local3 := Scanner.EnterModuleSymbol("DOUBLES", 9567H) * 16;
+    IF (typeKind = 5) OR (subOp = 18) THEN
+      extBase := Scanner.EnterModuleSymbol("DOUBLES", 9567H) * 16;
     END; (* 0532 *)
-    CASE param1 OF
+    CASE typeKind OF
     | 0: (* 0536 *)
-        IF param2 >= 15 THEN
+        IF subOp >= 15 THEN
           IF Compiler.rangeCheckEnabled THEN Emit1(125) ELSE Emit2(144,33) END;
-          param1 := 2;
+          typeKind := 2;
         END; (* 054b *)
     | 1: (* 054c *)
-        IF param2 >= 15 THEN
+        IF subOp >= 15 THEN
           Emit1(189);
-          param1 := 2;
+          typeKind := 2;
         ELSE
-          IF param2 IN {0,1,6,7,10} THEN param1 := 0
-          ELSIF param2 = 11 THEN Emit2(OPCOMPL, OPINC); RETURN
+          IF subOp IN {0,1,6,7,10} THEN typeKind := 0
+          ELSIF subOp = 11 THEN Emit2(OPCOMPL, OPINC); RETURN
           END; (* 056E *)
         END; (* 056E *)
     | 2: (* 056f *)
-        IF param2 <= 5 THEN Emit1(OPDCOMP); EmitSystemCall(23); param1 := 0
-        ELSIF param2 = 11 THEN
+        IF subOp <= 5 THEN Emit1(OPDCOMP); EmitSystemCall(23); typeKind := 0
+        ELSIF subOp = 11 THEN
           Emit2(OPEXTENDED,3); RETURN
         END; (* 0589 *)
     | 3: (* 058a *)
-        IF param2 <= 5 THEN
-          Emit1(OPREALCMP); EmitSystemCall(23); param1 := 0
-        ELSIF param2 IN {11,12} THEN
-          IF Compiler.rangeCheckEnabled THEN Emit1(param2 + OPSSW0)
+        IF subOp <= 5 THEN
+          Emit1(OPREALCMP); EmitSystemCall(23); typeKind := 0
+        ELSIF subOp IN {11,12} THEN
+          IF Compiler.rangeCheckEnabled THEN Emit1(subOp + OPSSW0)
           ELSE
             Emit1(OPSWAP);
-            IF param2 = 11 THEN
+            IF subOp = 11 THEN
               Emit2(OPLI15, OPPOWER2); Emit1(OPBITXOR);
             ELSE (* 05BD *)
               Emit1(OPLIW); EmitWord(7FFFH); Emit1(OPBITAND); 
@@ -607,64 +607,64 @@ BEGIN
             Emit1(OPSWAP);
           END; (* 05ca *)
           RETURN
-        ELSIF param2 IN {13,14,15} THEN
+        ELSIF subOp IN {13,14,15} THEN
           Emit1(OPFLOAT2LG);
-          param1 := 2;
+          typeKind := 2;
         END; (* 05d9 *)
     | 4: (* 05da *)
-        IF param2 <= 5 THEN
-          IF param2 = 5 THEN
+        IF subOp <= 5 THEN
+          IF subOp = 5 THEN
             Emit1(OPSWAP);
-            param2 := 4;
+            subOp := 4;
           END; (* 05E9 *)
-          IF param2 = 4 THEN Emit2(OPCOMPL, OPBITAND); Emit1(OPLI0); param2 := 0 END; (* 05F8 *)
-          param1 := 0
-        ELSIF param2 = 7 THEN
-          Emit1(OPCOMPL); param2 := 8
+          IF subOp = 4 THEN Emit2(OPCOMPL, OPBITAND); Emit1(OPLI0); subOp := 0 END; (* 05F8 *)
+          typeKind := 0
+        ELSIF subOp = 7 THEN
+          Emit1(OPCOMPL); subOp := 8
         END; (* 0606 *)
     | 5: (* 0607 *)
-        IF param2 <> 18 THEN
+        IF subOp <> 18 THEN
           Emit1(OPEXTCALL1);
-          IF param2 <= 5 THEN Emit1(local3+5); param1 := 0
-          ELSIF param2 >= 13 THEN
-            param1 := ORD(param2 = 16) + 2;
-            Emit1(local3 + param1 - 1);
-          ELSE Emit1(local3 + param2)
+          IF subOp <= 5 THEN Emit1(extBase+5); typeKind := 0
+          ELSIF subOp >= 13 THEN
+            typeKind := ORD(subOp = 16) + 2;
+            Emit1(extBase + typeKind - 1);
+          ELSE Emit1(extBase + subOp)
           END; (* 0634*)
           IF Compiler.rangeCheckEnabled THEN
-            Emit2(ORD(param2 <= 9)+1, (ORD(param2 IN {6,7,8,9,10,11,12})+1)*4);
-            IF param2 <= 5 THEN EmitSystemCall(23) END;
+            Emit2(ORD(subOp <= 9)+1, (ORD(subOp IN {6,7,8,9,10,11,12})+1)*4);
+            IF subOp <= 5 THEN EmitSystemCall(23) END;
           END; (* 064E *)
-          IF param1 = 5 THEN RETURN END;
+          IF typeKind = 5 THEN RETURN END;
         END; (* 0654 *)
 (* $T+ generate CaseSelectError exception *)
     END; (* 066c *)
 (* $T- *)
-    IF param2 <= 12 THEN
-      Emit1(param2 + param1 * 16 + 160);
-    ELSIF param2 - 13 <> param1 THEN
-      IF param2 <= 14 THEN
-        IF param1 <= 1 THEN Emit1(221) ELSE Emit1(param2 + 173) END;
-      ELSIF param2 <= 16 THEN Emit1(param1 + 188)
+    IF subOp <= 12 THEN
+      Emit1(subOp + typeKind * 16 + 160);
+    ELSIF subOp - 13 <> typeKind THEN
+      IF subOp <= 14 THEN
+        IF typeKind <= 1 THEN Emit1(221) ELSE Emit1(subOp + 173) END;
+      ELSIF subOp <= 16 THEN Emit1(typeKind + 188)
       ELSE (* 06A3 *) 
-        Emit2(OPEXTCALL1, local3 + param1 + 1);
+        Emit2(OPEXTCALL1, extBase + typeKind + 1);
         IF Compiler.rangeCheckEnabled THEN Emit2(OPRAISE, 8) END;
       END; (* 06B1 *)
     END; (* 06B1 *)
   END; (* 06b1 *)
 END EmitTypedOp;
 
-PROCEDURE EmitExtendedOp(param2, param1: CARDINAL);
+PROCEDURE EmitExtendedOp(subOp, typeKind: CARDINAL);
 BEGIN 
-  IF emitEnabled THEN FlushConstQueue; Emit1(param1 * 16 + param2 + 186) END;
+  IF emitEnabled THEN FlushConstQueue; Emit1(typeKind * 16 + subOp + 186) END;
 END EmitExtendedOp;
 
 
-PROCEDURE EmitStandardOp(param1: CARDINAL);
+PROCEDURE EmitStandardOp(stdNo: CARDINAL);
 VAR ptr: RecordPtr;
 BEGIN 
   IF emitEnabled THEN
-    IF (param1 = 0) AND (fixupCount <> 0) THEN
+    IF (stdNo = 0) AND (fixupCount <> 0) THEN
       ptr := ADR(fixupQueue[fixupCount-1]);
       IF (ptr^.word0 = 1) AND (ptr^.word1 = 0) THEN
         DEC(fixupCount);
@@ -674,23 +674,23 @@ BEGIN
       END; (* 06EC *)
     END; (* 06EC *)
     FlushConstQueue;
-    IF param1 >= 23 THEN
+    IF stdNo >= 23 THEN
       Emit1(OPEXTENDED);
     END; (* 06F7 *)
 (* $T+ *)
-    Emit1( Compiler.keywordTable[param1][0] );
+    Emit1( Compiler.keywordTable[stdNo][0] );
 (* $T- *)
   END; (* 0701 *)
 END EmitStandardOp;
 
-PROCEDURE EmitMiscOp(param2, param1: CARDINAL);
+PROCEDURE EmitMiscOp(subOp, n: CARDINAL);
 BEGIN 
   IF emitEnabled THEN
     FlushConstQueue;
-    IF param2 = 5 THEN
-      IF param1 >= 10 THEN
-        Emit2(OPEXTENDED, param1 - 5)
-      ELSIF param1 = 6 THEN
+    IF subOp = 5 THEN
+      IF n >= 10 THEN
+        Emit2(OPEXTENDED, n - 5)
+      ELSIF n = 6 THEN
         IF Compiler.rangeCheckEnabled THEN Emit1(102)
         ELSE
             (* generates the bad CAP sequence *)
@@ -699,51 +699,51 @@ BEGIN
         END; (* 073D *)
       ELSE (* 073F *)
 (* $T+ *)
-        Emit1(Compiler.keywordTable[param1+27][0]);
+        Emit1(Compiler.keywordTable[n+27][0]);
 (* $T- *)
       END; (* 074B *)
     ELSE (* 074D *)
-      IF param2 = 4 THEN
+      IF subOp = 4 THEN
         Emit2(OPLONGREAL, 10);
-        Emit1(param1);
-      ELSIF (param2 = 0) AND (param1 - 128 <= 3) AND (NOT Compiler.rangeCheckEnabled) THEN
-        Emit1(param1 + 8)
+        Emit1(n);
+      ELSIF (subOp = 0) AND (n - 128 <= 3) AND (NOT Compiler.rangeCheckEnabled) THEN
+        Emit1(n + 8)
       ELSE
-        Emit2(param2 + 132, param1)
+        Emit2(subOp + 132, n)
       END; (* 0775 *)
     END; (* 0775 *)
   END; (* 0775 *)
 END EmitMiscOp;
 
-PROCEDURE EmitSystemCall(param1: CARDINAL);
+PROCEDURE EmitSystemCall(sysNo: CARDINAL);
 BEGIN 
   IF emitEnabled THEN
     FlushConstQueue;
-    IF Compiler.rangeCheckEnabled AND (param1 <> 20) THEN Emit2(0,param1) END;
+    IF Compiler.rangeCheckEnabled AND (sysNo <> 20) THEN Emit2(0,sysNo) END;
   END;
 END EmitSystemCall;
 
-PROCEDURE EmitExtCall3(param3, param2, param1: CARDINAL); 
+PROCEDURE EmitExtCall3(a, b, c: CARDINAL); 
 BEGIN 
   IF emitEnabled THEN
     FlushConstQueue;
     IF Compiler.rangeCheckEnabled THEN
-      IF param3 <> 19 THEN Emit2(0, param3) END;
-      Emit1(param2);
-      IF param3 >= 3 THEN Emit1(param1) END;
+      IF a <> 19 THEN Emit2(0, a) END;
+      Emit1(b);
+      IF a >= 3 THEN Emit1(c) END;
     END; (* 07aa *)
   END;
 END EmitExtCall3;
 
-PROCEDURE OpenFixup(VAR param2: CARDINAL; param1: BOOLEAN);
-VAR local2: CARDINAL;
+PROCEDURE OpenFixup(VAR fixPos: CARDINAL; shortJump: BOOLEAN);
+VAR prevOp: CARDINAL;
 BEGIN 
   IF emitEnabled THEN
-    param2 := nextEmitPos;
-    IF param1 THEN
-      local2 := PeekCodeByte(nextEmitPos - 1);
-      IF local2 - 224 <= 1 THEN
-        PokeCodeByte(local2 + 2, nextEmitPos - 1);
+    fixPos := nextEmitPos;
+    IF shortJump THEN
+      prevOp := PeekCodeByte(nextEmitPos - 1);
+      IF prevOp - 224 <= 1 THEN
+        PokeCodeByte(prevOp + 2, nextEmitPos - 1);
       END;
       Emit1(0)
     ELSE EmitWord(0)
@@ -751,83 +751,83 @@ BEGIN
   END;
 END OpenFixup;
 
-PROCEDURE CloseFixup(param2: CARDINAL; param1: BOOLEAN); 
+PROCEDURE CloseFixup(fixPos: CARDINAL; shortJump: BOOLEAN); 
 BEGIN 
   IF emitEnabled THEN
-    IF param1 AND (nextEmitPos < param2 + 254) THEN
+    IF shortJump AND (nextEmitPos < fixPos + 254) THEN
       PokeCodeByte(PeekCodeByte(nextEmitPos - 1) + 4, nextEmitPos - 1);
-      Emit1(nextEmitPos + 1 - param2);
+      Emit1(nextEmitPos + 1 - fixPos);
     ELSE
-      EmitWord(param2 - (nextEmitPos + 1))
+      EmitWord(fixPos - (nextEmitPos + 1))
     END;
   END;
 END CloseFixup;
 
 
-PROCEDURE InsertFixup(param2: CARDINAL; param1: BOOLEAN): BOOLEAN;
+PROCEDURE InsertFixup(fixPos: CARDINAL; shortJump: BOOLEAN): BOOLEAN;
 VAR 
-    local2: BYTE;
-    local3: BYTE;
-    local4: CARDINAL;
-    local5: ADDRESS;
+    holdByte: BYTE;
+    prevByte: BYTE;
+    gapPos: CARDINAL;
+    moveSrc: ADDRESS;
 BEGIN 
   IF emitEnabled THEN
     FlushConstQueue;
-    local4 := param2 + 1;
-    IF param1 THEN
-      IF nextEmitPos > local4 + 254 THEN
-        IF local4 < windowBase THEN
-          Files.SetPos(Scanner.codeFile, LONG(local4));
-          Files.ReadByte(Scanner.codeFile, local2);
-          INC(local4);
-          WHILE local4 < windowBase DO
-            local3 := local2;
-            Files.ReadByte(Scanner.codeFile, local2);
-            Files.SetPos(Scanner.codeFile, LONG(local4));
-            Files.WriteByte(Scanner.codeFile, local3);
-            INC(local4)
+    gapPos := fixPos + 1;
+    IF shortJump THEN
+      IF nextEmitPos > gapPos + 254 THEN
+        IF gapPos < windowBase THEN
+          Files.SetPos(Scanner.codeFile, LONG(gapPos));
+          Files.ReadByte(Scanner.codeFile, holdByte);
+          INC(gapPos);
+          WHILE gapPos < windowBase DO
+            prevByte := holdByte;
+            Files.ReadByte(Scanner.codeFile, holdByte);
+            Files.SetPos(Scanner.codeFile, LONG(gapPos));
+            Files.WriteByte(Scanner.codeFile, prevByte);
+            INC(gapPos)
           END; (* 0842 *)
           MOVE(codeWindow, ADDRESS(codeWindow) + 1, nextEmitPos - windowBase);
-          codeWindow^[0] := local2;
+          codeWindow^[0] := holdByte;
         ELSE (* 0850 *)
-          local5 := ADDRESS(codeWindow) + local4 - windowBase;
-          MOVE(local5, local5 + 1, nextEmitPos - local4);
+          moveSrc := ADDRESS(codeWindow) + gapPos - windowBase;
+          MOVE(moveSrc, moveSrc + 1, nextEmitPos - gapPos);
         END; (* 085e *)
         INC(nextEmitPos);
-        PokeCodeByte( PeekCodeByte(param2 - 1) - 2, param2 - 1);
-        PokeCodeByte( (nextEmitPos - local4) MOD 256, param2);
-        PokeCodeByte( (nextEmitPos - local4) DIV 256, local4);
+        PokeCodeByte( PeekCodeByte(fixPos - 1) - 2, fixPos - 1);
+        PokeCodeByte( (nextEmitPos - gapPos) MOD 256, fixPos);
+        PokeCodeByte( (nextEmitPos - gapPos) DIV 256, gapPos);
         RETURN FALSE
       END; (* 087f *)
-      PokeCodeByte(nextEmitPos - local4, param2);
+      PokeCodeByte(nextEmitPos - gapPos, fixPos);
     ELSE (* 0887 *)
-      PokeCodeByte( (nextEmitPos - local4) MOD 256, param2);
-      PokeCodeByte( (nextEmitPos - local4) DIV 256, local4);
+      PokeCodeByte( (nextEmitPos - gapPos) MOD 256, fixPos);
+      PokeCodeByte( (nextEmitPos - gapPos) DIV 256, gapPos);
     END; (* 0898 *)
   END; (* 0898 *)
   RETURN TRUE
 END InsertFixup;
 
 
-PROCEDURE AdjustFixup(param1: CARDINAL);
-VAR local2: CARDINAL;
+PROCEDURE AdjustFixup(fixPos: CARDINAL);
+VAR dist: CARDINAL;
 BEGIN 
   IF emitEnabled THEN
-    IF PeekCodeByte(param1 - 1) <= 225 THEN
-      local2 := PeekCodeByte(param1) + PeekCodeByte(param1 + 1) * 256;
-      IF INTEGER(local2) > 0 THEN INC(local2) ELSE DEC(local2) END;
-      PokeCodeByte( local2 MOD 256, param1);
-      PokeCodeByte( local2 DIV 256, param1 + 1);
+    IF PeekCodeByte(fixPos - 1) <= 225 THEN
+      dist := PeekCodeByte(fixPos) + PeekCodeByte(fixPos + 1) * 256;
+      IF INTEGER(dist) > 0 THEN INC(dist) ELSE DEC(dist) END;
+      PokeCodeByte( dist MOD 256, fixPos);
+      PokeCodeByte( dist DIV 256, fixPos + 1);
     ELSE (* 08D2 *)
-      PokeCodeByte( PeekCodeByte(param1) + 1, param1);
+      PokeCodeByte( PeekCodeByte(fixPos) + 1, fixPos);
     END; (* 08D9 *)
   END; (* 08D9 *)
 END AdjustFixup;
 
 
-PROCEDURE MarkCodePos(param1: CARDINAL): CARDINAL;
+PROCEDURE MarkCodePos(n: CARDINAL): CARDINAL;
 BEGIN 
-  EmitSystemCall(param1);
+  EmitSystemCall(n);
   RETURN nextEmitPos
 END MarkCodePos;
 

src/compiler/COMPILER.MOD

@@ -20,10 +20,10 @@ VAR
 PROCEDURE InitCompiler; FORWARD;
 PROCEDURE OpenSourceAndOutput; FORWARD;
 
-PROCEDURE InsertIdent(keyword: ARRAY OF CHAR; n: CARDINAL):ADDRESS;
+PROCEDURE InsertIdent(keyword: ARRAY OF CHAR; kind: CARDINAL):ADDRESS;
 VAR ptr : RecordPtr;
 BEGIN
-  ptr := SCANNER.NewNode(n);
+  ptr := SCANNER.NewNode(kind);
   SCANNER.CopyStringToHeap(ptr^.word1, keyword);
   ptr^.word0 := curScopeHead;
   ptr^.word3 := 64;
@@ -31,43 +31,43 @@ BEGIN
   RETURN ptr
 END InsertIdent;
 
-PROCEDURE DeclConst(keyword: ARRAY OF CHAR; param3: RecordPtr;
-                param2: WORD; n:CARDINAL);
+PROCEDURE DeclConst(keyword: ARRAY OF CHAR; typeDesc: RecordPtr;
+                constValue: WORD; kind:CARDINAL);
 VAR ptr: RecordPtr;
 BEGIN 
-  ptr := InsertIdent(keyword, n);
-  ptr^.word2 := param3;
-  ptr^.word5 := param2;
+  ptr := InsertIdent(keyword, kind);
+  ptr^.word2 := typeDesc;
+  ptr^.word5 := constValue;
 END DeclConst;
 
 
-PROCEDURE DeclStdProc(keyword: ARRAY OF CHAR; param2,param1: WORD);
+PROCEDURE DeclStdProc(keyword: ARRAY OF CHAR; procNo,signature: WORD);
 VAR ptr: RecordPtr;
 BEGIN
   ptr := InsertIdent(keyword, 5);
-  ptr^.word5 := param2;
-  ptr^.high := param1;
+  ptr^.word5 := procNo;
+  ptr^.high := signature;
 END DeclStdProc;
 
-PROCEDURE DeclProc(keyword: ARRAY OF CHAR; param1: CARDINAL);
+PROCEDURE DeclProc(keyword: ARRAY OF CHAR; procNo: CARDINAL);
 BEGIN 
-  DeclStdProc(keyword, param1, 0);
+  DeclStdProc(keyword, procNo, 0);
   curScopeHead^.word3 := 192;
 END DeclProc;
 
 
-PROCEDURE DeclFunc(keyword: ARRAY OF CHAR; param2: CARDINAL; param1: RecordPtr);
+PROCEDURE DeclFunc(keyword: ARRAY OF CHAR; funcNo: CARDINAL; returnType: RecordPtr);
 BEGIN 
-  DeclProc(keyword, param2);
-  curScopeHead^.word2 := param1;
+  DeclProc(keyword, funcNo);
+  curScopeHead^.word2 := returnType;
 END DeclFunc;
 
 
-PROCEDURE NewTypeDesc(param2,param1: CARDINAL): RecordPtr;
+PROCEDURE NewTypeDesc(typeSize,typeId: CARDINAL): RecordPtr;
 VAR ptr : RecordPtr;
 BEGIN
-  ptr := SCANNER.NewSizedNode(param1);
-  ptr^.word3 := param2;
+  ptr := SCANNER.NewSizedNode(typeId);
+  ptr^.word3 := typeSize;
   RETURN ptr
 END NewTypeDesc;
 
@@ -84,18 +84,18 @@ END DeclType;
 
 
 PROCEDURE InitOperatorTable;
-  VAR n: CARDINAL;
+  VAR opIndex: CARDINAL;
 
-  PROCEDURE AddOperator(char1,char2: CHAR; param1: CARDINAL);
+  PROCEDURE AddOperator(char1,char2: CHAR; opCode: CARDINAL);
   BEGIN
-    ERRORS.opCharTable^[n]   := char1;
-    ERRORS.opCharTable^[n+1] := char2;
-    ERRORS.opCharTable^[n+2] := CHR(param1);
-    INC(n,3);
+    ERRORS.opCharTable^[opIndex]   := char1;
+    ERRORS.opCharTable^[opIndex+1] := char2;
+    ERRORS.opCharTable^[opIndex+2] := CHR(opCode);
+    INC(opIndex,3);
   END AddOperator;
 BEGIN 
   SCANNER.HeapAlloc(ERRORS.opCharTable, 27);
-  n := 0;
+  opIndex := 0;
   AddOperator(':','=',27);
   AddOperator('.','.', 4);
   AddOperator('<','=',56);
@@ -109,26 +109,26 @@ END InitOperatorTable;
 
 PROCEDURE InitCharClasses;
 CONST DEL = 177C;
-VAR i: CARDINAL;
-    local3: ARRAY [0..64] OF CHAR;
+VAR chCode: CARDINAL;
+    glyphs: ARRAY [0..64] OF CHAR;
     code : CARDINAL;
 BEGIN 
   SCANNER.HeapAlloc(SCANNER.charClassTable, 128);
-  i := ORD('A');
+  chCode := ORD('A');
   REPEAT
-    SCANNER.charClassTable^[i]    := CHR(10);
-    SCANNER.charClassTable^[i+32] := CHR(10);
-    INC(i);
-  UNTIL i > ORD('Z');
-  i := ORD('0'); REPEAT SCANNER.charClassTable^[i] := CHR(11); INC(i) UNTIL i > ORD('9');
+    SCANNER.charClassTable^[chCode]    := CHR(10);
+    SCANNER.charClassTable^[chCode+32] := CHR(10);
+    INC(chCode);
+  UNTIL chCode > ORD('Z');
+  chCode := ORD('0'); REPEAT SCANNER.charClassTable^[chCode] := CHR(11); INC(chCode) UNTIL chCode > ORD('9');
   SCANNER.charClassTable^[ORD('!')] := CHR(8);
   SCANNER.charClassTable^[ORD('~')] := CHR(66);
   SCANNER.charClassTable^[ORD(DEL)] := CHR(4);
   SCANNER.charClassTable^[ORD('"')] := CHR(12);
-  local3 := " ,:. )]}|;  '                              ([{^     =#<>  +-*  /&";
+  glyphs := " ,:. )]}|;  '                              ([{^     =#<>  +-*  /&";
   code := 0;
   REPEAT
-    IF local3[code] <> ' ' THEN SCANNER.charClassTable^[ORD(local3[code])]:=CHR(code) END;
+    IF glyphs[code] <> ' ' THEN SCANNER.charClassTable^[ORD(glyphs[code])]:=CHR(code) END;
     INC(code)
   UNTIL code > 64;
 END InitCharClasses;
@@ -205,13 +205,13 @@ BEGIN
 END DeclarePredefinedTypes;
 
 
-PROCEDURE MakeParamList(param3: CARDINAL; param2: CARDINAL; param1: RecordPtr): ADDRESS;
+PROCEDURE MakeParamList(paramCount: CARDINAL; resultKind: CARDINAL; firstType: RecordPtr): ADDRESS;
 VAR p : ArrayPtr;
 BEGIN
-  SCANNER.HeapAlloc(p, (param3+2)*2);
-  p^[0] := param3;
-  p^[1] := param2;
-  p^[2] := param1;
+  SCANNER.HeapAlloc(p, (paramCount+2)*2);
+  p^[0] := paramCount;
+  p^[1] := resultKind;
+  p^[2] := firstType;
   lastParamList := p;
   RETURN p
 END MakeParamList;
@@ -335,12 +335,12 @@ END DeclareStorageModule;
 (* $[- retain procedure name because of exception handler *)
 PROCEDURE OpenSourceAndOutput; 
 CONST DRVROVEC = 29;
-VAR local2 : ARRAY [0..2] OF CHAR;
-    char : CHAR;
+VAR cmdToken : ARRAY [0..2] OF CHAR;
+    driveCh : CHAR;
 BEGIN 
   SCANNER.ProcType := NIL;
   SCANNER.codeFile  := NIL;
-  Texts.ReadString(ComLine.commandLine, local2);
+  Texts.ReadString(ComLine.commandLine, cmdToken);
   IF NOT Files.Open(SCANNER.ProcType, ComLine.inName) THEN
     Terminal.WriteString(ComLine.inName);
     Terminal.WriteString(" not found.");
@@ -351,14 +351,14 @@ BEGIN
     IF ORD(ComLine.inName[0])-ORD('A') IN BITSET(IORESULT) THEN Files.ResetSys() END;
     ComLine.outName := ComLine.inName;
     SCANNER.ChangeFileExtension(ComLine.outName, "@@@", TRUE);
-    Texts.ReadString(ComLine.commandLine, local2);
-    IF (local2[1] = ':') AND (local2[2] = 0C) THEN
-      char := CAP(local2[0]);
-      IF ORD(char)-ORD('A') <= 15 THEN ComLine.outName[0] := char END;
+    Texts.ReadString(ComLine.commandLine, cmdToken);
+    IF (cmdToken[1] = ':') AND (cmdToken[2] = 0C) THEN
+      driveCh := CAP(cmdToken[0]);
+      IF ORD(driveCh)-ORD('A') <= 15 THEN ComLine.outName[0] := driveCh END;
     END;
     Files.Create(SCANNER.codeFile, ComLine.outName);
     Files.NoTrailer(SCANNER.ProcType);
-    Files.ReadByte(SCANNER.ProcType, char);
+    Files.ReadByte(SCANNER.ProcType, driveCh);
     Files.SetPos(SCANNER.ProcType, LONG(0));
   END;
 EXCEPTION Files.UseError:
@@ -369,8 +369,8 @@ END OpenSourceAndOutput;
 (* $[+ remove procedure names *)
 
 PROCEDURE InitCompiler; 
-VAR local2: ARRAY [0..2] OF CHAR;
-    option : CARDINAL;
+VAR cmdToken: ARRAY [0..2] OF CHAR;
+    optCode : CARDINAL;
     compilerOptions[0348H] : BITSET;
 BEGIN 
   nativeCodeRequested := FALSE;
@@ -386,10 +386,10 @@ BEGIN
   DeclareStorageModule;
   SCANNER.scanOptions := compilerOptions;
   rangeCheckEnabled := 2 IN SCANNER.scanOptions;
-  Texts.ReadString(ComLine.commandLine, local2);
-  IF local2[0] = '%' THEN
-    option := ORD(CAP(local2[1])) - ORD('L');
-    IF option <= 15 THEN INCL(SCANNER.scanOptions, option) END;
+  Texts.ReadString(ComLine.commandLine, cmdToken);
+  IF cmdToken[0] = '%' THEN
+    optCode := ORD(CAP(cmdToken[1])) - ORD('L');
+    IF optCode <= 15 THEN INCL(SCANNER.scanOptions, optCode) END;
   END;
   ERRORS.doSymtabRollback := FALSE;
   SCANNER.HeapAlloc(SYMTAB.IntType, 170);

src/compiler/ERRORS.MOD

@@ -48,25 +48,25 @@ BEGIN
 END FatalError;
 
 PROCEDURE FindFileOnDrives(VAR file: FILE; VAR name: ARRAY OF CHAR; ext: Ext);
-VAR currentDrive: CARDINAL;
-    local3: CARDINAL;
-    local4: ARRAY [0..13] OF CHAR;
+VAR startDrive: CARDINAL;
+    nameLen: CARDINAL;
+    tryName: ARRAY [0..13] OF CHAR;
 BEGIN
   IF NOT driveInitDone THEN
     currentDrive := Loader.firstDrive;
     driveInitDone := TRUE;
   END;
-  currentDrive := currentDrive;
-  local3 := HIGH(name);
-  IF local3 > 11 THEN local3 := 11 END;
-  MOVE(ADR(name), ADR(local4[2]), local3); 
-  local4[0] := CHR(currentDrive + ORD('A'));
-  local4[1] := ':';
-  Scanner.ChangeFileExtension(local4, ext, FALSE);
-  WHILE NOT Files.Open(file, local4) DO
+  startDrive := currentDrive;
+  nameLen := HIGH(name);
+  IF nameLen > 11 THEN nameLen := 11 END;
+  MOVE(ADR(name), ADR(tryName[2]), nameLen); 
+  tryName[0] := CHR(currentDrive + ORD('A'));
+  tryName[1] := ':';
+  Scanner.ChangeFileExtension(tryName, ext, FALSE);
+  WHILE NOT Files.Open(file, tryName) DO
     REPEAT
       currentDrive := (currentDrive + 1) MOD 16;
-      IF currentDrive = currentDrive THEN
+      IF currentDrive = startDrive THEN
         IF ext[0] = 'O' THEN
           ShowErrorPosition('E');
           WriteString("ERRMSGS.OVR not found, No =");
@@ -77,69 +77,69 @@ BEGIN
         END;
       END; (* 00B0 *)
     UNTIL currentDrive IN drivesToSearch;
-    local4[0] := CHR(currentDrive + ORD('A'));
+    tryName[0] := CHR(currentDrive + ORD('A'));
   END; (* 00c0 *)
 END FindFileOnDrives;
 
 (* $[- retain procedure names *)
 (* proc 17 *)
-PROCEDURE DoError(param1: CHAR); (* param1: user choice E(dit)/Q(uit) *)
+PROCEDURE DoError(choice: CHAR); (* choice: user choice E(dit)/Q(uit) *)
 CONST FREEMARKER = 3AE3H;
 VAR
-    local2: ADDRESS;
-    local3: CARDINAL;
-    local4: CARDINAL;
-    local5: CARDINAL;
-    local6: CARDINAL;
-    local7: CARDINAL;
-    local8: CARDINAL;
-    local9: CARDINAL;
-    local10: ARRAY [0..12] OF CHAR;
-    local11: FILE;
+    savedStack: ADDRESS;
+    moveSize: CARDINAL;
+    gapSize: CARDINAL;
+    editBufSize: CARDINAL;
+    freeRoom: CARDINAL;
+    stackRoom: CARDINAL;
+    spillSize: CARDINAL;
+    keepSize: CARDINAL;
+    backupName: ARRAY [0..12] OF CHAR;
+    backupFile: FILE;
     size: LONGINT;
-    local14: ModDescPtr;
+    savedModList: ModDescPtr;
     mainModule[030CH]: ModDescPtr;
     heap[0316H]: ADDRESS;
 BEGIN
-  IF param1 = 'E' THEN (* Edit *)
+  IF choice = 'E' THEN (* Edit *)
     size := Files.FileSize(Scanner.sourceFile);
     IF size > LONG(38500) THEN size := LONG(38500) END;
-    local5 := CARD(size) DIV 4 * 5 + 1500;
-    IF local5 < 5500 THEN local5 := 5500 END;
-    local7 := ADR(local10) - CARDINAL(Scanner.codeFile);
-    IF local5 > local7 THEN local5 := local7 END;
+    editBufSize := CARD(size) DIV 4 * 5 + 1500;
+    IF editBufSize < 5500 THEN editBufSize := 5500 END;
+    stackRoom := ADR(backupName) - CARDINAL(Scanner.codeFile);
+    IF editBufSize > stackRoom THEN editBufSize := stackRoom END;
     Files.Close(Scanner.sourceFile);
-    local14 := mainModule;
-    mainModule := local14^.link^.link^.link;
-    Scanner.GetStackMark(local2);
-    local9 := local2 - (Scanner.codeBuffer + 4096);
-    local3 := local2 - (CodeGen.windowLimit - CodeGen.nextEmitPos);
-    MOVE(local2-local9, local3-local9, local9);
-    Scanner.CheckStackMark(local3);
-    local6 := ADR(local10) - local3;
-    IF local5 > local6 THEN
-      local8 := local5 - local6;
-      local10 := "@:CBACKUP.$$$";
-      local10[0] := ComLine.inName[0];
-      Files.Create(local11, local10);
-      Files.WriteBytes(local11, local3-local8, local8);
-      Files.SetPos(local11, LONG(0));
-      Scanner.CheckStackMark(local3 - local8);
+    savedModList := mainModule;
+    mainModule := savedModList^.link^.link^.link;
+    Scanner.GetStackMark(savedStack);
+    keepSize := savedStack - (Scanner.codeBuffer + 4096);
+    moveSize := savedStack - (CodeGen.windowLimit - CodeGen.nextEmitPos);
+    MOVE(savedStack-keepSize, moveSize-keepSize, keepSize);
+    Scanner.CheckStackMark(moveSize);
+    freeRoom := ADR(backupName) - moveSize;
+    IF editBufSize > freeRoom THEN
+      spillSize := editBufSize - freeRoom;
+      backupName := "@:CBACKUP.$$$";
+      backupName[0] := ComLine.inName[0];
+      Files.Create(backupFile, backupName);
+      Files.WriteBytes(backupFile, moveSize-spillSize, spillSize);
+      Files.SetPos(backupFile, LONG(0));
+      Scanner.CheckStackMark(moveSize - spillSize);
     END; (* 018a *)
     Editor.editPosition := Scanner.tokenPos;
     Editor.Edit;
     savedEditPos := Editor.editPosition;
-    IF local5 > local6 THEN
-      Scanner.CheckStackMark(local3);
-      IF Files.ReadBytes(local11, local3-local8, local8)<>local8 THEN
+    IF editBufSize > freeRoom THEN
+      Scanner.CheckStackMark(moveSize);
+      IF Files.ReadBytes(backupFile, moveSize-spillSize, spillSize)<>spillSize THEN
         Editor.editOkFlag := FALSE
       END;
-      Files.Delete(local11);
+      Files.Delete(backupFile);
     END; (* 01B2 *)
-    MOVE(local3-local9, local2-local9, local9);
-    heap := local2 + 60;
-    local2^ := FREEMARKER;
-    mainModule := local14;
+    MOVE(moveSize-keepSize, savedStack-keepSize, keepSize);
+    heap := savedStack + 60;
+    savedStack^ := FREEMARKER;
+    mainModule := savedModList;
     IF Editor.editOkFlag THEN
       IF doSymtabRollback THEN SymTab.RestoreAfterEdit END;
       RAISE usererror
@@ -148,47 +148,47 @@ BEGIN
   FatalError("");
 
 EXCEPTION Files.DiskFull:
-    heap := local2 + 60;
-    local2^ := FREEMARKER;
-    Files.Delete(local11);
+    heap := savedStack + 60;
+    savedStack^ := FREEMARKER;
+    Files.Delete(backupFile);
     FatalError("ERROR: DISK FULL")
 END DoError;
 
 (* $[+ retain procedure names *)
 
-PROCEDURE TruncateScopeStack(param1: ADDRESS);
-VAR local2: SymTab.T1;
-    local3: CARDINAL;
-    local4: CARDINAL;
+PROCEDURE TruncateScopeStack(cutAddr: ADDRESS);
+VAR entry: SymTab.T1;
+    slot: CARDINAL;
+    topSlot: CARDINAL;
 BEGIN
-  local3 := 0;
-  local4 := 16;
-  WHILE local3 <= local4 DO
-    local2 := SymTab.rollbackStack^[local3];
-    WHILE (local2 <> NIL) AND (param1 <= ADDRESS(local2)) DO
-      local2 := local2^.link0
+  slot := 0;
+  topSlot := 16;
+  WHILE slot <= topSlot DO
+    entry := SymTab.rollbackStack^[slot];
+    WHILE (entry <> NIL) AND (cutAddr <= ADDRESS(entry)) DO
+      entry := entry^.link0
     END;
-    SymTab.rollbackStack^[local3] := local2;
-    INC(local3);
+    SymTab.rollbackStack^[slot] := entry;
+    INC(slot);
   END;
 END TruncateScopeStack;
 
 PROCEDURE RollbackToMark;
-VAR local2: SymTab.T1;
-    local3: ADDRESS;
+VAR sym: SymTab.T1;
+    mark: ADDRESS;
 BEGIN
-  Scanner.GetStackMark(local3);
-  local2 := SymTab.currentScope^.link1;
-  WHILE local2 <> NIL DO
-    IF (local2^.word4 = 3) AND (local2^.link2^.word4 = 6)
-    AND (local2^.link2^.link2 <> NIL)
-    AND (local3 <= ADDRESS(local2^.link2^.link2))
+  Scanner.GetStackMark(mark);
+  sym := SymTab.currentScope^.link1;
+  WHILE sym <> NIL DO
+    IF (sym^.word4 = 3) AND (sym^.link2^.word4 = 6)
+    AND (sym^.link2^.link2 <> NIL)
+    AND (mark <= ADDRESS(sym^.link2^.link2))
     THEN
-      local2^.link2^.link2 := NIL;
+      sym^.link2^.link2 := NIL;
     END;
-    local2 := local2^.link0;
+    sym := sym^.link0;
   END;
-  TruncateScopeStack(local3);
+  TruncateScopeStack(mark);
   Scanner.OpenSourceFile;
 END RollbackToMark;
 
@@ -197,12 +197,12 @@ CONST EVALUATED = " evaluated";
 CONST DIFFERENT = "Different ";
 CONST EDITQUIT  = "E(dit, Q(uit ";
 
-PROCEDURE NextSetBit(VAR param2: INTEGER;  param1: BITSET): BOOLEAN;
+PROCEDURE NextSetBit(VAR bit: INTEGER;  set: BITSET): BOOLEAN;
 BEGIN
   REPEAT
-    INC(param2);
-    IF CARDINAL(param2) IN param1 THEN RETURN TRUE END;
-  UNTIL param2 >= 16;
+    INC(bit);
+    IF CARDINAL(bit) IN set THEN RETURN TRUE END;
+  UNTIL bit >= 16;
   RETURN FALSE
 END NextSetBit;
 
@@ -229,9 +229,9 @@ BEGIN
   END;
 END WriteSlashField;
 
-PROCEDURE WriteKindName(param1: CARDINAL);
+PROCEDURE WriteKindName(kind: CARDINAL);
 BEGIN
-  WriteSlashField(param1, "Undefined/Constant/Exception/Type/Variable/Procedure/Module/")
+  WriteSlashField(kind, "Undefined/Constant/Exception/Type/Variable/Procedure/Module/")
 END WriteKindName;
 
 PROCEDURE WriteTypeName(n: CARDINAL);
@@ -248,26 +248,26 @@ BEGIN
   END;
 END WriteTypeOfSymbol;
 
-PROCEDURE WriteSymbolToken(param1: CHAR);
+PROCEDURE WriteSymbolToken(mode: CHAR);
 VAR ch: CHAR;
-VAR local3: CARDINAL;
-VAR local4: Scanner.Identifier;
+VAR idx: CARDINAL;
+VAR idBuf: Scanner.Identifier;
 BEGIN
-  local3 := Scanner.procPtr27(local4, param1);
-  IF local3 # 0 THEN WriteString(local4)
+  idx := Scanner.keywordHashFunc(idBuf, mode);
+  IF idx # 0 THEN WriteString(idBuf)
   ELSE
     Terminal.WriteChar('"');
-    local3 := 0;
-    WHILE (local3 <= 24) AND (opCharTable^[local3+2] # param1) DO INC(local3, 3) END;
-    IF (local3 <= 24) AND ((local3 DIV 3) IN compileOptions) THEN
-      Terminal.WriteChar(opCharTable^[local3]);
-      Terminal.WriteChar(opCharTable^[local3+1]);
+    idx := 0;
+    WHILE (idx <= 24) AND (opCharTable^[idx+2] # mode) DO INC(idx, 3) END;
+    IF (idx <= 24) AND ((idx DIV 3) IN compileOptions) THEN
+      Terminal.WriteChar(opCharTable^[idx]);
+      Terminal.WriteChar(opCharTable^[idx+1]);
     ELSE
-      IF ORD(param1) = 8 THEN
+      IF ORD(mode) = 8 THEN
         Terminal.WriteChar(listPipeChar);
       ELSE
         ch := '!';
-        WHILE (ch < DEL) AND (Scanner.charClassTable^[ORD(ch)] # param1) DO INC(ch) END;
+        WHILE (ch < DEL) AND (Scanner.charClassTable^[ORD(ch)] # mode) DO INC(ch) END;
         IF ch < DEL THEN Terminal.WriteChar(ch) END;
       END; (* 0433 *)
     END; (* 0433 *)
@@ -287,47 +287,47 @@ BEGIN
   WriteString(" found")
 END WriteFoundToken;
 
-PROCEDURE ShowErrorPosition(param1: CHAR);
-VAR local2: CARDINAL;
-VAR local3: CARDINAL;
-VAR local5: LONGINT;
-VAR local6: CHAR;
+PROCEDURE ShowErrorPosition(mode: CHAR);
+VAR col: CARDINAL;
+VAR lineStart: CARDINAL;
+VAR savedPos: LONGINT;
+VAR ch: CHAR;
 BEGIN
   IF NOT( 0 IN Scanner.scanOptions) THEN
     Terminal.WriteLn;
-    local5 := Files.NextPos(Scanner.sourceFile);
-    local3 := errorMarkPtr;
+    savedPos := Files.NextPos(Scanner.sourceFile);
+    lineStart := errorMarkPtr;
     REPEAT
-      DEC(local3);
-      Files.SetPos(Scanner.sourceFile, LONG(local3));
-      Files.ReadByte(Scanner.sourceFile, local6);
-    UNTIL (local3 = 0) OR (local6 = LF);
-    INC(local3, ORD(Scanner.curChar = LF));
-    Scanner.tokenColumn := Scanner.tokenPos - local3 - 6;
-    Files.SetPos(Scanner.sourceFile, LONG(local3));
-    WHILE local3 # errorMarkPtr DO
-      Files.ReadByte(Scanner.sourceFile, local6);
-      IF local6 # EOF THEN Terminal.WriteChar(local6) END;
-      INC(local3);
+      DEC(lineStart);
+      Files.SetPos(Scanner.sourceFile, LONG(lineStart));
+      Files.ReadByte(Scanner.sourceFile, ch);
+    UNTIL (lineStart = 0) OR (ch = LF);
+    INC(lineStart, ORD(Scanner.curChar = LF));
+    Scanner.tokenColumn := Scanner.tokenPos - lineStart - 6;
+    Files.SetPos(Scanner.sourceFile, LONG(lineStart));
+    WHILE lineStart # errorMarkPtr DO
+      Files.ReadByte(Scanner.sourceFile, ch);
+      IF ch # EOF THEN Terminal.WriteChar(ch) END;
+      INC(lineStart);
     END;
-    Files.SetPos(Scanner.sourceFile, local5);
+    Files.SetPos(Scanner.sourceFile, savedPos);
     INCL(Scanner.scanOptions, 0);
   END; (* 04f6 *)
-  IF param1 # 'X' THEN
+  IF mode # 'X' THEN
     WHILE (Scanner.curChar # CR) AND (Scanner.curChar # CHR(255)) DO
       Scanner.NextChar
     END;
   END; (*050D*)
   Terminal.WriteLn;
   IF Scanner.tokenColumn + 5 < Terminal.numCols THEN
-    local2 := 0;
-    WHILE local2 < Scanner.tokenColumn + 5 DO Terminal.WriteChar(' '); INC(local2) END;
+    col := 0;
+    WHILE col < Scanner.tokenColumn + 5 DO Terminal.WriteChar(' '); INC(col) END;
     WriteString("^   ");
   END; (* 0535 *)
-  IF param1 = 'X' THEN WriteString("Warning") 
+  IF mode = 'X' THEN WriteString("Warning") 
   ELSE
     WriteString("Error");
-    WriteSlashField(ORD(param1)-ORD('A'),
+    WriteSlashField(ORD(mode)-ORD('A'),
         " in Syntax/ in Identifier/ in Type/, Compiler Limit Exceeded//,illegal Constant/, Implementation Restriction/");
   END;
   Terminal.WriteChar(':'); Terminal.WriteLn;
@@ -347,22 +347,22 @@ BEGIN
  DoError(ch);
 END AskEditOrQuit; 
 
-PROCEDURE AskContinue(param1: ADDRESS);
+PROCEDURE AskContinue(info: ADDRESS);
 VAR ch: CHAR;
-VAR local3: POINTER TO RECORD w0: WORD; w1: BufPtr END;
-VAR local4: POINTER TO ARRAY [0..1] OF CHAR;
-VAR local5: BITSET;
+VAR infoDesc: POINTER TO RECORD w0: WORD; w1: BufPtr END;
+VAR msgBuf: POINTER TO ARRAY [0..1] OF CHAR;
+VAR savedOpts: BITSET;
 BEGIN
-  local5 := Scanner.scanOptions;
-  IF CARDINAL(param1) <= 1 THEN
-    PrintOverlayMessage(param1+50, local4^)
-  ELSIF CARDINAL(param1) = 2 THEN
+  savedOpts := Scanner.scanOptions;
+  IF CARDINAL(info) <= 1 THEN
+    PrintOverlayMessage(info+50, msgBuf^)
+  ELSIF CARDINAL(info) = 2 THEN
     PrintOverlayMessage(52, Scanner.tokenBuffer)
   ELSE
-    local3 := param1;
-    PrintOverlayMessage(52, local3^.w1^);
+    infoDesc := info;
+    PrintOverlayMessage(52, infoDesc^.w1^);
   END; (* 0628 *)
-  Scanner.scanOptions := local5;
+  Scanner.scanOptions := savedOpts;
   Terminal.WriteLn;
   REPEAT
     WriteString(EDITQUIT);
@@ -374,182 +374,182 @@ BEGIN
   IF ch # 'C' THEN DoError(ch) END;
 END AskContinue;
 
-PROCEDURE PrintOverlayMessage(param3: CARDINAL; VAR msg: ARRAY OF CHAR);
+PROCEDURE PrintOverlayMessage(code: CARDINAL; VAR msg: ARRAY OF CHAR);
 VAR errFile: Files.FILE;
-VAR local3: CARDINAL;
-VAR local4: CHAR;
-VAR local5: ARRAY [0..7] OF CHAR;
-VAR local6: ADDRESS;
+VAR skip: CARDINAL;
+VAR ch: CHAR;
+VAR ovrName: ARRAY [0..7] OF CHAR;
+VAR heapMark: ADDRESS;
 BEGIN
-  MARK(local6);
-  IF param3 < 100 THEN
-    errorNumber := param3;
-    local5  := "ERRMSGS "; (* NB: one extra char *)
-    FindFileOnDrives(errFile, local5, "OVR");
-    Files.SetPos(errFile, LONG(param3 DIV 20 * 650));
-    local3  := 0;
-    WHILE local3 < param3 MOD 20 DO
+  MARK(heapMark);
+  IF code < 100 THEN
+    errorNumber := code;
+    ovrName  := "ERRMSGS "; (* NB: one extra char *)
+    FindFileOnDrives(errFile, ovrName, "OVR");
+    Files.SetPos(errFile, LONG(code DIV 20 * 650));
+    skip  := 0;
+    WHILE skip < code MOD 20 DO
       REPEAT
-        Files.ReadByte(errFile, local4);
-      UNTIL local4 = LF;
-      INC(local3);
+        Files.ReadByte(errFile, ch);
+      UNTIL ch = LF;
+      INC(skip);
     END; (* 06b7 *)
-    Files.ReadByte(errFile, local4);
-    ShowErrorPosition(local4);
+    Files.ReadByte(errFile, ch);
+    ShowErrorPosition(ch);
     REPEAT
-      Files.ReadByte(errFile, local4);
-      IF local4 = '&' THEN WriteString(msg)
-      ELSE Terminal.WriteChar(local4)
+      Files.ReadByte(errFile, ch);
+      IF ch = '&' THEN WriteString(msg)
+      ELSE Terminal.WriteChar(ch)
       END; (* 06d1*)
-    UNTIL (local4 = CR) OR (local4 = EOF);
+    UNTIL (ch = CR) OR (ch = EOF);
   END; (* 06dc *)
-  RELEASE(local6);
+  RELEASE(heapMark);
 END PrintOverlayMessage;
 
-PROCEDURE ReportError(param1: CARDINAL);
+PROCEDURE ReportError(code: CARDINAL);
 VAR dummy: POINTER TO ARRAY [0..1] OF CHAR;
 BEGIN
-  ReportErrorWithText(param1, dummy^);
+  ReportErrorWithText(code, dummy^);
 END ReportError;
 
-PROCEDURE ReportErrorWithText(param3: CARDINAL; VAR msg: ARRAY OF CHAR);
+PROCEDURE ReportErrorWithText(code: CARDINAL; VAR msg: ARRAY OF CHAR);
 BEGIN
-  PrintOverlayMessage(param3,msg);
+  PrintOverlayMessage(code,msg);
   AskEditOrQuit;
 END ReportErrorWithText;
 
-PROCEDURE ReportExpectedSet(param2: BITSET; param1: INTEGER);
-VAR local2, local3: INTEGER;
-VAR local4: CARDINAL;
+PROCEDURE ReportExpectedSet(valid: BITSET; base: INTEGER);
+VAR firstBit, prevBit: INTEGER;
+VAR shown: CARDINAL;
 BEGIN
   ShowErrorPosition('A');
-  local2 := -1;
-  local4 := 0;
-  IF NextSetBit(local2, param2) THEN
-    WriteSymbolToken(CHR(local2 + param1));
-    INC(local4);
+  firstBit := -1;
+  shown := 0;
+  IF NextSetBit(firstBit, valid) THEN
+    WriteSymbolToken(CHR(firstBit + base));
+    INC(shown);
   END;
-  IF NextSetBit(local2, param2) THEN
-    local3 := local2;
-    INC(local4);
-    WHILE NextSetBit(local3, param2) DO
+  IF NextSetBit(firstBit, valid) THEN
+    prevBit := firstBit;
+    INC(shown);
+    WHILE NextSetBit(prevBit, valid) DO
       Terminal.WriteChar(',');
-      WriteSymbolToken(CHR(local2 + param1));
-      local2 := local3;
-      INC(local4);
+      WriteSymbolToken(CHR(firstBit + base));
+      firstBit := prevBit;
+      INC(shown);
     END; (* 0730 *)
     WriteString(" or ");
-    WriteSymbolToken(CHR(local2 + param1));
+    WriteSymbolToken(CHR(firstBit + base));
   END; (* 073d *)
   WriteString(" expected, ");
-  IF local4 > 5 THEN Terminal.WriteLn END;
+  IF shown > 5 THEN Terminal.WriteLn END;
   WriteString(BUT);
   WriteFoundToken;
   AskEditOrQuit;
 END ReportExpectedSet;
 
-PROCEDURE WriteRequiredNote(param1: ADDRESS);
-VAR local2: POINTER TO RECORD w0: WORD; w1: BufPtr END;
+PROCEDURE WriteRequiredNote(info: ADDRESS);
+VAR desc: POINTER TO RECORD w0: WORD; w1: BufPtr END;
 BEGIN
   WriteString(" required");
-  IF param1 > 255 THEN
-    local2 := param1;
-    IF local2^.w1 # NIL THEN
+  IF info > 255 THEN
+    desc := info;
+    IF desc^.w1 # NIL THEN
       WriteString(' for "');
-      WriteString(local2^.w1^);
+      WriteString(desc^.w1^);
       Terminal.WriteChar('"');
     END; (* 078A *)
     RETURN
   END; (* 078B *)
-  IF param1 # NIL THEN
+  IF info # NIL THEN
     WriteString(" for ");
-    WriteSymbolToken(CHR(param1));
+    WriteSymbolToken(CHR(info));
   END; (* 079b *)
 END WriteRequiredNote;
 
-PROCEDURE ReportTypeMismatch(param3: BITSET; param2: ADDRESS; param1: CARDINAL);
-VAR local2: INTEGER;
-VAR local3: SymTab.T1;
+PROCEDURE ReportTypeMismatch(want: BITSET; got: ADDRESS; ctx: CARDINAL);
+VAR bit: INTEGER;
+VAR actual: SymTab.T1;
 BEGIN
   ShowErrorPosition('C');
-  local3 := param2;
-  IF    param3 = {0,1}  THEN WriteString("Bounded Type")
-  ELSIF param3 = {4,8}  THEN WriteString("REAL or Set Type")
+  actual := got;
+  IF    want = {0,1}  THEN WriteString("Bounded Type")
+  ELSIF want = {4,8}  THEN WriteString("REAL or Set Type")
   ELSE
-    IF 2 IN param3 THEN
-      IF 0 IN param3    THEN WriteString("Scalar")
+    IF 2 IN want THEN
+      IF 0 IN want    THEN WriteString("Scalar")
                         ELSE WriteString("Numeric") END;
-      IF 5 IN param3    THEN WriteString(",Pointer") END;
-      IF 4 IN param3    THEN WriteString(" or Set") END;
+      IF 5 IN want    THEN WriteString(",Pointer") END;
+      IF 4 IN want    THEN WriteString(" or Set") END;
       WriteString(" Type");
-      IF NOT( {7,8} - param3 = {} ) THEN 
+      IF NOT( {7,8} - want = {} ) THEN 
         WriteString(",exluding");
-        IF NOT( 7 IN param3 ) THEN WriteString(" LONGINT and") END;
+        IF NOT( 7 IN want ) THEN WriteString(" LONGINT and") END;
         WriteString(" REAL,");
       END; (* 085b *)
     ELSE
-      local2 := -1;
-      IF NextSetBit(local2, param3) THEN WriteTypeName(local2) END; (* 086b *)
+      bit := -1;
+      IF NextSetBit(bit, want) THEN WriteTypeName(bit) END; (* 086b *)
     END; (* 086b *)
   END; (* 086B *)
-  WriteRequiredNote(param1);
+  WriteRequiredNote(ctx);
   Terminal.WriteChar(',');
   Terminal.WriteLn;
   WriteString(BUT);
-  IF (local3^.link0 # NIL) AND (6 IN local3^.link0^.word3) THEN
-    WriteTypeOfSymbol(local3)
+  IF (actual^.link0 # NIL) AND (6 IN actual^.link0^.word3) THEN
+    WriteTypeOfSymbol(actual)
   ELSE
-    WriteTypeName(local3^.word4)
+    WriteTypeName(actual^.word4)
   END;
   WriteString(EVALUATED);
   AskEditOrQuit;
 END ReportTypeMismatch;
 
-PROCEDURE ReportIncompatibleTypes(param4, param3: T1; param2: ARRAY OF CHAR);
-VAR local2, local3: T1;
+PROCEDURE ReportIncompatibleTypes(t1, t2: T1; op: ARRAY OF CHAR);
+VAR a, b: T1;
 BEGIN
   ShowErrorPosition('C');
-  local2 := DerefAliasType(param4);
-  local3 := DerefAliasType(param3);
-  IF  (local2^.link0 = NIL)
-  AND (local3^.link0 = NIL)
-  AND (local2^.word4 = local3^.word4) 
+  a := DerefAliasType(t1);
+  b := DerefAliasType(t2);
+  IF  (a^.link0 = NIL)
+  AND (b^.link0 = NIL)
+  AND (a^.word4 = b^.word4) 
   THEN
     WriteString(DIFFERENT);
-    WriteTypeName(local2^.word4);
+    WriteTypeName(a^.word4);
     WriteString(" types");
   ELSE
-    WriteTypeOfSymbol(local2);
+    WriteTypeOfSymbol(a);
     WriteString(" and ");
-    WriteTypeOfSymbol(local3);
+    WriteTypeOfSymbol(b);
   END; (* 08db *)
   WriteString(" are");
-  WriteString(param2);
+  WriteString(op);
   WriteString(" incompatible");
   AskEditOrQuit;
 END ReportIncompatibleTypes;
 
-PROCEDURE ReportAssignMismatch(param3, param2: T1; param1: ADDRESS);
-VAR local2, local3: T1;
+PROCEDURE ReportAssignMismatch(dst, src: T1; ctx: ADDRESS);
+VAR d, s: T1;
 BEGIN
   ShowErrorPosition('C');
-  local2 := param3;
-  local3 := param2;
-  IF local2^.link0 = NIL THEN local2 := DerefAliasType(local2) END;
-  IF local3^.link0 = NIL THEN local3 := DerefAliasType(local3) END;
-  IF (local2^.link0 # NIL) OR (local2^.word4 # local3^.word4) THEN
-    WriteTypeOfSymbol(local2);
-    WriteRequiredNote(param1);
+  d := dst;
+  s := src;
+  IF d^.link0 = NIL THEN d := DerefAliasType(d) END;
+  IF s^.link0 = NIL THEN s := DerefAliasType(s) END;
+  IF (d^.link0 # NIL) OR (d^.word4 # s^.word4) THEN
+    WriteTypeOfSymbol(d);
+    WriteRequiredNote(ctx);
     WriteString(", but ");
-    IF (local3^.link0 = NIL) AND (local2^.word4 = local3^.word4) THEN
+    IF (s^.link0 = NIL) AND (d^.word4 = s^.word4) THEN
       WriteString("other ")
     END;
-    WriteTypeOfSymbol(local3);
+    WriteTypeOfSymbol(s);
     WriteString(EVALUATED);
   ELSE
     WriteString(DIFFERENT);
-    WriteTypeName(local2^.word4);
-    WriteRequiredNote(param1);    
+    WriteTypeName(d^.word4);
+    WriteRequiredNote(ctx);    
   END; (*095c *)
   AskEditOrQuit;
 END ReportAssignMismatch;

src/compiler/README.md

@@ -14,11 +14,11 @@ No `0x1A`/`0x00` padding, LF line endings.
 | `CODEGEN.DEF/MOD` | renamed: `SetPendingOp/FlushPendingOp/QueueConst/EmitTypedOp/OpenFixup/CloseFixup/PeekCodeByte/...`, state `nextEmitPos/windowBase/codeWindow/fixupQueue/...` |
 | `SYMTAB.DEF` | renamed globals/procs; `SYMTAB.MOD` does not exist upstream yet (only `symtab.txt` disassembly) |
 
-Full old->new tables: `RENAME-MAP.md`.
+Full old->new tables: `RENAME-MAP.md` (module level; params/locals renamed
+per-procedure in the bodies — see the `VAR` blocks and headers inline).
 
 ## Deliberately NOT renamed (next steps)
 
-* `param1..param4` / `local2..localN` inside `.MOD` bodies (DEF signatures are renamed; bodies keep originals so diffs stay reviewable).
 * `Pass1/Statemen/Express` — no `.MOD` upstream, only `pass1.txt/statement.txt/express.txt`; see `docs/compiler/60-frontend.md` for the proc map.
 * `GENZ80` native backend — untouched until MCode output is stable.
 

src/compiler/SCANNER.MOD

@@ -23,39 +23,39 @@ CONST EXPECTED = " expected, but ";
 
 (* $[+ remove procedure names *)
 
-PROCEDURE ScannerError(param1: CARDINAL);
+PROCEDURE ScannerError(code: CARDINAL);
 BEGIN
-  Errors.ReportError(param1);
+  Errors.ReportError(code);
 END ScannerError;
 
-PROCEDURE ChangeFileExtension(VAR s: ARRAY OF CHAR; ext: Ext; b: BOOLEAN);
+PROCEDURE ChangeFileExtension(VAR fname: ARRAY OF CHAR; ext: Ext; force: BOOLEAN);
 VAR i: CARDINAL;
 BEGIN
   i := 0;
-  WHILE (i < HIGH(s) - 3) AND (s[i] <> 0C) AND (s[i] <> '.') DO
+  WHILE (i < HIGH(fname) - 3) AND (fname[i] <> 0C) AND (fname[i] <> '.') DO
     INC(i)
   END;
-  IF b OR (s[i] <> '.') THEN
-    s[i] := '.';
-    MOVE(ADR(ext), ADR(s[i+1]), 3);
+  IF force OR (fname[i] <> '.') THEN
+    fname[i] := '.';
+    MOVE(ADR(ext), ADR(fname[i+1]), 3);
   END;
 END ChangeFileExtension;
 
-PROCEDURE EnterModuleSymbol(param3: ARRAY OF CHAR; param1: CARDINAL): CARDINAL;
+PROCEDURE EnterModuleSymbol(modName: ARRAY OF CHAR; kind: CARDINAL): CARDINAL;
 VAR i: CARDINAL;
     ptr : POINTER TO SymTab.Symbol;
 BEGIN
   i := 0;
-  WHILE (i < SymTab.moduleCount) AND (SymTab.moduleTable^[i].name <> param3) DO
+  WHILE (i < SymTab.moduleCount) AND (SymTab.moduleTable^[i].name <> modName) DO
     INC(i)
   END; 
   ptr := ADR(SymTab.moduleTable^[i]);
   IF i < SymTab.moduleCount THEN
-    IF ptr^.word <> param1 THEN Errors.ReportErrorWithText(12, ptr^.name) END;
+    IF ptr^.word <> kind THEN Errors.ReportErrorWithText(12, ptr^.name) END;
   ELSE
     IF i > 15 THEN ScannerError(84) END;
-    ptr^.name := param3;
-    ptr^.word := param1;
+    ptr^.name := modName;
+    ptr^.word := kind;
     INC(SymTab.moduleCount);
   END;
   RETURN i
@@ -72,15 +72,15 @@ BEGIN
 
 END Allocate;
 
-PROCEDURE GetStackMark(VAR param1: ADDRESS);
+PROCEDURE GetStackMark(VAR mark: ADDRESS);
 BEGIN
-  param1 := stackLimit - 60;
+  mark := stackLimit - 60;
 END GetStackMark;
 
-PROCEDURE CheckStackMark(param1: ADDRESS);
+PROCEDURE CheckStackMark(mark: ADDRESS);
 BEGIN 
-  stackLimit := param1 + 60;
-  param1^ := FREEMARKER;
+  stackLimit := mark + 60;
+  mark^ := FREEMARKER;
 END CheckStackMark;
 
 (* proc 22: find identifier in keyword list *)
@@ -123,67 +123,67 @@ BEGIN
   RETURN 1;  (* never return a zero length *)
 END StrLen;
 
-PROCEDURE CopyStringToHeap(VAR a: ADDRESS; VAR s: ARRAY OF CHAR);
+PROCEDURE CopyStringToHeap(VAR dest: ADDRESS; VAR src: ARRAY OF CHAR);
 VAR length: CARDINAL;
 BEGIN
-  length := StrLen(s);
-  Allocate(a, length+1);
-  MOVE(ADR(s), a, length);
+  length := StrLen(src);
+  Allocate(dest, length+1);
+  MOVE(ADR(src), dest, length);
 END CopyStringToHeap;
 
-PROCEDURE NewNode(n:CARDINAL):ADDRESS;
+PROCEDURE NewNode(nodeKind:CARDINAL):ADDRESS;
 VAR ptr: Compiler.RecordPtr;
 BEGIN
   Allocate(ptr, 14);
-  ptr^.word4 := n;
+  ptr^.word4 := nodeKind;
   RETURN ptr
 END NewNode;
 
-PROCEDURE NewSizedNode(n:CARDINAL):ADDRESS;
+PROCEDURE NewSizedNode(nodeKind:CARDINAL):ADDRESS;
 VAR ptr: Compiler.RecordPtr;
 BEGIN
-  IF    n <=  1 THEN Allocate(ptr, 14)
-  ELSIF n <=  6 THEN Allocate(ptr, 10)
-  ELSIF n <= 11 THEN Allocate(ptr, 12)
+  IF    nodeKind <=  1 THEN Allocate(ptr, 14)
+  ELSIF nodeKind <=  6 THEN Allocate(ptr, 10)
+  ELSIF nodeKind <= 11 THEN Allocate(ptr, 12)
   ELSE               Allocate(ptr, 16)
   END;
-  ptr^.word4 := n;
+  ptr^.word4 := nodeKind;
   RETURN ptr
 END NewSizedNode;
 
-PROCEDURE MakeIdentifierNode(param1: CARDINAL): ADDRESS;
+PROCEDURE MakeIdentifierNode(nodeKind: CARDINAL): ADDRESS;
 VAR ptr : Compiler.RecordPtr;
 BEGIN
   NeedIdentifier;
   IF ADDRESS(scopeCursor) = SymTab.currentScope THEN Errors.ReportErrorWithText(1, tokenBuffer) END;
-  ptr := NewNode(param1);
+  ptr := NewNode(nodeKind);
   CopyStringToHeap(ptr^.word1, tokenBuffer);
   GetSym;
   RETURN ptr
 END MakeIdentifierNode;
 
-PROCEDURE InsertSymbol(param1: SymTab.T1);
+PROCEDURE InsertSymbol(node: SymTab.T1);
 BEGIN
-  IF FindIdent(ADR(SymTab.currentScope^.link1), param1^.link1, 9 IN scanOptions) # NIL THEN
-    Errors.ReportErrorWithText(1, param1^.link1^)
+  IF FindIdent(ADR(SymTab.currentScope^.link1), node^.link1, 9 IN scanOptions) # NIL THEN
+    Errors.ReportErrorWithText(1, node^.link1^)
   END;
-  param1^.link0 := SymTab.currentScope^.link1;
-  SymTab.currentScope^.link1 := param1;
+  node^.link0 := SymTab.currentScope^.link1;
+  SymTab.currentScope^.link1 := node;
 END InsertSymbol;
 
-PROCEDURE DeclareIdentifier(param1: CARDINAL): ADDRESS;
+PROCEDURE DeclareIdentifier(nodeKind: CARDINAL): ADDRESS;
 VAR ptr: SymTab.T1;
 BEGIN
-  ptr := MakeIdentifierNode(param1);
+  ptr := MakeIdentifierNode(nodeKind);
   ptr^.link0 := SymTab.currentScope^.link1;
   SymTab.currentScope^.link1 := ptr;
   RETURN ptr;
 END DeclareIdentifier;
 
-PROCEDURE OpenScope(a:ADDRESS; next: ADDRESS);
+PROCEDURE OpenScope(scopeChain:ADDRESS; next: ADDRESS);
 BEGIN
   Allocate(SymTab.currentScope, 14);
-  SymTab.currentScope^.w0 := a;
+  SymTab.currentScope^.w0 := scopeChain;
   SymTab.currentScope^.link1 := next;
 END OpenScope;
 
@@ -272,32 +272,32 @@ PROCEDURE GetSym;
 
   (* proc 35 *)
   PROCEDURE ParseNumber;
-  VAR local2: CARDINAL;
-  VAR local3: CARDINAL;
-  VAR local4: CARDINAL;
-  VAR local5: CARDINAL;
-  VAR local6: CARDINAL;
-  VAR local7: INTEGER;
-  VAR local8: BOOLEAN;
-  VAR local9 : BOOLEAN;
-  VAR local10: BOOLEAN;
-  VAR local12: LONGINT;
-  VAR local14: LONGINT;
-  VAR local16: LONGINT;
-  VAR local18: LONGINT;
+  VAR intPart: CARDINAL;
+  VAR expVal: CARDINAL;
+  VAR curDigit: CARDINAL;
+  VAR prevDigit: CARDINAL;
+  VAR limit: CARDINAL;
+  VAR expAdjust: INTEGER;
+  VAR negExp: BOOLEAN;
+  VAR isDecimal : BOOLEAN;
+  VAR isOctal: BOOLEAN;
+  VAR decVal: LONGINT;
+  VAR decFull: LONGINT;
+  VAR octVal: LONGINT;
+  VAR hexVal: LONGINT;
   
   (* $[+ remove procedure names *)
   
     (* proc 36 *)
     PROCEDURE Power10(exp: CARDINAL): REAL;
-    VAR n: CARDINAL;
+    VAR i: CARDINAL;
     VAR r: REAL;
     BEGIN
-      n := 0;
+      i := 0;
       r := 1.0;
       REPEAT
         IF ODD(exp) THEN
-          CASE n OF
+          CASE i OF
           | 0 : r := r * 1.0E01
           | 1 : r := r * 1.0E02
           | 2 : r := r * 1.0E04
@@ -308,7 +308,7 @@ PROCEDURE GetSym;
           END;
         END;
         exp := exp DIV 2;
-        INC(n);
+        INC(i);
       UNTIL exp = 0;
       RETURN r
     END Power10;
@@ -322,74 +322,74 @@ PROCEDURE GetSym;
       IF digit > 9 THEN
         IF digit >= 17 THEN digit := digit - 7 ELSE digit := 16 END;
       END; (* 043C *)
-      local4 := digit
+      curDigit := digit
     END AccumulateDigit;
   
   (* $[- keep procedure names *)
   BEGIN (* ParseNumber *)
-    local2  := 0;
-    local12 := LONG(0);
-    local7  := 0;
-    local18 := local12;
-    local16 := local12;
-    local14 := local12;
+    intPart  := 0;
+    decVal := LONG(0);
+    expAdjust  := 0;
+    hexVal := decVal;
+    octVal := decVal;
+    decFull := decVal;
     tokenLength:= 0;
-    local4  := ORD(curChar) - ORD('0');
-    local5  := local4;
-    local10 := TRUE;
-    local9  := TRUE;
+    curDigit  := ORD(curChar) - ORD('0');
+    prevDigit  := curDigit;
+    isOctal := TRUE;
+    isDecimal  := TRUE;
     REPEAT
-      IF local5 > 7 THEN
-        local10 := FALSE;
-        IF local5 > 9 THEN local9 := FALSE END;
+      IF prevDigit > 7 THEN
+        isOctal := FALSE;
+        IF prevDigit > 9 THEN isDecimal := FALSE END;
       END;
-      IF local4 <= 9 THEN
-        local14 := local14 * LONG(10) + LONG(local4);
-        IF local14 < 3355443L THEN local12 := local14 ELSE INC(local7) END;
-        IF local4 <= 7 THEN local16 := local16 * LONG(8) + LONG(local4) END;
+      IF curDigit <= 9 THEN
+        decFull := decFull * LONG(10) + LONG(curDigit);
+        IF decFull < 3355443L THEN decVal := decFull ELSE INC(expAdjust) END;
+        IF curDigit <= 7 THEN octVal := octVal * LONG(8) + LONG(curDigit) END;
       END; (* 04b1 *)
-      IF local18 <= LONG(65535) THEN local18 := local18 * LONG(16) + LONG(local4) END;
-      local5 := local4;
+      IF hexVal <= LONG(65535) THEN hexVal := hexVal * LONG(16) + LONG(curDigit) END;
+      prevDigit := curDigit;
       AccumulateDigit;
-    UNTIL local4 > 15;
+    UNTIL curDigit > 15;
     literalType := Compiler.CardType;
     IF curChar = '.' THEN
       AccumulateDigit;
       IF    curChar = '.' THEN curChar := DEL; DEC(tokenLength)
       ELSIF curChar = ')' THEN curChar := ']'; DEC(tokenLength)
       ELSE
-        IF NOT local9 THEN ScannerError(30) END;
+        IF NOT isDecimal THEN ScannerError(30) END;
         literalType := Compiler.RealType;
-        WHILE local4 <= 9 DO
-          IF local12 < 3355443L THEN
-            local12 := local12 * LONG(10) + LONG(local4);
-            DEC(local7)
+        WHILE curDigit <= 9 DO
+          IF decVal < 3355443L THEN
+            decVal := decVal * LONG(10) + LONG(curDigit);
+            DEC(expAdjust)
           END; (* 0527 *)
           AccumulateDigit;
         END; (* 052B *)
-        IF local4 IN {13, 14} THEN
-          IF local4 = 13 THEN literalType := Compiler.LongrealType END;
-          local3 := 0;
+        IF curDigit IN {13, 14} THEN
+          IF curDigit = 13 THEN literalType := Compiler.LongrealType END;
+          expVal := 0;
           AccumulateDigit;
-          local8 := (curChar = '-');
-          IF local8 OR (curChar = '+') THEN AccumulateDigit END;
-          IF local4 > 9 THEN ScannerError(30) END;
+          negExp := (curChar = '-');
+          IF negExp OR (curChar = '+') THEN AccumulateDigit END;
+          IF curDigit > 9 THEN ScannerError(30) END;
           REPEAT
-            IF local3 < 255 THEN local3 := local3 * 10 + local4 END;
+            IF expVal < 255 THEN expVal := expVal * 10 + curDigit END;
             AccumulateDigit;
-          UNTIL local4 > 9;
-          IF local8
-          THEN DEC(local7, local3)
-          ELSE INC(local7, local3)
+          UNTIL curDigit > 9;
+          IF negExp
+          THEN DEC(expAdjust, expVal)
+          ELSE INC(expAdjust, expVal)
           END;
         END; (* 0577 *)
         IF literalType = Compiler.RealType THEN
-          IF local12 >= 16777216L
-          THEN realValue := FLOAT((local12 + LONG(1)) DIV LONG(2)) * 2.0
-          ELSE realValue := FLOAT(local12)
+          IF decVal >= 16777216L
+          THEN realValue := FLOAT((decVal + LONG(1)) DIV LONG(2)) * 2.0
+          ELSE realValue := FLOAT(decVal)
           END;
-          IF    local7 < 0 THEN realValue := realValue / Power10(-local7)
-          ELSIF local7 # 0 THEN realValue := realValue * Power10(local7)
+          IF    expAdjust < 0 THEN realValue := realValue / Power10(-expAdjust)
+          ELSIF expAdjust # 0 THEN realValue := realValue * Power10(expAdjust)
           END;
         ELSE
           tokenBuffer[tokenLength] := 0C;
@@ -400,36 +400,36 @@ PROCEDURE GetSym;
     IF literalType^.word4 # 8 THEN
       IF curChar = 'L' THEN
         AccumulateDigit;
-        realValue := REAL(local14);
+        realValue := REAL(decFull);
         literalType := Compiler.LongintType;
       ELSE
-        local6 := 65535;
-        IF curChar = 'H' THEN AccumulateDigit; local12 := local18
+        limit := 65535;
+        IF curChar = 'H' THEN AccumulateDigit; decVal := hexVal
         ELSE
-          IF local5 IN {11, 12} THEN
-            IF NOT local10 THEN ScannerError(30) END;
-            local12 := local16;
-            IF local5 = 12 THEN literalType := Compiler.CharType; local6 := 255 END;
+          IF prevDigit IN {11, 12} THEN
+            IF NOT isOctal THEN ScannerError(30) END;
+            decVal := octVal;
+            IF prevDigit = 12 THEN literalType := Compiler.CharType; limit := 255 END;
           ELSE
-            IF NOT local9 OR (local5 > 9) THEN ScannerError(30) END;
-            local12 := local14;
+            IF NOT isDecimal OR (prevDigit > 9) THEN ScannerError(30) END;
+            decVal := decFull;
           END;
         END; (* 062e *)
-        IF local12 > LONG(local6) THEN ScannerError(73) END;
-        cardValue := CARD(local12);
+        IF decVal > LONG(limit) THEN ScannerError(73) END;
+        cardValue := CARD(decVal);
       END;
     END; (* 063f *)
     IF charClassTable^[ORD(curChar)] = 10 THEN ScannerError(30) END;
   EXCEPTION
   | OVERFLOW: ScannerError(73)
   | REALOVERFLOW: 
-      IF local7 >= 0 THEN ScannerError(74) END;
+      IF expAdjust >= 0 THEN ScannerError(74) END;
       realValue := REAL(0L);
   END ParseNumber;
   
 (* $[+ remove procedure names *)
   PROCEDURE SkipComment;
-  VAR local2: CARDINAL;
+  VAR optIdx: CARDINAL;
   BEGIN
     REPEAT
       REPEAT
@@ -441,13 +441,13 @@ PROCEDURE GetSym;
         END;
         IF curChar = '$' THEN
           NextChar;
-          local2 := CARDINAL(BITSET(curChar) * {0,1,2,3,4,6}) - ORD('L');
-          IF local2 <= 15 THEN
+          optIdx := CARDINAL(BITSET(curChar) * {0,1,2,3,4,6}) - ORD('L');
+          IF optIdx <= 15 THEN
             NextChar;
-            IF    curChar = '-' THEN EXCL(scanOptions, local2)
-            ELSIF curChar = '+' THEN INCL(scanOptions, local2)
+            IF    curChar = '-' THEN EXCL(scanOptions, optIdx)
+            ELSIF curChar = '+' THEN INCL(scanOptions, optIdx)
             END;
-            IF local2 = 0 THEN Texts.WriteLn(2) END;
+            IF optIdx = 0 THEN Texts.WriteLn(2) END;
           END;
         END; (* 06c6 *)
       UNTIL curChar = '*';
@@ -456,8 +456,8 @@ PROCEDURE GetSym;
   END SkipComment;
 
   PROCEDURE ScanNextToken():BOOLEAN; (* original was in Z80 code *)
-  VAR i: CARDINAL;
-  VAR local3: CARDINAL;
+  VAR j: CARDINAL;
+  VAR nextClass: CARDINAL;
   BEGIN
     isLiteral := FALSE;
     identKind := 7;
@@ -469,29 +469,29 @@ PROCEDURE GetSym;
     ELSE curSymbol := 0
     END;
     IF curSymbol = 10 THEN
-      i := 0;
+      j := 0;
       REPEAT
-        IF i # 128 THEN tokenBuffer[i] := curChar; INC(i) END;
+        IF j # 128 THEN tokenBuffer[j] := curChar; INC(j) END;
         NextChar;
-        local3 := charClassTable^[ORD(curChar)];
-      UNTIL (local3 # 10) AND (local3 # 11);
-      tokenBuffer[i] := 0C;
+        nextClass := charClassTable^[ORD(curChar)];
+      UNTIL (nextClass # 10) AND (nextClass # 11);
+      tokenBuffer[j] := 0C;
       RETURN TRUE
     END; (* 0730 *)
     RETURN FALSE;
     (* padding to compensate for smaller code *)
-    i := i+i+i+i+i+i+i+i+i+i+i+i+i+i+i+i+i+i+i+i+i+i+i+i+i+i+i+i
+    j := j+j+j+j+j+j+j+j+j+j+j+j+j+j+j+j+j+j+j+j+j+j+j+j+j+j+j+j
   END ScanNextToken;
 
-VAR local2: BOOLEAN;
-    local3: CARDINAL;
-    local4: BOOLEAN;
-    local5: CHAR;
+VAR tokenDone: BOOLEAN;
+    strLen: CARDINAL;
+    ignoreCase: BOOLEAN;
+    quote: CHAR;
 BEGIN
   REPEAT
     IF ScanNextToken() THEN
-      local4 := 9 IN scanOptions;
-      curSymbol := keywordHashFunc(ADR(tokenBuffer), local4);
+      ignoreCase := 9 IN scanOptions;
+      curSymbol := keywordHashFunc(ADR(tokenBuffer), ignoreCase);
       IF curSymbol # 0 THEN
         identKind := 7;
         IF ((curSymbol = 14) OR (curSymbol = 39)) AND NOT (12 IN scanOptions) THEN
@@ -501,7 +501,7 @@ BEGIN
       END; (* 0797 *)
       scopeCursor := ADDRESS(SymTab.currentScope);
       REPEAT
-        curNode  := FindIdent(ADR(scopeCursor^.link1), ADR(tokenBuffer), local4);
+        curNode  := FindIdent(ADR(scopeCursor^.link1), ADR(tokenBuffer), ignoreCase);
         IF curNode # NIL THEN
           literalType := ADDRESS(curNode^.word2);
           identKind  := curNode^.word4;
@@ -513,7 +513,7 @@ BEGIN
       identKind := 0;
       RETURN
     END; (* 07BA *)
-    local2 := TRUE;
+    tokenDone := TRUE;
     CASE curSymbol OF
     | 0 : ScannerError(31 - ORD(curChar = CHR(255)) * 2)
     | 2 : NextChar;
@@ -529,32 +529,32 @@ BEGIN
           curSymbol := 0;
           ParseNumber;
           tokenBuffer[tokenLength] := 0C
-    |12 : local3  := 0;
+    |12 : strLen  := 0;
           isLiteral := TRUE;
           identKind := 1;
           curSymbol := 0;
-          local5  := curChar;
+          quote  := curChar;
           NextChar;
-          WHILE curChar # local5 DO
+          WHILE curChar # quote DO
             IF curChar = LINEFEED THEN ScannerError(28) END;
             IF curChar = CHR(255) THEN ScannerError(29) END;
-            IF local3 < 128 THEN
-              tokenBuffer[local3] := curChar;
-              INC(local3);
+            IF strLen < 128 THEN
+              tokenBuffer[strLen] := curChar;
+              INC(strLen);
             END;
             NextChar;
           END; (* 0839 *)
-          tokenBuffer[local3] := 0C;
+          tokenBuffer[strLen] := 0C;
           NextChar;
           literalType := Compiler.charArrayDesc;
-          IF local3 = 1 THEN
+          IF strLen = 1 THEN
             literalType := Compiler.CharType;
             cardValue  := ORD(tokenBuffer[0]);
           END;
     ELSE
           NextChar;
           CASE curSymbol OF
-          | 43:  IF curChar = '*' THEN SkipComment; NextChar; local2 := FALSE
+          | 43:  IF curChar = '*' THEN SkipComment; NextChar; tokenDone := FALSE
               ELSIF curChar = '.' THEN curSymbol := 44; NextChar
               ELSIF curChar = ':' THEN curSymbol := 45; NextChar
               END;
@@ -564,12 +564,12 @@ BEGIN
           | 55:  IF curChar = '=' THEN curSymbol := 57; NextChar END;
           END;
     END;
-  UNTIL local2;
+  UNTIL tokenDone;
 END GetSym;
 
-PROCEDURE AcceptSymbol(param1: CARDINAL): BOOLEAN;
+PROCEDURE AcceptSymbol(sym: CARDINAL): BOOLEAN;
 BEGIN
-  IF curSymbol = param1 THEN GetSym; RETURN TRUE END;
+  IF curSymbol = sym THEN GetSym; RETURN TRUE END;
   RETURN FALSE
 END AcceptSymbol;
 
@@ -587,35 +587,35 @@ BEGIN
   END;
 END PushWithScope;
 
-PROCEDURE ExpectSymbol(param1:CARDINAL);
-VAR local2: BITSET;
-VAR local3: CARDINAL;
-BEGIN
-  IF curSymbol = param1 THEN GetSym; RETURN END;
-  local3 := 0;
-  local2 := {};
-  IF    param1 >= 51 THEN local3 := 51
-  ELSIF param1 >= 40 THEN local3 := 40
-  ELSIF param1 >= 27 THEN local3 := 27
-  ELSIF param1 >= 13 THEN local3 := 13
+PROCEDURE ExpectSymbol(sym:CARDINAL);
+VAR expSet: BITSET;
+VAR base: CARDINAL;
+BEGIN
+  IF curSymbol = sym THEN GetSym; RETURN END;
+  base := 0;
+  expSet := {};
+  IF    sym >= 51 THEN base := 51
+  ELSIF sym >= 40 THEN base := 40
+  ELSIF sym >= 27 THEN base := 27
+  ELSIF sym >= 13 THEN base := 13
   END;
-  local2 := local2 + {param1 - local3};
-  Errors.ReportExpectedSet(local2, local3)
+  expSet := expSet + {sym - base};
+  Errors.ReportExpectedSet(expSet, base)
 END ExpectSymbol;
 
-PROCEDURE TestSymbolInSet(param1: BITSET);
+PROCEDURE TestSymbolInSet(symSet: BITSET);
 BEGIN
-  IF NOT (curSymbol IN param1) THEN Errors.ReportExpectedSet(param1, 0) END;
+  IF NOT (curSymbol IN symSet) THEN Errors.ReportExpectedSet(symSet, 0) END;
 END TestSymbolInSet;
 
-PROCEDURE TestSymbolRange40(param1: BITSET);
+PROCEDURE TestSymbolRange40(symSet: BITSET);
 BEGIN
-  IF NOT ((curSymbol-40) IN param1) THEN Errors.ReportExpectedSet(param1, 40) END;
+  IF NOT ((curSymbol-40) IN symSet) THEN Errors.ReportExpectedSet(symSet, 40) END;
 END TestSymbolRange40;
 
-PROCEDURE TestSymbolRange13(param1: BITSET);
+PROCEDURE TestSymbolRange13(symSet: BITSET);
 BEGIN
-  IF NOT ((curSymbol-13) IN param1) THEN Errors.ReportExpectedSet(param1, 13) END;
+  IF NOT ((curSymbol-13) IN symSet) THEN Errors.ReportExpectedSet(symSet, 13) END;
 END TestSymbolRange13;
 
 PROCEDURE NeedIdentifier;
@@ -629,20 +629,20 @@ BEGIN
   END;
 END NeedIdentifier;
 
-PROCEDURE ExpectStringLiteral(VAR param2: ARRAY OF CHAR);
+PROCEDURE ExpectStringLiteral(VAR pattern: ARRAY OF CHAR);
 BEGIN
   NeedIdentifier;
-  IF StrCmp(ADR(tokenBuffer), ADR(param2), 9 IN scanOptions) THEN GetSym; RETURN END;
-  Errors.ReportErrorWithText(9, param2);
+  IF StrCmp(ADR(tokenBuffer), ADR(pattern), 9 IN scanOptions) THEN GetSym; RETURN END;
+  Errors.ReportErrorWithText(9, pattern);
 END ExpectStringLiteral;
 
-PROCEDURE ExpectIdentKind(param1: CARDINAL);
+PROCEDURE ExpectIdentKind(kind: CARDINAL);
 BEGIN
-  IF identKind # param1 THEN
+  IF identKind # kind THEN
     NeedIdentifier;
     IF identKind = 0 THEN Errors.ReportErrorWithText(0, tokenBuffer) END;
     Errors.ShowErrorPosition('B');
-    Errors.WriteKindName(param1);
+    Errors.WriteKindName(kind);
     Texts.WriteString(3, EXPECTED);
     Errors.WriteKindName(identKind);
     Texts.WriteString(3, " found");