m2comp step 1.1 — bare subrange type + syntax showcase (4/4 tests green)

docs/summary_m2comp_step1.1.md

@@ -0,0 +1,51 @@
+# m2comp step 1.1 — bare subrange type + syntax showcase (tag: `m2comp-step1.1`)
+
+Follow-up to step 1 (`m2comp-step1`): one grammar fix found while
+writing a full-syntax showcase, plus the showcase itself as a
+regression test.
+
+## Grammar fix
+
+- `Type` was missing the bare-subrange alternative `[lo .. hi]`
+  (only `IndexType` had it), so `TYPE Sub = [0 .. 9];` failed with
+  `invalid Type`. Added the alternative to `Type`, mirroring
+  `SimpleType` in `m2c`/`pimmod2.atg`. Still LL(1)-clean, rebuilt
+  via `build.sh` (`M2compP.mod` regenerated).
+
+## Showcase — `tests/showcase.mod` (accepted)
+
+Exercises every `M2comp.atg` production in one program module:
+
+- both `IMPORT` forms (`FROM In IMPORT x`, `IMPORT y, z`);
+- `CONST` with decimal, `0FFH` hex, reals (`3.14`, `2.0E+3`),
+  both string quotes, unary-minus expr (`-N + 2`);
+- all six `Type` alternatives: qualified+subrange (`INTEGER[1..N]`),
+  bare `[0..9]`, abbreviated 2-D `ARRAY`, `RECORD`/empty record,
+  `SET OF`, `POINTER TO`;
+- procedures with `VAR` params, function result, nesting;
+- local `MODULE` with `[Priority]`, `FROM..IMPORT`,
+  `EXPORT QUALIFIED`, own procedure + `BEGIN` init body;
+- all statement forms: assign, calls (with/without parens, bare),
+  `IF/ELSIF/ELSE`, `WHILE`, `REPEAT/UNTIL`, `LOOP/EXIT`, `FOR/BY`,
+  `RETURN` with and without expression;
+- all relations (`= # <> < <= > >= IN`), `OR/AND/NOT/DIV/MOD`,
+  `+x`, `-Factor` (`-k + 1`), `^` deref, multi-index `m[1,2]`,
+  dotted `Local.q`, nested `(* *)` comments.
+
+## Tests — 4/4 (`run_tests.sh`)
+
+| test | result |
+| ---- | ------ |
+| ok_minimal | accepted |
+| ok_proc | accepted |
+| showcase | accepted |
+| bad_mismatch | rejected (`Incorrect source`) |
+
+## Notes
+
+- Two test-authoring slips (not grammar bugs): local `MODULE`
+  declarations need `;` not `.` (`END Local;`).
+- Still open from step 1: drop `<>` (§2.2)? `(*$ *)` pragma
+  section (§2.3/2.4)? Nested-`ARRAY OF ARRAY` long-form flag
+  (step-2 semantic check)?
+- Next: step 2 `SymTab` (200/201/202/210-224 checks) + MC64 backend.

run_tests.sh

@@ -18,6 +18,7 @@ expect_fail() {
 }
 expect_ok tests/ok_minimal.mod
 expect_ok tests/ok_proc.mod
+expect_ok tests/showcase.mod
 expect_fail tests/bad_mismatch.mod
 echo "--- $pass passed, $fail failed ---"
 [ "$fail" -eq 0 ]

src/M2comp.atg

@@ -132,6 +132,11 @@ PRODUCTIONS
   Type
     = QualIdent
       [ "[" Expr ".." Expr "]" ]
