reformatted OSP.mod for readability. Started building parser rules for statements...

diff --git a/cerise/oberon0/OSP.Mod b/cerise/oberon0/OSP.Mod
index 58be0a27c7c8aabd1c13dec03824b6944ae79474..44335499cd7667ee8d29e1efdca8a7e25c37b1c5 100644 (file)
--- a/cerise/oberon0/OSP.Mod
+++ b/cerise/oberon0/OSP.Mod
@@ -284,62 +284,123 @@ MODULE OSP; (* NW 23.9.93 / 9,5.2017   OSPX*)
   PROCEDURE StatSequence;\r
     VAR par, obj: OSG.Object; x, y: OSG.Item; n, L: LONGINT;\r
   BEGIN (* StatSequence *)\r
-    REPEAT (*sync*) obj := NIL;\r
+    REPEAT (*sync*)\r
+      obj := NIL;\r
       IF ~((sym = OSS.ident) OR (sym >= OSS.if) & (sym <= OSS.repeat) OR (sym >= OSS.semicolon)) THEN\r
         OSS.Mark("statement expected");\r
         REPEAT OSS.Get(sym) UNTIL (sym = OSS.ident) OR (sym >= OSS.if)\r
       END ;\r
+\r
       IF sym = OSS.ident THEN\r
-        find(obj); OSS.Get(sym);\r
-        IF obj.class = OSG.SProc THEN StandProc(obj.val)\r
-        ELSE OSG.MakeItem(x, obj, level); selector(x);\r
+        find(obj);\r
+        OSS.Get(sym);\r
+        IF obj.class = OSG.SProc THEN\r
+          StandProc(obj.val)\r
+        ELSE\r
+          OSG.MakeItem(x, obj, level);\r
+          selector(x);\r
           IF sym = OSS.becomes THEN (*assignment*)\r
-            OSS.Get(sym); expression(y);\r
-            IF (x.type.form IN {OSG.Boolean, OSG.Integer}) & (x.type.form = y.type.form) THEN OSG.Store(x, y)\r
-            ELSE OSS.Mark("incompatible assignment")\r
+            OSS.Get(sym);\r
+            expression(y);\r
+            IF (x.type.form IN {OSG.Boolean, OSG.Integer}) & (x.type.form = y.type.form) THEN\r
+              OSG.Store(x, y)\r
+            ELSE\r
+              OSS.Mark("incompatible assignment")\r
             END\r
-          ELSIF sym = OSS.eql THEN OSS.Mark("should be :="); OSS.Get(sym); expression(y)\r
+          ELSIF sym = OSS.eql THEN\r
+            OSS.Mark("should be :=");\r
+            OSS.Get(sym);\r
+            expression(y)\r
           ELSIF sym = OSS.lparen THEN (*procedure call*)\r
             OSS.Get(sym);\r
-            IF (obj.class = OSG.Proc) & (obj.type = NIL) THEN ParamList(obj); OSG.Call(obj);\r
-            ELSE OSS.Mark("not a procedure")\r
+            IF (obj.class = OSG.Proc) & (obj.type = NIL) THEN\r
+              ParamList(obj);\r
+              OSG.Call(obj);\r
+            ELSE\r
+              OSS.Mark("not a procedure")\r
             END\r
           ELSIF obj.class = OSG.Proc THEN (*procedure call without parameters*)\r
-            IF obj.nofpar > 0 THEN OSS.Mark("missing parameters") END ;\r
-            IF obj.type = NIL THEN OSG.Call(obj) ELSE OSS.Mark("not a procedure") END\r
-          ELSIF (obj.class = OSG.SProc) & (obj.val = 3) THEN OSG.WriteLn\r
-          ELSIF obj.class = OSG.Typ THEN OSS.Mark("illegal assignment")\r
-          ELSE OSS.Mark("not a procedure")\r
+            IF obj.nofpar > 0 THEN\r
+              OSS.Mark("missing parameters")\r
+            END ;\r
+            IF obj.type = NIL THEN\r
+              OSG.Call(obj) ELSE\r
+              OSS.Mark("not a procedure")\r
+            END\r
+          ELSIF (obj.class = OSG.SProc) & (obj.val = 3) THEN\r
+            OSG.WriteLn\r
+          ELSIF obj.class = OSG.Typ THEN\r
+            OSS.Mark("illegal assignment")\r
+          ELSE\r
+            OSS.Mark("not a procedure")\r
           END\r
         END\r
       ELSIF sym = OSS.if THEN\r
-        OSS.Get(sym); expression(x); CheckBool(x); OSG.CFJump(x); Check(OSS.then, "no THEN");\r
-        StatSequence; L := 0;\r
+        OSS.Get(sym);\r
+        expression(x);\r
+        CheckBool(x);\r
+        OSG.CFJump(x);\r
+        Check(OSS.then, "no THEN");\r
+        StatSequence;\r
+        L := 0;\r
         WHILE sym = OSS.elsif DO\r
