preparing to support different grammars

src/context.js

@@ -2,7 +2,7 @@
 
 var Cast = require("cast.js");
 var Code = require("code.js");
-var Errors = require("oberon.js/Errors.js");
+var Errors = require("js/Errors.js");
 var Module = require("module.js");
 var op = require("operator.js");
 var Parser = require("parser.js");

src/eberon/eberon_grammar.js

@@ -0,0 +1,4 @@
+var grammar = require("grammar.js");
+
+exports.grammar = grammar.make(grammar.makeProcedureDeclaration);
+

src/grammar.js

@@ -1,7 +1,7 @@
 "use strict";
 
 var Context = require("context.js");
-var Lexer = require("oberon.js/Lexer.js");
+var Lexer = require("js/Lexer.js");
 var Parser = require("parser.js");
 var Class = require("rtl.js").Class;
 
@@ -159,39 +159,51 @@ var typeDeclaration = context(and(identdef, "=", strucType), Context.TypeDeclara
 var procedureHeading = and("PROCEDURE"
                          , identdef
                          , context(optional(formalParameters), Context.FormalParametersProcDecl));
-var procedureDeclaration = context(
-      and(procedureHeading, ";"
-          // break recursive declaration of procedureBody
-        , function(stream, context){return procedureBody(stream, context);}
-        , ident)
-    , Context.ProcDecl);
+var grammar;
 
-var constantDeclaration = context(and(identdef, "=", constExpression), Context.ConstDecl);
+exports.makeProcedureDeclaration = function(procedureBody){
+    return context(and(procedureHeading, ";",
+                       procedureBody,
+                       ident),
+                   Context.ProcDecl);
+    };
 
-var declarationSequence = and(optional(and("CONST", repeat(and(constantDeclaration, required(";")))))
-                            , optional(and("TYPE", context(repeat(and(typeDeclaration, required(";"))), Context.TypeSection)))
-                            , optional(and("VAR", repeat(and(variableDeclaration, required(";")))))
-                            , repeat(and(procedureDeclaration, ";")));
-var procedureBody = and(declarationSequence
-                      , optional(and("BEGIN", statementSequence))
-                      , optional(context(and("RETURN", expression), Context.Return))
-                      , required("END", "END expected (PROCEDURE)"));
+var constantDeclaration = context(and(identdef, "=", constExpression), Context.ConstDecl);
 
 var imprt = and(ident, optional(and(":=", ident)));
 var importList = and("IMPORT", imprt, repeat(and(",", imprt)));
-var modul = context(and("MODULE", ident, ";",
-                        context(optional(and(importList, ";")), Context.ModuleImport),
-                        declarationSequence,
-                        optional(and("BEGIN", statementSequence)),
-                        required("END", "END expected (MODULE)"), ident, point),
-                     Context.ModuleDeclaration);
-
-exports.declarationSequence = declarationSequence;
+
+function make(makeProcedureDeclaration){
+    var result = {};
+    result.procedureDeclaration
+        // break recursive declaration of procedureBody
+        = makeProcedureDeclaration(
+            function(stream, context){
+                return result.procedureBody(stream, context);}
+        );
+    result.declarationSequence
+        = and(optional(and("CONST", repeat(and(constantDeclaration, required(";"))))),
+              optional(and("TYPE", context(repeat(and(typeDeclaration, required(";"))), Context.TypeSection))),
+              optional(and("VAR", repeat(and(variableDeclaration, required(";"))))),
+              repeat(and(result.procedureDeclaration, ";")));
+    result.procedureBody
+        = and(result.declarationSequence,
+              optional(and("BEGIN", statementSequence)),
+              optional(context(and("RETURN", expression), Context.Return)),
+              required("END", "END expected (PROCEDURE)"));
+    result.module
+        = context(and("MODULE", ident, ";",
+                      context(optional(and(importList, ";")), Context.ModuleImport),
+                      result.declarationSequence,
+                      optional(and("BEGIN", statementSequence)),
+                      required("END", "END expected (MODULE)"), ident, point),
+                  Context.ModuleDeclaration);
+    return result;
+    }
+
+exports.make = make;
 exports.expression = expression;
 exports.ident = ident;
-exports.module = modul;
-exports.procedureBody = procedureBody;
-exports.procedureDeclaration = procedureDeclaration;
 exports.procedureHeading = procedureHeading;
 exports.statement = statement;
 exports.typeDeclaration = typeDeclaration;

src/oberon.js/Errors.js → src/js/Errors.js

@@ -1,6 +1,6 @@
 var RTL$ = require("rtl.js");
 var JS = GLOBAL;
-var JsString = require("JsString.js");
+var JsString = require("js/JsString.js");
 var Error = RTL$.extend({
 	init: function Error(){
 	}

src/oberon.js/Lexer.js → src/js/Lexer.js

@@ -1,8 +1,8 @@
 var RTL$ = require("rtl.js");
 var JS = GLOBAL;
-var JsString = require("JsString.js");
-var Errors = require("Errors.js");
-var Stream = require("Stream.js");
+var JsString = require("js/JsString.js");
+var Errors = require("js/Errors.js");
+var Stream = require("js/Stream.js");
 var quote = "\"";
 var commentBegin = "(*";
 var commentEnd = "*)";

src/oberon.js/Stream.js → src/js/Stream.js

@@ -1,5 +1,5 @@
 var RTL$ = require("rtl.js");
-var JsString = require("JsString.js");
+var JsString = require("js/JsString.js");
 var Type = RTL$.extend({
 	init: function Type(){
 		this.s = null;

src/module.js

@@ -1,7 +1,7 @@
 "use strict";
 
 var Code = require("code.js");
-var Errors = require("oberon.js/Errors");
+var Errors = require("js/Errors.js");
 var Procedure = require("procedure.js");
 var Symbol = require("symbol.js");
 var Type = require("type.js");

src/nodejs.js

@@ -50,7 +50,7 @@ function writeCompiledModule(name, code, outDir){
     fs.writeFileSync(filePath, code);
     }
 
-function compile(sources, handleErrors, outDir){
+function compile(sources, grammar, handleErrors, outDir){
     var rtlCodeWatcher = new RtlCodeUsingWatcher();
     var rtl = new RTL(rtlCodeWatcher.using.bind(rtlCodeWatcher));
     var moduleCode = function(name, imports){return new ModuleGenerator(name, imports);};
@@ -65,6 +65,7 @@ function compile(sources, handleErrors, outDir){
                 compiledFilesStack.push(fileName);
                 return fs.readFileSync(fileName, "utf8");
             },
+            grammar,
             function(moduleResolver){return new Context.Context(
                 new Code.Generator(),
                 moduleCode,

src/oberon/JsString.ob → src/ob/JsString.ob

@@ -59,4 +59,11 @@ BEGIN
     RETURN result
 END appendChar;
 
+PROCEDURE concat*(self: Type; add: Type): Type;
+VAR result: Type;
+BEGIN
+    JS.do("result = self + add");
+    RETURN result
+END concat;
+
 END JsString.

src/ob/Types.ob

@@ -0,0 +1,17 @@
+MODULE Types;
+IMPORT JsString;
+
+TYPE
+    Id = RECORD END;
+    Type = POINTER TO RECORD(Id)
+        description: PROCEDURE(): JsString.Type
+    END;
+    TypeId = RECORD(Id)
+        type: Type
+    END;
+
+PROCEDURE description*(t: TypeId): JsString.Type;
+    RETURN JsString.concat(JsString.make("type "), t.type.description())
+END description;
+
+END Types.

src/oberon/oberon_grammar.js

@@ -0,0 +1,4 @@
+var grammar = require("grammar.js");
+
+exports.grammar = grammar.make(grammar.makeProcedureDeclaration);
+

src/oc.js

@@ -3,11 +3,10 @@
 var Class = require("rtl.js").Class;
 var Code = require("code.js");
 var Context = require("context.js");
-var Errors = require("oberon.js/Errors");
-var Grammar = require("grammar.js");
-var Lexer = require("oberon.js/lexer.js");
+var Errors = require("js/Errors.js");
+var Lexer = require("js/Lexer.js");
 var RTL = require("rtl_code.js").RTL;
-var Stream = require("oberon.js/Stream.js");
+var Stream = require("js/Stream.js");
 
 var CompiledModule = Class.extend({
     init: function CompiledModule(symbol, code, exports){
@@ -20,10 +19,10 @@ var CompiledModule = Class.extend({
     exports: function(){return this.__exports;}
 });
 
-function compileModule(stream, context, handleErrors){
+function compileModule(grammar, stream, context, handleErrors){
     Lexer.skipSpaces(stream, context);  
     try {
-        if (!Grammar.module(stream, context))
+        if (!grammar.module(stream, context))
             throw new Errors.Error("syntax error");
     }
     catch (x) {
@@ -45,6 +44,7 @@ function compileModule(stream, context, handleErrors){
 
 function compileModulesFromText(
         text,
+        grammar,
         contextFactory,
         resolveModule,
         handleCompiledModule,
@@ -52,7 +52,7 @@ function compileModulesFromText(
     var stream = Stream.make(text);
     do {
         var context = contextFactory(resolveModule);
-        var module = compileModule(stream, context, handleErrors);
+        var module = compileModule(grammar, stream, context, handleErrors);
         if (!module)
             return;
         handleCompiledModule(module);
@@ -84,10 +84,11 @@ var ModuleResolver = Class.extend({
     }
 });
 
-function makeResolver(contextFactory, handleCompiledModule, handleErrors, moduleReader){
+function makeResolver(grammar, contextFactory, handleCompiledModule, handleErrors, moduleReader){
     return new ModuleResolver(
         function(text, resolveModule, handleModule){
             compileModulesFromText(text,
+                                   grammar,
                                    contextFactory,
                                    resolveModule,
                                    handleModule,
@@ -98,16 +99,17 @@ function makeResolver(contextFactory, handleCompiledModule, handleErrors, module
         );
 }
 
-function compileModules(names, moduleReader, contextFactory, handleErrors, handleCompiledModule){
-    var resolver = makeResolver(contextFactory, handleCompiledModule, handleErrors, moduleReader);
+function compileModules(names, moduleReader, grammar, contextFactory, handleErrors, handleCompiledModule){
+    var resolver = makeResolver(grammar, contextFactory, handleCompiledModule, handleErrors, moduleReader);
     names.forEach(function(name){ resolver.compile(moduleReader(name)); });
 }
 
-function compile(text, handleErrors){
+function compile(text, grammar, handleErrors){
     var result = "";
     var rtl = new RTL();
     var moduleCode = function(name, imports){return new Code.ModuleGenerator(name, imports);};
     var resolver = makeResolver(
+            grammar,
             function(moduleResolver){
                 return new Context.Context(new Code.Generator(),
                                            moduleCode,

src/operator.js

@@ -2,7 +2,7 @@
 
 var Cast = require("cast.js");
 var Code = require("code.js");
-var Errors = require("oberon.js/Errors");
+var Errors = require("js/Errors.js");
 var Type = require("type.js");
 
 var precedence = {

src/parser.js

@@ -1,9 +1,9 @@
 "use strict";
 
 var assert = require("assert.js").ok;
-var Errors = require("oberon.js/Errors");
-var Lexer = require("oberon.js/lexer.js");
-var Stream = require("oberon.js/Stream.js");
+var Errors = require("js/Errors.js");
+var Lexer = require("js/Lexer.js");
+var Stream = require("js/Stream.js");
 
 function literal(s){
 	var l = Lexer.makeLiteral(s);

src/procedure.js

@@ -3,7 +3,7 @@
 var Cast = require("cast.js");
 var Class = require("rtl.js").Class;
 var Code = require("code.js");
-var Errors = require("oberon.js/Errors");
+var Errors = require("js/Errors.js");
 var op = require("operator.js");
 var precedence = require("operator.js").precedence;
 var Symbol = require("symbol.js");

src/scope.js

@@ -1,7 +1,7 @@
 "use strict";
 
 var Class = require("rtl.js").Class;
-var Errors = require("oberon.js/Errors");
+var Errors = require("js/Errors.js");
 var Procedure = require("procedure.js");
 var Symbol = require("symbol.js");
 var Type = require("type.js");

src/symbol.js

@@ -1,7 +1,7 @@
 "use strict";
 
 var Class = require("rtl.js").Class;
-var Errors = require("oberon.js/Errors");
+var Errors = require("js/Errors.js");
 var Type = require("type.js");
 
 var Symbol = Class.extend({

src/type.js

@@ -1,7 +1,7 @@
 "use strict";
 
 var Class = require("rtl.js").Class;
-var Errors = require("oberon.js/Errors");
+var Errors = require("js/Errors.js");
 
 var Id = Class.extend({
     init: function Id(){}

test/test_compile.js

@@ -2,6 +2,7 @@
 
 var nodejs = require("nodejs");
 var oc = require("oc");
+var oberonGrammar = require("oberon/oberon_grammar.js").grammar;
 var fs = require("fs");
 var path = require("path");
 var Test = require("test.js");
@@ -21,7 +22,7 @@ function compareResults(result, name, dirs){
 function compile(src){
     var text = fs.readFileSync(src, "utf8");
     var errors = "";
-    var result = oc.compile(text, function(e){errors += e;});
+    var result = oc.compile(text, oberonGrammar, function(e){errors += e;});
     if (errors)
         throw new Test.TestError(errors);
     return result;
@@ -35,7 +36,7 @@ function compileNodejs(src, dirs){
     fs.mkdirSync(outDir);
 
     var errors = "";
-    nodejs.compile([src], function(e){errors += e;}, outDir);
+    nodejs.compile([src], oberonGrammar, function(e){errors += e;}, outDir);
     if (errors)
         throw new Test.TestError(errors);
 
@@ -52,7 +53,7 @@ function expectError(src, dirs){
     var text = fs.readFileSync(src, "utf8");
     var errors = "";
     try {
-        oc.compile(text, function(e){errors += e + "\n";});
+        oc.compile(text, oberonGrammar, function(e){errors += e + "\n";});
     }
     catch (e){
         errors += e;

test/test_unit.cmd

@@ -1,2 +1,2 @@
-SET NODE_PATH=.;%~dp0../src;%~dp0../src/oberon.js
+SET NODE_PATH=.;%~dp0../src;%~dp0../src/oberon;%~dp0../src/js
 "C:\Program Files\nodejs\node.exe" test_unit.js %*

test/test_unit.js

@@ -4,8 +4,9 @@ var assert = require("assert.js").ok;
 var Class = require("rtl.js").Class;
 var Code = require("code.js");
 var Context = require("context.js");
-var Errors = require("oberon.js/Errors");
+var Errors = require("js/Errors.js");
 var Grammar = require("grammar.js");
+var oberonGrammar = require("oberon/oberon_grammar.js").grammar;
 var oc = require("oc.js");
 var RTL = require("rtl_code.js").RTL;
 var Scope = require("scope.js");
@@ -97,7 +98,7 @@ function setupWithContext(grammar, source){
     function innerMakeContext(){
         var context = makeContext();
         try {
-            parseInContext(Grammar.declarationSequence, source, context);
+            parseInContext(oberonGrammar.declarationSequence, source, context);
         }
         catch (x) {
             if (x instanceof Errors.Error)
@@ -158,10 +159,11 @@ var TestContextWithModule = TestContext.extend({
 function testWithModule(src, pass, fail){
     return testWithSetup(
         function(){
-            var imported = oc.compileModule(Stream.make(src), makeContext());
+            var imported = oc.compileModule(oberonGrammar, Stream.make(src), makeContext());
             var module = imported.symbol().info();
             return setup(function(s){
-                oc.compileModule(Stream.make(s),
+                oc.compileModule(oberonGrammar,
+                                 Stream.make(s),
                                  new TestContextWithModule(module));
             });},
         pass,
@@ -254,14 +256,14 @@ var testSuite = {
     fail(["i: T", "undeclared identifier: 'T'"])
     ),
 "procedure VAR section": testWithGrammar(
-    Grammar.declarationSequence,
+    oberonGrammar.declarationSequence,
     pass("VAR",
          "VAR i: INTEGER;",
          "VAR i, j: INTEGER;",
          "VAR i, j: INTEGER; b: BOOLEAN;")
     ),
 "const declaration": testWithContext(
-    context(Grammar.declarationSequence,
+    context(oberonGrammar.declarationSequence,
             "CONST ci = 1; VAR v1: INTEGER;"),
     pass("CONST i = 10;",
          "CONST i = 1 + 2;",
@@ -368,7 +370,7 @@ var testSuite = {
         )
     ),
 "POINTER forward declaration": testWithContext(
-    context(Grammar.module, ""),
+    context(oberonGrammar.module, ""),
     pass("MODULE m; TYPE T = POINTER TO NotDeclaredYet; NotDeclaredYet = RECORD END; END m.",
          "MODULE m; TYPE T1 = POINTER TO NotDeclaredYet; T2 = POINTER TO NotDeclaredYet; NotDeclaredYet = RECORD END; END m."
          ),
@@ -433,7 +435,7 @@ var testSuite = {
           "invalid type cast: a value variable and cannot be used in typeguard"])
     ),
 "typeguard for VAR argument": testWithContext(
-    context(Grammar.procedureDeclaration,
+    context(oberonGrammar.procedureDeclaration,
             "TYPE Base = RECORD END; Derived = RECORD (Base) i: INTEGER END;"
             + "T = RECORD END; TD = RECORD(T) b: Base END;"),
     pass("PROCEDURE proc(VAR p: Base); BEGIN p(Derived).i := 1; END proc"),
@@ -522,14 +524,14 @@ var testSuite = {
          ["NEW(proc())", "expression cannot be used as VAR parameter"])
     ),
 "NEW for read only array element fails": testWithContext(
-    context(Grammar.procedureDeclaration,
+    context(oberonGrammar.procedureDeclaration,
             "TYPE P = POINTER TO RECORD END;"),
     pass(),
     fail(["PROCEDURE readOnlyPointers(a: ARRAY OF P); BEGIN NEW(a[0]) END readOnlyPointers",
           "read-only variable cannot be used as VAR parameter"])
     ),
 "LEN": testWithGrammar(
-    Grammar.procedureDeclaration,
+    oberonGrammar.procedureDeclaration,
     pass("PROCEDURE p(a: ARRAY OF INTEGER): INTEGER; RETURN LEN(a) END p",
          "PROCEDURE p(VAR a: ARRAY OF BOOLEAN): INTEGER; RETURN LEN(a) END p",
          "PROCEDURE p(): INTEGER; RETURN LEN(\"abc\") END p"),
@@ -684,7 +686,7 @@ var testSuite = {
          ["i := noResult()", "procedure returning no result cannot be used in an expression"])
     ),
 "array expression": testWithGrammar(
-    Grammar.procedureBody,
+    oberonGrammar.procedureBody,
     pass("VAR a: ARRAY 10 OF INTEGER; BEGIN a[0] := 1 END",
          "VAR a: ARRAY 10 OF INTEGER; BEGIN a[0] := 1; a[1] := a[0] END",
          "VAR a1, a2: ARRAY 3 OF CHAR; BEGIN ASSERT(a1 = a2); END",
@@ -715,7 +717,7 @@ var testSuite = {
           "operator '=' type mismatch: numeric type or SET or BOOLEAN or CHAR or character array or POINTER or PROCEDURE expected, got 'ARRAY 3 OF INTEGER'"])
     ),
 "multi-dimensional array expression": testWithGrammar(
-    Grammar.procedureBody,
+    oberonGrammar.procedureBody,
     pass("VAR a: ARRAY 10 OF ARRAY 5 OF INTEGER; BEGIN a[0][0] := 1 END",
          "VAR a: ARRAY 10, 5 OF BOOLEAN; BEGIN a[0][0] := TRUE END",
          "VAR a: ARRAY 10, 5 OF BOOLEAN; BEGIN a[0, 0] := TRUE END")
@@ -944,7 +946,7 @@ var testSuite = {
         )
     ),
 "procedure body": testWithGrammar(
-    Grammar.procedureBody,
+    oberonGrammar.procedureBody,
     pass("END",
          "VAR END",
          "VAR i: INTEGER; END",
@@ -980,7 +982,7 @@ var testSuite = {
          ["PROCEDURE p(p: INTEGER)", "argument 'p' has the same name as procedure"])
     ),
 "procedure": testWithContext(
-    context(Grammar.procedureDeclaration,
+    context(oberonGrammar.procedureDeclaration,
             "TYPE ProcType = PROCEDURE(): ProcType;"),
     pass("PROCEDURE p; END p",
          "PROCEDURE p; VAR i: INTEGER; BEGIN i := i + 1 END p",
@@ -1001,7 +1003,7 @@ var testSuite = {
     ),
 "procedure RETURN": testWithContext(
     context(
-        Grammar.procedureDeclaration,
+        oberonGrammar.procedureDeclaration,
             "TYPE A = ARRAY 3 OF INTEGER; R = RECORD END; PR = POINTER TO R;"
           + "VAR i: INTEGER; PROCEDURE int(): INTEGER; RETURN 1 END int;"),
     pass("PROCEDURE p(): BOOLEAN; RETURN TRUE END p",
@@ -1030,7 +1032,7 @@ var testSuite = {
          )
     ),
 "pass VAR argument as VAR parameter": testWithContext(
-    context(Grammar.procedureDeclaration,
+    context(oberonGrammar.procedureDeclaration,
             "PROCEDURE p1(VAR i: INTEGER); END p1;"
             + "PROCEDURE p2(VAR b: BOOLEAN); END p2;"),
     pass("PROCEDURE p(VAR i1: INTEGER); BEGIN p1(i1) END p"),
@@ -1057,7 +1059,7 @@ var testSuite = {
          ["p2(~b1)", "expression cannot be used as VAR parameter"])
     ),
 "ARRAY parameter": testWithContext(
-    context(Grammar.procedureDeclaration,
+    context(oberonGrammar.procedureDeclaration,
             "TYPE T = RECORD i: INTEGER; p: POINTER TO T END;"
             + "PROCEDURE p1(i: INTEGER); END p1;"
             + "PROCEDURE varInteger(VAR i: INTEGER); END varInteger;"
@@ -1101,7 +1103,7 @@ var testSuite = {
          )
 ),
 "local procedure": testWithContext(
-    context(Grammar.procedureDeclaration,
+    context(oberonGrammar.procedureDeclaration,
             "TYPE ProcType = PROCEDURE;" +
             "VAR procVar: ProcType;" +
             "PROCEDURE procWithProcArg(p: ProcType); END procWithProcArg;"),
@@ -1211,7 +1213,7 @@ var testSuite = {
          ["r1 := b1", "type mismatch: 'r1' is 'T1' and cannot be assigned to 'Base1' expression"])
     ),
 "open array assignment fails": testWithGrammar(
-    Grammar.procedureDeclaration,
+    oberonGrammar.procedureDeclaration,
     pass(),
     fail(["PROCEDURE p(s1, s2: ARRAY OF CHAR); BEGIN s1 := s2 END p",
           "cannot assign to read-only variable"],
@@ -1221,7 +1223,7 @@ var testSuite = {
           "type mismatch: 's2' is 'ARRAY 10 OF CHAR' and cannot be assigned to 'ARRAY OF CHAR' expression"])
     ),
 "open array type as procedure parameter": testWithContext(
-    context(Grammar.procedureDeclaration,
+    context(oberonGrammar.procedureDeclaration,
             "TYPE A = ARRAY 3 OF INTEGER;"
             ),
     pass("PROCEDURE p(a: ARRAY OF INTEGER); BEGIN END p",
@@ -1233,7 +1235,7 @@ var testSuite = {
         )
     ),
 "non-open array type as procedure parameter": testWithContext(
-    context(Grammar.procedureDeclaration,
+    context(oberonGrammar.procedureDeclaration,
             "TYPE A = ARRAY 2 OF INTEGER;"
             + "VAR a: A;"
             + "PROCEDURE pa(a: A); BEGIN END pa;"
@@ -1253,7 +1255,7 @@ var testSuite = {
         )
     ),
 "string assignment to open array fails": testWithGrammar(
-    Grammar.procedureDeclaration,
+    oberonGrammar.procedureDeclaration,
     pass(),
     fail(["PROCEDURE p(s: ARRAY OF CHAR); BEGIN s := \"abc\" END p", "cannot assign to read-only variable"],
          ["PROCEDURE p(VAR s: ARRAY OF CHAR); BEGIN s := \"abc\" END p", "string cannot be assigned to open ARRAY OF CHAR"])
@@ -1271,11 +1273,11 @@ var testSuite = {
          ["p4(\"abc\")", "type mismatch for argument 1: 'multi-character string' cannot be converted to 'ARRAY OF INTEGER'"])
     ),
 "scope": testWithGrammar(
-    Grammar.declarationSequence,
+    oberonGrammar.declarationSequence,
     pass("PROCEDURE p1(a1: INTEGER); END p1; PROCEDURE p2(a1: BOOLEAN); END p2;")
     ),
 "module": testWithGrammar(
-    Grammar.module,
+    oberonGrammar.module,
     pass("MODULE m; END m."),
     fail(["MODULE m; END undeclared.",
           "original module name 'm' expected, got 'undeclared'"],
@@ -1289,7 +1291,7 @@ var testSuite = {
          ["ASSERT(123, TRUE)", "type mismatch for argument 1: 'INTEGER' cannot be converted to 'BOOLEAN'"])
     ),
 "export": testWithGrammar(
-    Grammar.declarationSequence,
+    oberonGrammar.declarationSequence,
     pass("CONST i* = 1;",
          "TYPE T* = RECORD END;",
          "VAR i*: INTEGER;",
@@ -1318,7 +1320,7 @@ var testSuite = {
          )
     ),
 "import JS": testWithGrammar(
-    Grammar.module,
+    oberonGrammar.module,
     pass("MODULE m; IMPORT JS; END m.",
          "MODULE m; IMPORT JS; BEGIN JS.alert(\"test\") END m.",
          "MODULE m; IMPORT JS; BEGIN JS.console.info(123) END m.",
@@ -1333,7 +1335,7 @@ var testSuite = {
           )
     ),
 "JS.var": testWithGrammar(
-    Grammar.module,
+    oberonGrammar.module,
     pass("MODULE m; IMPORT JS; VAR v: JS.var; END m.",
          "MODULE m; IMPORT JS; VAR v: JS.var; BEGIN v := JS.f(); END m.",
          "MODULE m; IMPORT JS; VAR v: JS.var; BEGIN v := JS.f1(); JS.f2(v); END m."
@@ -1342,19 +1344,19 @@ var testSuite = {
           "type mismatch: 'i' is 'INTEGER' and cannot be assigned to 'JS.var' expression"])
     ),
 "import unknown module": testWithGrammar(
-    Grammar.module,
+    oberonGrammar.module,
     pass(),
     fail(["MODULE m; IMPORT unknown; END m.", "module(s) not found: unknown"],
          ["MODULE m; IMPORT unknown1, unknown2; END m.", "module(s) not found: unknown1, unknown2"]
          )
     ),
 "self import is failed": testWithGrammar(
-    Grammar.module,
+    oberonGrammar.module,
     pass(),
     fail(["MODULE test; IMPORT test; END test.", "module 'test' cannot import itself"])
     ),
 "import aliases": testWithGrammar(
-    Grammar.module,
+    oberonGrammar.module,
     pass("MODULE m; IMPORT J := JS; END m.",
          "MODULE m; IMPORT J := JS; BEGIN J.alert(\"test\") END m."),
     fail(["MODULE m; IMPORT u1 := unknown1, unknown2; END m.", "module(s) not found: unknown1, unknown2"],
@@ -1431,7 +1433,7 @@ var testSuite = {
           "POINTER TO non-exported RECORD type cannot be dereferenced"])
     ),
 "syntax errors": testWithGrammar(
-    Grammar.module,
+    oberonGrammar.module,
     pass(),
     fail(["MODULE m; CONST c = 1 END m.",
           "';' expected"],