+    | "["
+      Expr
+      ".."
+      Expr
+      "]"
     | "ARRAY"                         (* abbreviated form only (3.1):
                                          comma index list; a nested
                                          ARRAY OF ARRAY long form is

src/M2comp.lst

@@ -21,7 +21,7 @@ Statistics:
   nr of non-terminals:    36 (limit   210)
   nr of pragmas:           0 (limit   436)
   nr of symbolnodes:     100 (limit   500)
-  nr of graphnodes:      311 (limit  1500)
+  nr of graphnodes:      317 (limit  1500)
   nr of conditionsets:     6 (limit   100)
   nr of charactersets:     9 (limit   250)
 

src/M2compP.mod

@@ -525,38 +525,45 @@ PROCEDURE ProcDecl;
 
 PROCEDURE Type;
   BEGIN
-    IF (sym = 1) THEN
-      QualIdent;
-      IF (sym = 18) THEN
+    CASE sym OF
+      1 :
+        QualIdent;
+        IF (sym = 18) THEN
+          Get;
+          Expr;
+          Expect(25);
+          Expr;
+          Expect(19);
+        END;
+    | 18 :
         Get;
         Expr;
         Expect(25);
         Expr;
         Expect(19);
-      END;
-    ELSIF (sym = 26) THEN
-      Get;
-      IF (sym = 1) OR (sym = 18) THEN
-        IndexType;
-        WHILE (sym = 10) DO
-          Get;
+    | 26 :
+        Get;
+        IF (sym = 1) OR (sym = 18) THEN
           IndexType;
+          WHILE (sym = 10) DO
+            Get;
+            IndexType;
+          END;
         END;
-      END;
-      Expect(27);
-      Type;
-    ELSIF (sym = 28) THEN
-      Get;
-      FieldSeq;
-      Expect(12);
-    ELSIF (sym = 29) THEN
-      Get;
-      Expect(27);
-      QualIdent;
-    ELSIF (sym = 30) THEN
-      Get;
-      Expect(31);
-      Type;
+        Expect(27);
+        Type;
+    | 28 :
+        Get;
+        FieldSeq;
+        Expect(12);
+    | 29 :
+        Get;
+        Expect(27);
+        QualIdent;
+    | 30 :
+        Get;
+        Expect(31);
+        Type;
     ELSE SynError(71);
     END;
   END Type;

tests/showcase.LST

@@ -0,0 +1,108 @@
+Listing:
+
+    1  MODULE Showcase;
+    2  (* Exercises every syntax form of M2comp.atg step 1. *)
+    3  FROM In IMPORT x;
+    4  IMPORT y, z;
+    5  
+    6  CONST
+    7    N = 10;
+    8    H = 0FFH;
+    9    R = 3.14;
+   10    E = 2.0E+3;
+   11    S = "hi";
+   12    Q = 'q';
+   13    Neg = -N + 2;
+   14  
+   15  TYPE
+   16    Sub = [0 .. 9];
+   17    RS = INTEGER[1 .. N];
+   18    Vec = ARRAY [0 .. 9] OF INTEGER;
+   19    Mat = ARRAY [0 .. 9], [0 .. 3] OF REAL;
+   20    Rec = RECORD a : INTEGER; b : Vec END;
+   21    Empty = RECORD END;
+   22    Ptr = POINTER TO Rec;
+   23    St = SET OF Sub;
+   24    Boo = BOOLEAN;
+   25  
+   26  VAR
+   27    i, j : INTEGER;
+   28    v : Vec;
+   29    m : Mat;
+   30    r : Rec;
+   31    p : Ptr;
+   32    s : St;
+   33    b : BOOLEAN;
+   34    ch : CHAR;
+   35  
+   36  PROCEDURE Min(a, b : INTEGER) : INTEGER;
+   37  BEGIN
+   38    IF a < b THEN RETURN a ELSE RETURN b END
+   39  END Min;
+   40  
+   41  PROCEDURE Work(VAR v : Vec; n : CARDINAL; flag : BOOLEAN);
+   42  VAR k : INTEGER;
+   43  
+   44    PROCEDURE Nested(t : INTEGER) : INTEGER;
+   45    BEGIN
+   46      RETURN t * 2
+   47    END Nested;
+   48  
+   49  BEGIN
+   50    k := +n - 1;
+   51    k := -k + 1;
+   52    v[0] := k;
+   53    v[N - 1] := Nested(k);
+   54    m[1, 2] := R;
+   55    r.a := k;
+   56    p^ := r;
+   57    s := s;
+   58    b := (k <= 0) OR (k >= N) OR NOT flag;
+   59    IF k = 0 THEN k := 1
+   60    ELSIF k # 1 THEN k := 2
+   61    ELSE k := 3
+   62    END;
+   63    WHILE k < N DO
+   64      k := k + 1
+   65    END;
+   66    REPEAT
+   67      k := k - 1
+   68    UNTIL k = 0;
+   69    LOOP
+   70      k := k + 1;
+   71      IF k > N THEN EXIT END
+   72    END;
+   73    FOR k := 1 TO N BY 2 DO
+   74      Work(v, k, flag)
+   75    END;
+   76    FOR k := N TO 1 DO
+   77      k := k DIV 2
+   78    END;
+   79    b := (k IN s) AND (H <> 0) AND (Q = Q);
+   80    j := k MOD 3;
+   81    r := r
+   82  END Work;
+   83  
+   84  MODULE Local [3];
+   85  FROM In IMPORT w;
+   86  EXPORT QUALIFIED q;
+   87  VAR q : INTEGER;
+   88  PROCEDURE Init;
+   89  BEGIN
+   90    q := 0
+   91  END Init;
+   92  BEGIN
+   93    q := 1
+   94  END Local;
+   95  
+   96  BEGIN
+   97    i := Min(3, 4) + (2 * 3 - 4 / 2);
+   98    Work(v, N, TRUE);
+   99    Local.q := i;
+  100    y(i, S, x);
+  101    z
+  102  END Showcase.
+
+    0 errors
+
+

tests/showcase.mod

@@ -0,0 +1,102 @@
+MODULE Showcase;
+(* Exercises every syntax form of M2comp.atg step 1. *)
+FROM In IMPORT x;
+IMPORT y, z;
+
+CONST
+  N = 10;
+  H = 0FFH;
+  R = 3.14;
+  E = 2.0E+3;
+  S = "hi";
+  Q = 'q';
+  Neg = -N + 2;
+
+TYPE
+  Sub = [0 .. 9];
+  RS = INTEGER[1 .. N];
+  Vec = ARRAY [0 .. 9] OF INTEGER;
+  Mat = ARRAY [0 .. 9], [0 .. 3] OF REAL;
+  Rec = RECORD a : INTEGER; b : Vec END;
+  Empty = RECORD END;
+  Ptr = POINTER TO Rec;
+  St = SET OF Sub;
+  Boo = BOOLEAN;
+
+VAR
+  i, j : INTEGER;
+  v : Vec;
+  m : Mat;
+  r : Rec;
+  p : Ptr;
+  s : St;
+  b : BOOLEAN;
+  ch : CHAR;
+
+PROCEDURE Min(a, b : INTEGER) : INTEGER;
+BEGIN
+  IF a < b THEN RETURN a ELSE RETURN b END
+END Min;
+
+PROCEDURE Work(VAR v : Vec; n : CARDINAL; flag : BOOLEAN);
+VAR k : INTEGER;
+
+  PROCEDURE Nested(t : INTEGER) : INTEGER;
+  BEGIN
+    RETURN t * 2
+  END Nested;
+
+BEGIN
+  k := +n - 1;
+  k := -k + 1;
+  v[0] := k;
+  v[N - 1] := Nested(k);
+  m[1, 2] := R;
+  r.a := k;
+  p^ := r;
+  s := s;
+  b := (k <= 0) OR (k >= N) OR NOT flag;
+  IF k = 0 THEN k := 1
+  ELSIF k # 1 THEN k := 2
+  ELSE k := 3
+  END;
+  WHILE k < N DO
+    k := k + 1
+  END;
+  REPEAT
+    k := k - 1
+  UNTIL k = 0;
+  LOOP
+    k := k + 1;
+    IF k > N THEN EXIT END
+  END;
+  FOR k := 1 TO N BY 2 DO
+    Work(v, k, flag)
+  END;
+  FOR k := N TO 1 DO
+    k := k DIV 2
+  END;
+  b := (k IN s) AND (H <> 0) AND (Q = Q);
+  j := k MOD 3;
+  r := r
+END Work;
+
+MODULE Local [3];
+FROM In IMPORT w;
+EXPORT QUALIFIED q;
+VAR q : INTEGER;
+PROCEDURE Init;
+BEGIN
+  q := 0
+END Init;
+BEGIN
+  q := 1
+END Local;
+
+BEGIN
+  i := Min(3, 4) + (2 * 3 - 4 / 2);
+  Work(v, N, TRUE);
+  Local.q := i;
+  y(i, S, x);
+  z
+END Showcase.