-          OSS.Get(sym); OSG.FJump(L); OSG.FixLink(x.a); expression(x); CheckBool(x); OSG.CFJump(x);\r
-          IF sym = OSS.then THEN OSS.Get(sym) ELSE OSS.Mark("THEN?") END ;\r
+          OSS.Get(sym);\r
+          OSG.FJump(L);\r
+          OSG.FixLink(x.a);\r
+          expression(x);\r
+          CheckBool(x);\r
+          OSG.CFJump(x);\r
+          IF sym = OSS.then THEN\r
+            OSS.Get(sym)\r
+          ELSE\r
+            OSS.Mark("THEN?")\r
+          END ;\r
           StatSequence\r
         END ;\r
         IF sym = OSS.else THEN\r
-          OSS.Get(sym); OSG.FJump(L); OSG.FixLink(x.a); StatSequence\r
-        ELSE OSG.FixLink(x.a)\r
+          OSS.Get(sym);\r
+          OSG.FJump(L);\r
+          OSG.FixLink(x.a);\r
+          StatSequence\r
+        ELSE\r
+          OSG.FixLink(x.a)\r
         END ;\r
         OSG.FixLink(L);\r
-        IF sym = OSS.end THEN OSS.Get(sym) ELSE OSS.Mark("END?") END\r
+        IF sym = OSS.end THEN\r
+          OSS.Get(sym)\r
+        ELSE\r
+          OSS.Mark("END?")\r
+        END\r
       ELSIF sym = OSS.while THEN\r
-        OSS.Get(sym); L := OSG.pc; expression(x); CheckBool(x); OSG.CFJump(x);\r
-        Check(OSS.do, "no DO"); StatSequence; OSG.BJump(L); OSG.FixLink(x.a);\r
+        OSS.Get(sym);\r
+        L := OSG.pc;\r
+        expression(x);\r
+        CheckBool(x);\r
+        OSG.CFJump(x);\r
+        Check(OSS.do, "no DO");\r
+        StatSequence;\r
+        OSG.BJump(L);\r
+        OSG.FixLink(x.a);\r
         Check(OSS.end, "no END")\r
       ELSIF sym = OSS.repeat THEN\r
-        OSS.Get(sym); L := OSG.pc; StatSequence;\r
+        OSS.Get(sym);\r
+        L := OSG.pc;\r
+        StatSequence;\r
         IF sym = OSS.until THEN\r
-          OSS.Get(sym); expression(x); CheckBool(x); OSG.CBJump(x, L)\r
-        ELSE OSS.Mark("missing UNTIL"); OSS.Get(sym)\r
+          OSS.Get(sym);\r
+          expression(x);\r
+          CheckBool(x);\r
+          OSG.CBJump(x, L)\r
+        ELSE\r
+          OSS.Mark("missing UNTIL");\r
+          OSS.Get(sym)\r
         END\r
       END ;\r
       OSG.CheckRegs;\r
-      IF sym = OSS.semicolon THEN OSS.Get(sym)\r
-      ELSIF sym < OSS.semicolon THEN OSS.Mark("missing semicolon?")\r
+      IF sym = OSS.semicolon THEN\r
+        OSS.Get(sym)\r
+      ELSIF sym < OSS.semicolon THEN\r
+        OSS.Mark("missing semicolon?")\r
       END\r
     UNTIL sym > OSS.semicolon\r
   END StatSequence;\r
@@ -518,6 +579,7 @@ MODULE OSP; (* NW 23.9.93 / 9,5.2017   OSPX*)
       Check(OSS.semicolon, "; expected");\r
       Declarations(dc);\r
       WHILE sym = OSS.procedure DO ProcedureDecl; Check(OSS.semicolon, "; expected") END ;\r
+\r
       OSG.Header(dc);\r
       IF sym = OSS.begin THEN OSS.Get(sym); StatSequence END ;\r
       Check(OSS.end, "no END");\r

diff --git a/cerise/parser.c b/cerise/parser.c
index e166ccbe6dc70ec03cab3b700f1b1f57ad17c9db..d3ca8f949b0ea4e2666757001264655a2c92635a 100644 (file)
--- a/cerise/parser.c
+++ b/cerise/parser.c
@@ -471,7 +471,26 @@ RULE(const_decl)
 
 RULE(statement_seq)
 {
-    (void)p, (void)item;
+    (void)item;
+    if (matches(p, IDENT))
+    {
+        if (accept(p, '='))
+        {
+
+        }
+        else
+        {
+            error(p, "expected assignment");
+        }
+    }
+    else if (matches(p, IF))
+    {
+    }
+    else
+    {
+        error(p, "expected a statement");
+    }
+    expect(p, ';');
 }
 
 RULE(declaration_seq)
@@ -481,16 +500,20 @@ RULE(declaration_seq)
         const_decl(p, item);
         expect(p, ';');
     }
+
     if (accept(p, TYPE))
     {
         type_decl(p, item);
         expect(p, ';');
     }
+
     if (accept(p, VAR))
     {
         var_decl(p, item);
         expect(p, ';');
     }
+
+    /* WHILE sym = OSS.procedure DO ProcedureDecl; Check(OSS.semicolon, "; expected") END ; */
 }
 
 RULE(import_list)