js -> eberon transition

src/context.js

@@ -42,23 +42,6 @@ var HandleSymbolAsType = ContextType.HandleSymbolAsType;
 HandleSymbolAsType.extend = Class.extend;
 HandleSymbolAsType.prototype.init = ContextType.HandleSymbolAsType;
 
-function assertProcType(type, info){
-    var unexpected;
-    if ( !type )
-        unexpected = info.idType();
-    else if (((info instanceof TypeId.Type) || !(type instanceof Type.Procedure)) 
-        && !(type instanceof Module.AnyType))
-        unexpected = type.description();
-    if (unexpected)
-        throw new Errors.Error("PROCEDURE expected, got '" + unexpected + "'");
-    return type;
-}
-
-function assertProcStatementResult(type){
-    if (type && !(type instanceof Module.AnyType))
-        throw new Errors.Error("procedure returning a result cannot be used as a statement");
-}
-
 function beginCallMsg(){}
 function endCallMsg(){}
 
@@ -212,19 +195,7 @@ var ModuleImport = ChainedContext.extend({
 });
 exports.ModuleImport = ModuleImport;
 
-function makeProcCall(context, type, info){
-    assertProcType(type, info);
-    var l = context.root().language();
-    return type.callGenerator(
-        { types: l.types, 
-          rtl: function(){ return l.rtl(); }, 
-          qualifyScope: context.qualifyScope.bind(context)
-        });
-}
-
-exports.assertProcStatementResult = assertProcStatementResult;
 exports.beginCallMsg = beginCallMsg;
 exports.endCallMsg = endCallMsg;
 exports.Chained = ChainedContext;
-exports.makeProcCall = makeProcCall;
 exports.HandleSymbolAsType = HandleSymbolAsType;

src/eberon/EberonArray.ob

@@ -43,7 +43,7 @@ END MethodIndexOf.callGenerator;
 PROCEDURE MethodCallIndexOf.make(args: ARRAY OF Expression.PType; cx: LanguageContext.PType): Expression.PType;
 BEGIN
     argCode <- Procedure.makeArgumentsCode(cx);
-    argType <- Procedure.checkSingleArgument(args, SELF, cx.types, argCode).type();
+    argType <- Procedure.checkSingleArgument(args, SELF, cx.language.types, argCode).type();
     RETURN Expression.makeSimple("(" + argCode.result() + ")", Types.basic.integer)
 END MethodCallIndexOf.make;
 

src/eberon/EberonCast.ob

@@ -31,7 +31,7 @@ BEGIN
 END;
 
 PROCEDURE CastOpToDynamicArray.assign(cx: LanguageContext.PType; left, right: Expression.PType): STRING;
-    RETURN copyArray(left.type()(Types.PArray), left.code(), right.code(), cx.rtl()^)
+    RETURN copyArray(left.type()(Types.PArray), left.code(), right.code(), cx.language.rtl^)
 END;
 
 PROCEDURE CastOpToMap.make(cx: LanguageContext.PType; e: Expression.PType): Expression.PType;
@@ -39,11 +39,11 @@ PROCEDURE CastOpToMap.make(cx: LanguageContext.PType; e: Expression.PType): Expr
 END;
 
 PROCEDURE CastOpToMap.assign(cx: LanguageContext.PType; left, right: Expression.PType): STRING;
-    RETURN cx.rtl().copy(right.code(), left.code(), EberonOperator.generateTypeInfo(left.type()));
+    RETURN cx.language.rtl.copy(right.code(), left.code(), EberonOperator.generateTypeInfo(left.type()));
 END;
 
 PROCEDURE CastOpToMap.clone(cx: LanguageContext.PType; e: Expression.PType): STRING;
-    RETURN cx.rtl().clone(e.code(), EberonOperator.generateTypeInfo(e.type()), "undefined");
+    RETURN cx.language.rtl.clone(e.code(), EberonOperator.generateTypeInfo(e.type()), "undefined");
 END;
 
 PROCEDURE isOpenCharArray(type: Types.PType): BOOLEAN;

src/eberon/EberonConstructor.ob

@@ -26,20 +26,20 @@ TYPE
 PROCEDURE checkArgs(call: ConstructorCall; args: ARRAY OF Expression.PType; cx: LanguageContext.PType): STRING;
 BEGIN
     argCode <- Procedure.makeArgumentsCode(cx);
-    Procedure.processArguments(args, call.args, argCode, cx.types);
+    Procedure.processArguments(args, call.args, argCode, cx.language.types);
     RETURN argCode.result();
 END;
 
 PROCEDURE ConstructorCall.make(args: ARRAY OF Expression.PType; cx: LanguageContext.PType): Expression.PType;
 BEGIN
     argCode <- checkArgs(SELF, args, cx);
-    RETURN Expression.makeSimple(Record.initializer(cx^, SELF.recordType^, argCode), SELF.resultType);
+    RETURN Expression.makeSimple(Record.initializer(cx.cx^, SELF.recordType^, argCode), SELF.resultType);
 END;
 
 PROCEDURE BaseConstructorCall.make(args: ARRAY OF Expression.PType; cx: LanguageContext.PType): Expression.PType;
 BEGIN
     argCode <- checkArgs(SELF, args, cx);
-    code <- Record.constructor(cx^, SELF.recordType^) + ".call(this, " + argCode + ");" + Stream.kCR;
+    code <- Record.constructor(cx.cx^, SELF.recordType^) + ".call(this, " + argCode + ");" + Stream.kCR;
     RETURN Expression.makeSimple(code, NIL);
 END;
 
@@ -83,7 +83,7 @@ BEGIN
         raiseSingleArgumentException(SELF);
     END;
 
-    IF SELF.cx.types.implicitCast(e.type(), SELF.type, FALSE, op)
+    IF SELF.cx.language.types.implicitCast(e.type(), SELF.type, FALSE, op)
         # Cast.errNo THEN
             Errors.raise("type mismatch: field '" + SELF.field + "' is '" + SELF.type.description()
                          + "' and cannot be initialized using '" + e.type().description() + "' expression");
@@ -115,7 +115,7 @@ BEGIN
         instType := EberonRecord.instantiateForNew;
     END;
     
-    EberonRecord.ensureCanBeInstantiated(cx^, recordType, instType);
+    EberonRecord.ensureCanBeInstantiated(cx.cx^, recordType, instType);
     IF forNew THEN
         resultType := NEW Record.Pointer("", typeId);
     END;

src/eberon/EberonDynamicArray.ob

@@ -119,14 +119,14 @@ BEGIN
         NEW Types.ProcedureArgument(SELF.elementsType, FALSE), 
         0, 
         argCode, 
-        SELF.cx.types);
+        SELF.cx.language.types);
     SELF.code := argCode.result();
     
     t <- e.type();
     IF t IS Types.PArray THEN
         SELF.code := Cast.cloneArray(t, SELF.code, SELF.cx);
     ELSIF t IS Record.PType THEN
-        SELF.code := SELF.cx.rtl().clone(SELF.code, EberonOperator.generateTypeInfo(t), Record.constructor(SELF.cx^, t^));
+        SELF.code := SELF.cx.language.rtl.clone(SELF.code, EberonOperator.generateTypeInfo(t), Record.constructor(SELF.cx.cx^, t^));
     END;
 END AddCallGenerator.handleArgument;
 
@@ -178,14 +178,14 @@ END;
 
 PROCEDURE MethodCallClear.make(args: ARRAY OF Expression.PType; cx: LanguageContext.PType): Expression.PType;
 BEGIN
-    Procedure.processArguments(args, SELF.args, NIL, cx.types);
+    Procedure.processArguments(args, SELF.args, NIL, cx.language.types);
     RETURN Expression.makeSimple("(0, Number.MAX_VALUE)", NIL)
 END MethodCallClear.make;
 
 PROCEDURE MethodCallRemove.make(args: ARRAY OF Expression.PType; cx: LanguageContext.PType): Expression.PType;
 BEGIN
     argCode <- Procedure.makeArgumentsCode(cx);
-    arg <- Procedure.checkSingleArgument(args, SELF, cx.types, argCode);
+    arg <- Procedure.checkSingleArgument(args, SELF, cx.language.types, argCode);
     value <- arg.constValue();
     IF (value # NIL) & (value^ IS ConstValue.Int) THEN
         Code.checkIndex(value.value);

src/eberon/EberonMap.ob

@@ -80,7 +80,7 @@ END;
 PROCEDURE MethodCallRemove.make(args: ARRAY OF Expression.PType; cx: LanguageContext.PType): Expression.PType;
 BEGIN
     argCode <- Procedure.makeArgumentsCode(cx);
-    arg <- Procedure.checkSingleArgument(args, SELF, cx.types, argCode);
+    arg <- Procedure.checkSingleArgument(args, SELF, cx.language.types, argCode);
     RETURN Expression.makeSimple("[" + argCode.result() + "]", NIL)
 END;        
 

src/eberon/EberonOperator.ob

@@ -98,9 +98,10 @@ BEGIN
         IF (right.designator() = NIL) & (left.type() = right.type()) THEN
             result := leftLval + " = " + right.code();
         ELSE
-            result := leftLval + " = " + cx.rtl().clone(right.code(), 
-                                                      generateTypeInfo(left.type()), 
-                                                      Record.constructor(cx^, left.type()(Record.PType)^));
+            result := leftLval + " = " 
+                    + cx.language.rtl.clone(right.code(), 
+                                            generateTypeInfo(left.type()), 
+                                            Record.constructor(cx.cx^, left.type()(Record.PType)^));
         END;
     ELSE
         result := SUPER(cx, left, right);

src/eberon/EberonRecord.ob

@@ -1,6 +1,8 @@
 MODULE EberonRecord;
 IMPORT 
-    Cast, Chars, Context, EberonContext, EberonTypes, Errors, JS, Object, Base := Record, Scope, ScopeBase, String, Types;
+    Cast, Chars, Context, EberonContext, EberonTypes, 
+    Errors, JS, Object, Procedure, Base := Record, 
+    Scope, ScopeBase, String, Types;
 CONST
     instantiateForVar* = 0;    
     instantiateForNew* = 1;    
@@ -16,16 +18,16 @@ TYPE
     Record* = RECORD(Base.Type)
         PROCEDURE Record(name: STRING; cons: STRING; scope: ScopeBase.PType);
 
-        PROCEDURE declareConstructor(type: Types.PDefinedProcedure; exported: BOOLEAN);
+        PROCEDURE declareConstructor(type: Procedure.PType; exported: BOOLEAN);
         PROCEDURE addMethod(methodId: Context.PIdentdefInfo; type: Types.PProcedure);
-        PROCEDURE defineConstructor(type: Types.PDefinedProcedure);
+        PROCEDURE defineConstructor(type: Procedure.PType);
         PROCEDURE defineMethod(methodId: Context.PIdentdefInfo; type: EberonTypes.PMethodType);
         PROCEDURE requireNewOnly();
         PROCEDURE setBaseConstructorCallCode(code: STRING);
         PROCEDURE setFieldInitializationCode(field: STRING; code: STRING);
         PROCEDURE setRecordInitializationCode(baseConstructorCallCode: STRING);
 
-        customConstructor-: Types.PDefinedProcedure;
+        customConstructor-: Procedure.PType;
         customConstructorExported: BOOLEAN;
         customConstructorDefined: BOOLEAN;
         customInitedfields-: ARRAY * OF STRING;
@@ -211,7 +213,7 @@ PROCEDURE FieldAsMethod.asVar(leadCode: STRING; isReadOnly: BOOLEAN; cx: Context
     RETURN NEW EberonTypes.MethodVariable(SELF.type()(Types.PProcedure)); 
 END;
 
-PROCEDURE constructor*(r: Record): Types.PDefinedProcedure;
+PROCEDURE constructor*(r: Record): Procedure.PType;
 BEGIN
     result <- r.customConstructor;
     IF (result = NIL) & (r.base # NIL) THEN
@@ -336,7 +338,7 @@ END;
 
 PROCEDURE Record.defineMethod(methodId: Context.PIdentdefInfo; type: EberonTypes.PMethodType);
 VAR 
-    existingType: Types.PDefinedProcedure;
+    existingType: Procedure.PType;
 BEGIN
     id <- methodId.id();
     IF SELF.definedMethods.indexOf(id) # -1 THEN
@@ -391,7 +393,7 @@ BEGIN
     SELF.baseConstructorCallCode := baseConstructorCallCode;
 END;
 
-PROCEDURE Record.declareConstructor(type: Types.PDefinedProcedure; exported: BOOLEAN);
+PROCEDURE Record.declareConstructor(type: Procedure.PType; exported: BOOLEAN);
 BEGIN
     IF SELF.customConstructor # NIL THEN
         Errors.raise("constructor '" + SELF.name + "' already declared");
@@ -404,7 +406,7 @@ BEGIN
     SELF.customConstructorExported := exported;
 END;
 
-PROCEDURE Record.defineConstructor(type: Types.PDefinedProcedure);
+PROCEDURE Record.defineConstructor(type: Procedure.PType);
 BEGIN
     IF SELF.customConstructor = NIL THEN
         Errors.raise("constructor was not declared for '" + SELF.name +"'");

src/eberon/EberonTypes.ob

@@ -2,14 +2,14 @@ MODULE EberonTypes;
 IMPORT Context, LanguageContext, Procedure, Record, Types;
 
 TYPE
-    CallGenerator = PROCEDURE(cx: LanguageContext.PType; type: Types.DefinedProcedure): Procedure.PCallGenerator;
+    CallGenerator = PROCEDURE(cx: LanguageContext.PType; type: Procedure.Type): Procedure.PCallGenerator;
 
     MethodType* = RECORD(Procedure.Std)
-        PROCEDURE MethodType*(id: STRING; t: Types.PDefinedProcedure; call: CallGenerator);
+        PROCEDURE MethodType*(id: STRING; t: Procedure.PType; call: CallGenerator);
 
-        PROCEDURE procType*(): Types.PDefinedProcedure;
+        PROCEDURE procType*(): Procedure.PType;
 
-        type: Types.PDefinedProcedure;
+        type: Procedure.PType;
         call: CallGenerator
     END;
     PMethodType* = POINTER TO MethodType;
@@ -29,7 +29,7 @@ PROCEDURE MethodType.designatorCode(id: STRING): STRING;
     RETURN id
 END MethodType.designatorCode;
 
-PROCEDURE MethodType.procType(): Types.PDefinedProcedure;
+PROCEDURE MethodType.procType(): Procedure.PType;
     RETURN SELF.type
 END MethodType.procType;
 
@@ -41,7 +41,7 @@ PROCEDURE MethodType.callGenerator(cx: LanguageContext.PType): Procedure.PCallGe
     RETURN SELF.call(cx, SELF.type^)
 END MethodType.callGenerator;
 
-PROCEDURE MethodType.MethodType(id: STRING; t: Types.PDefinedProcedure; call: CallGenerator)
+PROCEDURE MethodType.MethodType(id: STRING; t: Procedure.PType; call: CallGenerator)
     | SUPER(id, NIL);
 BEGIN
     SELF.type := t;

src/eberon/eberon_context.js

@@ -26,6 +26,7 @@ var EberonString = require("js/EberonString.js");
 var EberonTypes = require("js/EberonTypes.js");
 var Errors = require("js/Errors.js");
 var Expression = require("js/Expression.js");
+var Module = require("js/Module.js");
 var op = require("js/Operator.js");
 var eOp = require("js/EberonOperator.js");
 var Symbol = require("js/Symbols.js");
@@ -199,17 +200,8 @@ var Identdef = Class.extend.call(ContextIdentdef.Type, {
     }
 });
 
-function makeContext(context){
-    var l = context.root().language();
-    return {
-        types: l.types, 
-        rtl: function(){return l.rtl();}, 
-        qualifyScope: context.qualifyScope.bind(context)
-        };
-    }
-
 function makeContextCall(context, call){
-    return call(makeContext(context));
+    return call(ContextHierarchy.makeLanguageContext(context));
     }
 
 function OperatorNewMsg(e){
@@ -273,7 +265,7 @@ var Designator = Class.extend.call(ContextDesignator.Type, {
 
         if (currentType instanceof EberonMap.Type){
             var indexType = currentType.valueType;
-            var rval = this.root().language().rtl().getMappedValue(code, indexCode);
+            var rval = this.root().language().rtl.getMappedValue(code, indexCode);
             return { length: undefined, 
                      type: indexType,
                      info: new MapElementVariable(indexType, info.isReadOnly(), rval),
@@ -341,7 +333,7 @@ var Designator = Class.extend.call(ContextDesignator.Type, {
             this.discardCode();
         }
         else
-            this.__procCall = Context.makeProcCall(this, type, this.info);
+            this.__procCall = ContextProcedure.makeCall(this, type, this.info);
     },
     __endCall: function(){
         var e = this.__procCall.end();
@@ -417,7 +409,7 @@ var InPlaceVariableInit = Context.Chained.extend({
             EberonRecord.ensureCanBeInstantiated(this, type, EberonRecord.instantiateForCopy);
             if (e.designator()){
                 var l = this.root().language();
-                this._code += l.rtl().clone(e.code(), l.types.typeInfo(type));
+                this._code += l.rtl.clone(e.code(), l.types.typeInfo(type));
             }
             else // do not clone if it is temporary, e.g. constructor call
                 this._code += e.code();
@@ -429,7 +421,7 @@ var InPlaceVariableInit = Context.Chained.extend({
             var language = this.root().language();
             var cloneOp;
             language.types.implicitCast(type, type, false, {set: function(v){cloneOp = v;}, get:function(){return cloneOp;}});
-            this._code += cloneOp.clone(language, e);
+            this._code += cloneOp.clone(ContextHierarchy.makeLanguageContext(this), e);
         }
     },
     _onParsed: function(){
@@ -489,16 +481,16 @@ var AssignmentOrProcedureCall = Context.Chained.extend({
         var code;
         if (this.__right){
             var left = Expression.make(d.code(), type, d);
-            code = op.assign(left, this.__right, makeContext(this));
+            code = op.assign(left, this.__right, ContextHierarchy.makeLanguageContext(this));
         }
         else if (!(d.info() instanceof ResultVariable)){
-            var procCall = Context.makeProcCall(this, type, d.info());
+            var procCall = ContextProcedure.makeCall(this, type, d.info());
             var result = procCall.end();
-            Context.assertProcStatementResult(result.type());
+            Module.assertProcStatementResult(result.type());
             code = d.code() + result.code();
         }
         else{
-            Context.assertProcStatementResult(type);
+            Module.assertProcStatementResult(type);
             code = d.code();
         }
     

src/nodejs.js

@@ -83,7 +83,7 @@ function compile(sources, language, handleErrors, includeDirs, outDir, importDir
             function(moduleResolver){return new ContextHierarchy.Root(
                 { codeGenerator: language.codeGenerator.make(),
                   moduleGenerator: moduleCode,
-                  rtl: function(){return rtl;},
+                  rtl: rtl,
                   types: language.types,
                   stdSymbols: language.stdSymbols,
                   moduleResolver: moduleResolver

src/ob/Cast.ob

@@ -61,13 +61,13 @@ PROCEDURE areTypesMatch*(t1: Types.PType; t2: Types.PType): BOOLEAN;
             OR ((t2 = Types.nil) & (matchesToNIL(t1^))))
 END areTypesMatch;
 
-PROCEDURE areArgsMatch(a1, a2: Types.PProcedureArgument; p1, p2: Types.PDefinedProcedure): BOOLEAN;
+PROCEDURE areArgsMatch(a1, a2: Types.PProcedureArgument; p1, p2: Types.PProcedure): BOOLEAN;
     RETURN (a1.isVar = a2.isVar)
         & (    ((a1.type = p1) & (a2.type = p2))
             OR areTypesExactlyMatch(a1.type, a2.type))
 END areArgsMatch;
 
-PROCEDURE areProceduresMatch*(p1, p2: Types.PDefinedProcedure): BOOLEAN;
+PROCEDURE areProceduresMatch*(p1, p2: Types.PProcedure): BOOLEAN;
 VAR
     result: BOOLEAN;
 BEGIN
@@ -103,7 +103,7 @@ BEGIN
     ELSIF (t1 IS Record.PPointer) & (t2 IS Record.PPointer) THEN
         result := areTypesMatch(Record.pointerBase(t1^), 
                                 Record.pointerBase(t2^));
-    ELSIF (t1 IS Types.PDefinedProcedure) & (t2 IS Types.PDefinedProcedure) THEN
+    ELSIF (t1 IS Types.PProcedure) & (t2 IS Types.PProcedure) THEN
         result := areProceduresMatch(t1, t2);
     END;
     RETURN result
@@ -147,7 +147,8 @@ BEGIN
     IF t.elementsType.isScalar() THEN
         result := code + ".slice()";
     ELSE
-        result := cx.rtl().clone(code, cx.types.typeInfo(t), "undefined");
+        l <- cx.language;
+        result := l.rtl.clone(code, l.types.typeInfo(t), "undefined");
     END;
     RETURN result
 END;
@@ -161,7 +162,7 @@ PROCEDURE CastOpArray.clone(cx: LanguageContext.PType; e: Expression.PType): STR
 END;
 
 PROCEDURE CastOpRecord.assign(cx: LanguageContext.PType; left, right: Expression.PType): STRING;
-    RETURN cx.rtl().copy(right.code(), left.lval(), Record.generateTypeInfo(left.type()));
+    RETURN cx.language.rtl.copy(right.code(), left.lval(), Record.generateTypeInfo(left.type()));
 END;
 
 PROCEDURE CastOpStrToChar.make(cx: LanguageContext.PType; e: Expression.PType): Expression.PType;
@@ -233,7 +234,7 @@ BEGIN
         END;
     ELSIF (from = Types.nil) & matchesToNIL(to^) THEN
         result := errNo;
-    ELSIF (from IS Types.PDefinedProcedure) & (to IS Types.PDefinedProcedure) THEN
+    ELSIF (from IS Types.PProcedure) & (to IS Types.PProcedure) THEN
         IF areProceduresMatch(from, to) THEN
             result := errNo;
         END

src/ob/ContextDesignator.ob

@@ -87,7 +87,7 @@ PROCEDURE Type.handleTypeCast(type: Types.PType);
 BEGIN
     ContextExpression.checkTypeCast(SELF.info(Types.PVariable), SELF.currentType, type, "type cast");
 
-    code <- SELF.root().language().rtl().typeGuard(SELF.code, ContextExpression.castCode(type, SELF));
+    code <- SELF.root().language().rtl.typeGuard(SELF.code, ContextExpression.castCode(type, SELF));
     SELF.code := code;
 
     SELF.currentType := type;
@@ -230,7 +230,7 @@ BEGIN
 
     readOnly <- (info IS Types.PConst) 
              OR ((info IS Types.PVariable) & info.isReadOnly());
-    v <- NEW Variable.PropertyVariable(indexType, leadCode, indexCode, readOnly, SELF.root().language().rtl());
+    v <- NEW Variable.PropertyVariable(indexType, leadCode, indexCode, readOnly, SELF.root().language().rtl);
     RETURN NEW Index(length, indexType, v, wholeCode, lval, indexCode);
 END;
 

src/ob/ContextExpression.ob

@@ -519,7 +519,7 @@ BEGIN
         rightExpression := promoteTypeInExpression(rightExpression, leftExpression.type());
 
         o <- SELF.doRelationOperation(leftExpression, rightExpression, SELF.relation);
-        SELF.expression := o(leftExpression, rightExpression, SELF.root().language());
+        SELF.expression := o(leftExpression, rightExpression, ContextHierarchy.makeLanguageContext(SELF(POINTER)));
     END;
 END;
 
@@ -984,7 +984,7 @@ BEGIN
     IF LEN(SELF.expression) = 0 THEN
         parent.handleExpression(expressionFromConst(Types.basic.set, NEW ConstValue.Set(SELF.value), String.fromInt(ORD(SELF.value))));
     ELSE
-        code <- SELF.root().language().rtl().makeSet(SELF.expression);
+        code <- SELF.root().language().rtl.makeSet(SELF.expression);
         IF SELF.value # {} THEN
             code := code + " | " + String.fromInt(ORD(SELF.value));
         END;

src/ob/ContextHierarchy.ob

@@ -38,9 +38,9 @@ TYPE
     END;
 
     Root* = RECORD(Node)
-        PROCEDURE Root(language: LanguageContext.PType);
+        PROCEDURE Root(language: LanguageContext.PLanguage);
 
-        PROCEDURE language*(): LanguageContext.PType;
+        PROCEDURE language*(): LanguageContext.PLanguage;
 
         PROCEDURE findSymbol*(ident: STRING): Symbols.PFoundSymbol;
         PROCEDURE findModule(name: STRING): Types.PModule;
@@ -49,7 +49,7 @@ TYPE
         PROCEDURE pushScope*(scope: Scope.PType);
         PROCEDURE popScope*();
 
-        mLanguage: LanguageContext.PType;
+        mLanguage: LanguageContext.PLanguage;
         scopes: ARRAY * OF Scope.PType;
         gen: INTEGER;
     END;
@@ -76,10 +76,6 @@ PROCEDURE Node.parent(): PNode;
     RETURN SELF.mParent;
 END;
 
-PROCEDURE Node.rtl(): OberonRtl.PType;
-    RETURN SELF.root().language().rtl();
-END;
-
 PROCEDURE Node.handleMessage(VAR msg: Message): Object.PType;
     RETURN SELF.mParent.handleMessage(msg);
 END;
@@ -92,6 +88,10 @@ PROCEDURE Node.qualifyScope(scope: ScopeBase.PType): STRING;
     RETURN SELF.mParent.qualifyScope(scope);
 END;
 
+PROCEDURE Node.rtl(): OberonRtl.PType;
+    RETURN SELF.root().language().rtl;
+END;
+
 PROCEDURE Node.handleLiteral(s: STRING);
 END;
 
@@ -102,12 +102,12 @@ PROCEDURE Node.genTypeName(): STRING;
     RETURN SELF.mParent.genTypeName();
 END;
 
-PROCEDURE Root.Root(language: LanguageContext.PType)
+PROCEDURE Root.Root(language: LanguageContext.PLanguage)
     | SUPER(NIL),
       mLanguage(language);
-END;
+      END;
 
-PROCEDURE Root.language(): LanguageContext.PType;
+PROCEDURE Root.language(): LanguageContext.PLanguage;
     RETURN SELF.mLanguage;
 END;
 
@@ -200,4 +200,8 @@ PROCEDURE getSymbol*(cx: Root; id: STRING): Symbols.PSymbol;
     RETURN getSymbolAndScope(cx, id).symbol();
 END;
 
+PROCEDURE makeLanguageContext*(cx: PNode): LanguageContext.PType;
+    RETURN NEW LanguageContext.Type(cx.root().language(), cx);
+END;
+
 END ContextHierarchy.

src/ob/ContextProcedure.ob

@@ -3,7 +3,7 @@ IMPORT
     Cast, Chars, CodeGenerator, Context, ContextExpression, 
     ContextHierarchy, ContextType, 
     Errors, Expression, LanguageContext,
-    Object, Procedure, Scope, Symbols, Types, Variable;
+    Object, Procedure, Scope, Symbols, TypeId, Types, Variable;
 TYPE
     Declaration* = RECORD(ContextType.DeclarationAndIdentHandle)
         PROCEDURE Declaration(parent: ContextHierarchy.PNode);
@@ -17,7 +17,7 @@ TYPE
 
         outerScope: Scope.PType;
         id: Context.PIdentdefInfo;
-        type: Types.PDefinedProcedure;
+        type: Procedure.PType;
         multipleArguments: BOOLEAN;
         returnParsed: BOOLEAN;
     END;
@@ -30,7 +30,7 @@ TYPE
         PROCEDURE doCheckResultType(type: Types.PStorageType);
 
         arguments: ARRAY * OF Types.PProcedureArgument;
-        type: Procedure.PType;
+        type: Procedure.PDefined;
         result: Types.PStorageType;
     END;
 
@@ -96,7 +96,7 @@ END;
 
 PROCEDURE Declaration.setType(type: Types.PStorageType);
 BEGIN
-    t <- type(Types.PDefinedProcedure);
+    t <- type(Procedure.PType);
     procSymbol <- NEW Symbols.Symbol(
         SELF.id.id(), NEW Types.ProcedureId(t));
     SELF.outerScope.addSymbol(procSymbol, SELF.id.exported());
@@ -158,7 +158,7 @@ BEGIN
             + type.description() + "'");
     END;
 
-    SELF.codeGenerator().write("return " + op.clone(language, e) + ";" + Chars.ln);
+    SELF.codeGenerator().write("return " + op.clone(ContextHierarchy.makeLanguageContext(SELF(POINTER)), e) + ";" + Chars.ln);
 
     SELF.returnParsed := TRUE;
 END;
@@ -178,7 +178,7 @@ END;
 
 PROCEDURE FormalParameters.FormalParameters(parent: ContextType.PDeclarationAndIdentHandle)
     | SUPER(parent),
-      type(NEW Procedure.Type(parent.typeName()));
+      type(NEW Procedure.Defined(parent.typeName()));
 BEGIN
     parent.setType(SELF.type);
 END;
@@ -273,4 +273,30 @@ PROCEDURE AddArgumentMsg.AddArgumentMsg(name: STRING; arg: Types.PProcedureArgum
       arg(arg);
 END;
 
+PROCEDURE assertProcType(type: Types.PType; info: Types.PId): Procedure.PType;
+VAR
+    unexpected: STRING;
+    result: Procedure.PType;
+BEGIN
+    IF type = NIL THEN
+        unexpected := info.idType();
+    ELSIF (info IS TypeId.PType) OR ~(type IS Procedure.PType) THEN
+        unexpected := type.description();
+    ELSE
+        result := type;
+    END;
+    
+    IF result = NIL THEN
+        Errors.raise("PROCEDURE expected, got '" + unexpected + "'");
+    END;
+    
+    RETURN result;
+END;
+
+PROCEDURE makeCall*(cx: ContextHierarchy.PNode; type: Types.PType; info: Types.PId): Procedure.PCallGenerator;
+BEGIN
+    RETURN assertProcType(type, info)
+          .callGenerator(ContextHierarchy.makeLanguageContext(cx));
+END;
+
 END ContextProcedure.

src/ob/ContextType.ob

@@ -157,7 +157,7 @@ VAR
     result: STRING;
     initializer: STRING;
 BEGIN
-    rtl <- SELF.root().language().rtl();
+    rtl <- SELF.root().language().rtl;
     IF type = Types.basic.ch THEN
         result := rtl.makeCharArray(dimensions);
     ELSE
@@ -366,7 +366,7 @@ BEGIN
     base <- SELF.type.base;
     IF base # NIL THEN
         qualifiedBase <- SELF.qualifyScope(base.scope) + base.name; 
-        result := SELF.root().language().rtl().extend(SELF.cons, qualifiedBase) + ";" + Chars.ln;
+        result := SELF.root().language().rtl.extend(SELF.cons, qualifiedBase) + ";" + Chars.ln;
     END;
     RETURN result;
 END;

src/ob/LanguageContext.ob

@@ -1,5 +1,5 @@
 MODULE LanguageContext;
-IMPORT Context, CodeGenerator, Expression, Symbols, T := Types;
+IMPORT CodeGenerator, Context, Expression, OberonRtl, Symbols, T := Types;
 
 TYPE
     PType* = POINTER TO Type;
@@ -20,11 +20,25 @@ TYPE
     END;
     PTypes* = POINTER TO Types;
 
-    Type* = RECORD(Context.Type)
-        moduleResolver*: PROCEDURE(name: STRING): T.PModule;
-        codeGenerator*: CodeGenerator.PIGenerator;
-        types*: PTypes;
-        stdSymbols*: Symbols.Map;
+    Language* = RECORD
+        moduleResolver-: PROCEDURE(name: STRING): T.PModule;
+        rtl-: OberonRtl.PType;
+        codeGenerator-: CodeGenerator.PIGenerator;
+        types-: PTypes;
+        stdSymbols-: Symbols.Map;
     END;
+    PLanguage* = POINTER TO Language;
+
+    Type* = RECORD
+        PROCEDURE Type*(language: PLanguage; cx: Context.PType);
+
+        language-: PLanguage;
+        cx-: Context.PType;
+    END;
+
+PROCEDURE Type.Type(language: PLanguage; cx: Context.PType)
+    | language(language),
+      cx(cx);
+END;
 
 END LanguageContext.

src/ob/Module.ob

@@ -1,18 +1,18 @@
 MODULE Module;
 IMPORT 
-    Context, Errors, Expression, LanguageContext, Procedure, Symbols, TypeId, Types;
+    Context, Errors, Expression, LanguageContext, Procedure, Symbols, TypeId, Types, Variable;
 TYPE
     Type* = RECORD(Types.Module)
         PROCEDURE findSymbol*(id: STRING): Symbols.PFoundSymbol
     END;
     PType* = POINTER TO Type;
 
-    AnyType* = RECORD(Types.Procedure)
+    AnyType = RECORD(Procedure.Type)
         PROCEDURE AnyType();
+    END;
 
-        PROCEDURE callGenerator(cx: LanguageContext.PType): Procedure.PCallGenerator;
-
-        asVar: Types.PId
+    AnyVariable = RECORD(Variable.TypedVariable)
+        PROCEDURE AnyVariable();
     END;
 
     AnyField = RECORD(Types.Field)
@@ -21,7 +21,7 @@ TYPE
         mId: STRING;
     END;
 
-    AnyTypeProc* = RECORD(Procedure.Std)
+    AnyTypeProc = RECORD(Procedure.Std)
     END;
 
     AnyProcCall = RECORD(Procedure.Call)
@@ -32,6 +32,7 @@ TYPE
 VAR
     doProcId, varTypeId: STRING;
     any: POINTER TO AnyType;
+    anyVar: POINTER TO AnyVariable;
     anyProc: AnyTypeProc;
     doProcSymbol, varTypeSymbol: Symbols.PSymbol;
 
@@ -63,6 +64,33 @@ PROCEDURE AnyType.isScalar(): BOOLEAN;
     RETURN FALSE;
 END;
 
+PROCEDURE AnyType.args(): Types.ProcedureArguments;
+VAR
+    result: Types.ProcedureArguments;
+BEGIN
+    RETURN result;
+END;
+
+PROCEDURE AnyType.result(): Types.PType;
+    RETURN NIL;
+END;
+
+PROCEDURE AnyVariable.AnyVariable()
+    | SUPER(any);
+END;
+
+PROCEDURE AnyVariable.isReadOnly(): BOOLEAN;
+    RETURN FALSE;
+END;
+
+PROCEDURE AnyVariable.isReference(): BOOLEAN;
+    RETURN TRUE;
+END;
+
+PROCEDURE AnyVariable.referenceCode(): STRING;
+    RETURN "";
+END;
+
 PROCEDURE AnyField.id(): STRING;
     RETURN "any field"
 END AnyField.id;
@@ -76,8 +104,8 @@ PROCEDURE AnyField.type(): Types.PStorageType;
 END AnyField.type;
 
 PROCEDURE AnyField.asVar(leadCode: STRING; isReadOnly: BOOLEAN; cx: Context.Type): Types.PId;
-    RETURN any.asVar
-END AnyField.asVar;
+    RETURN anyVar;
+END;
 
 PROCEDURE AnyField.designatorCode(leadCode: STRING; cx: Context.Type): Types.PFieldCode;
     RETURN NEW Types.FieldCode(leadCode + "." + SELF.mId, "", "");
@@ -128,7 +156,7 @@ VAR
         arg: Expression.PType;
         type: Types.PType;
     BEGIN
-        arg := Procedure.checkSingleArgument(args, SELF, cx.types, NIL);
+        arg := Procedure.checkSingleArgument(args, SELF, cx.language.types, NIL);
         type := arg.type();
         IF ~(type IS Types.PString) THEN
             Errors.raise("string is expected as an argument of "
@@ -153,19 +181,26 @@ PROCEDURE makeJS*(): PType;
 END;
 
 PROCEDURE AnyType.AnyType()
-    | SUPER("any type"),
-      asVar(NEW TypeId.Type(SELF(POINTER)));
+    | SUPER("any type");
 END;
 
 PROCEDURE AnyField.AnyField(id: STRING)
     | mId(id);
 END;
 
+PROCEDURE assertProcStatementResult*(type: Types.PType);
+BEGIN
+    IF (type # NIL) & ~(type^ IS AnyType) THEN
+        Errors.raise("procedure returning a result cannot be used as a statement");
+    END;
+END;
+
 BEGIN
     doProcId := "do$";
     varTypeId := "var$";
     
     NEW(any);
+    NEW(anyVar);
 
     doProcSymbol := makeDoProcSymbol();
     varTypeSymbol := makeVarTypeSymbol();

src/ob/Operator.ob

@@ -445,7 +445,7 @@ END codeSetInclR;
 
 PROCEDURE strCmp(op: STRING; left, right: Expression.PType; cx: LanguageContext.PType): Expression.PType;
     RETURN Expression.makeSimple(
-            cx.rtl().strCmp(castToStr(left, cx), castToStr(right, cx)) + op + "0",
+            cx.language.rtl.strCmp(castToStr(left, cx), castToStr(right, cx)) + op + "0",
             Types.basic.bool)
 END;
 
@@ -468,7 +468,7 @@ VAR
                          + String.fromInt(Types.stringLen(s))
                          + "-character string");
         END;
-        RETURN cx.rtl().assignArrayFromString(leftCode, rightCode)
+        RETURN cx.language.rtl.assignArrayFromString(leftCode, rightCode)
     END assignArrayFromString;
 BEGIN
     designator := left.designator();
@@ -488,7 +488,7 @@ BEGIN
         & (rightType IS Types.PString) THEN
         result := assignArrayFromString(leftType(Types.PArray)^, rightType^);
     ELSE
-        IF cx.types.implicitCast(rightType, leftType, FALSE, castOperation)
+        IF cx.language.types.implicitCast(rightType, leftType, FALSE, castOperation)
             # Cast.errNo THEN
             Errors.raise("type mismatch: '" + left.code() + "' is '" + leftType.description()
                          + "' and cannot be assigned to '" + rightType.description() + "' expression");
@@ -582,11 +582,11 @@ PROCEDURE setHasBit*(left, right: Expression.PType; cx: LanguageContext.PType):
 END;
 
 PROCEDURE setInclL*(left, right: Expression.PType; cx: LanguageContext.PType): Expression.PType;
-    RETURN binaryPred(left, right, cx.rtl(), opSetInclL, codeSetInclL)
+    RETURN binaryPred(left, right, cx.language.rtl, opSetInclL, codeSetInclL)
 END setInclL;
 
 PROCEDURE setInclR*(left, right: Expression.PType; cx: LanguageContext.PType): Expression.PType;
-    RETURN binaryPred(left, right, cx.rtl(), opSetInclR, codeSetInclR)
+    RETURN binaryPred(left, right, cx.language.rtl, opSetInclR, codeSetInclR)
 END setInclR;
 
 PROCEDURE or*(left, right: Expression.PType): Expression.PType;

src/ob/Procedure.ob

@@ -45,20 +45,22 @@ TYPE
         call: PCall
     END;
 
-    Type* = RECORD(Types.DefinedProcedure)
-        PROCEDURE callGenerator(cx: LanguageContext.PType): PCallGenerator;
+    Type* = RECORD(Types.Procedure)
+        PROCEDURE callGenerator*(cx: LanguageContext.PType): PCallGenerator;
+    END;
+    PType* = POINTER TO Type;
+
+    Defined* = RECORD(Type)
         PROCEDURE define*(args: ARRAY OF Types.PProcedureArgument; result: Types.PType);
 
         mArgs: Types.ProcedureArguments;
         mResult: Types.PType
     END;
-    PType* = POINTER TO Type;
+    PDefined* = POINTER TO Defined;
 
-    Std* = RECORD(Types.Procedure)
+    Std* = RECORD(Type)
         PROCEDURE Std*(name: STRING; call: PCall);
 
-        PROCEDURE callGenerator*(cx: LanguageContext.PType): PCallGenerator;
-
         call: PCall
     END;
 
@@ -159,12 +161,27 @@ BEGIN
     processArguments(actual, expected, NIL, types);
 END checkArguments;
 
+PROCEDURE Defined.designatorCode(id: STRING): STRING;
+    RETURN id;
+END;
+
 PROCEDURE Std.Std(name: STRING; call: PCall)
     | SUPER(name);
 BEGIN
     SELF.call := call;
 END;
 
+PROCEDURE Std.args(): Types.ProcedureArguments;
+VAR
+    result: Types.ProcedureArguments;
+BEGIN
+    RETURN result;
+END;
+
+PROCEDURE Std.result(): Types.PType;
+    RETURN NIL;
+END;
+
 PROCEDURE CallGeneratorImpl.handleArgument(e: Expression.PType);
 BEGIN
     SELF.args.add(e);
@@ -211,7 +228,7 @@ END GenArgCode.result;
 
 PROCEDURE makeProcCallGeneratorWithCustomArgs*(
     cx: LanguageContext.PType; 
-    type: Types.DefinedProcedure;
+    type: Type;
     argumentsCode: PArgumentsCode
     ) : PCallGenerator;
 TYPE
@@ -223,7 +240,7 @@ TYPE
 
     PROCEDURE CallImpl.make(args: ARRAY OF Expression.PType; cx: LanguageContext.PType): Expression.PType;
     BEGIN
-        processArguments(args, SELF.args, SELF.argumentsCode, cx.types);
+        processArguments(args, SELF.args, SELF.argumentsCode, cx.language.types);
         RETURN Expression.makeSimple(
                 "(" + SELF.argumentsCode.result() + ")",
                 SELF.result
@@ -246,7 +263,7 @@ END;
 
 PROCEDURE makeProcCallGenerator*(
     cx: LanguageContext.PType; 
-    type: Types.DefinedProcedure
+    type: Type
     ) : PCallGenerator;
     RETURN makeProcCallGeneratorWithCustomArgs(cx, type, makeArgumentsCode(cx))
 END makeProcCallGenerator;
@@ -309,7 +326,7 @@ PROCEDURE makeNew(): Symbols.PSymbol;
     VAR
         result: Expression.PType;
     BEGIN
-        arg <- checkSingleArgument(args, SELF, cx.types, NIL);
+        arg <- checkSingleArgument(args, SELF, cx.language.types, NIL);
         argType <- arg.type();
         IF ~(argType IS Record.PPointer) THEN
             Errors.raise("POINTER variable expected, got '" 
@@ -319,7 +336,7 @@ PROCEDURE makeNew(): Symbols.PSymbol;
             IF baseType IS Record.PNonExported THEN
                 Errors.raise("non-exported RECORD type cannot be used in NEW");
             END;
-            right <- Expression.makeSimple(baseType.codeForNew(cx^), argType);
+            right <- Expression.makeSimple(baseType.codeForNew(cx.cx^), argType);
             result := Expression.makeSimple(Operator.assign(arg, right, cx), NIL);
         END;
         RETURN result;
@@ -339,7 +356,7 @@ VAR
     arg: Expression.PType;
     argType: Types.PType;
 BEGIN
-    arg := checkSingleArgument(args, SELF, cx.types, NIL);
+    arg := checkSingleArgument(args, SELF, cx.language.types, NIL);
     argType := arg.type();
     IF ~SELF.check(argType) THEN
         Errors.raise("ARRAY or string is expected as an argument of LEN, got '"
@@ -369,7 +386,7 @@ PROCEDURE makeOdd(): Symbols.PSymbol;
         code: STRING;
         constValue: ConstValue.PType;
     BEGIN
-        arg := checkSingleArgument(args, SELF, cx.types, NIL);
+        arg := checkSingleArgument(args, SELF, cx.language.types, NIL);
         code := Code.adjustPrecedence(arg, Precedence.bitAnd);
         
         constValue := arg.constValue();
@@ -400,9 +417,9 @@ PROCEDURE makeAssert(): Symbols.PSymbol;
     VAR
         arg: Expression.PType;
     BEGIN
-        arg := checkSingleArgument(args, SELF, cx.types, NIL);
+        arg := checkSingleArgument(args, SELF, cx.language.types, NIL);
         RETURN Expression.makeSimple(
-                cx.rtl().assertId() + "(" + arg.code() + ")",
+                cx.language.rtl.assertId() + "(" + arg.code() + ")",
                 NIL)
     END CallImpl.make;
 BEGIN
@@ -427,7 +444,7 @@ PROCEDURE setBitImpl(name: STRING; bitOp: BinaryOpStr): Symbols.PSymbol;
         valueCode: STRING;
         comment: STRING;
     BEGIN
-        checkArguments(args, SELF.args, cx.types);
+        checkArguments(args, SELF.args, cx.language.types);
         ASSERT(LEN(args) = 2);
         x := args[0];
         y := args[1];
@@ -499,7 +516,7 @@ PROCEDURE incImpl(name: STRING; unary: STRING; incOp: BinaryOpStr; incRefOp: Ope
         valueCode: STRING;
     BEGIN
         checkVariableArgumentsCount(1, 2, args);
-        checkArgumentsType(args, SELF.args, NIL, cx.types);
+        checkArgumentsType(args, SELF.args, NIL, cx.language.types);
         x := args[0];
         IF Cast.passedByReference(x) THEN
             IF LEN(args) = 1 THEN
@@ -563,7 +580,7 @@ PROCEDURE makeAbs(): Symbols.PSymbol;
         arg: Expression.PType;
         argType: Types.PType;
     BEGIN
-        arg := checkSingleArgument(args, SELF, cx.types, NIL);
+        arg := checkSingleArgument(args, SELF, cx.language.types, NIL);
         argType := arg.type();
         IF Types.numeric.indexOf(argType) = -1 THEN
             Errors.raise("type mismatch: expected numeric type, got '"
@@ -586,7 +603,7 @@ PROCEDURE makeFloor(): Symbols.PSymbol;
     VAR
         arg: Expression.PType;
     BEGIN
-        arg := checkSingleArgument(args, SELF, cx.types, NIL);
+        arg := checkSingleArgument(args, SELF, cx.language.types, NIL);
         code <- Code.adjustPrecedence(arg, Precedence.bitOr) + " | 0";
         RETURN NEW Expression.Type(
             code,
@@ -612,7 +629,7 @@ PROCEDURE makeFlt(): Symbols.PSymbol;
         arg: Expression.PType;
         value: ConstValue.PType;
     BEGIN
-        arg := checkSingleArgument(args, SELF, cx.types, NIL);
+        arg := checkSingleArgument(args, SELF, cx.language.types, NIL);
         value := arg.constValue();
         IF value # NIL THEN
             value := NEW ConstValue.Real(FLT(value^(ConstValue.Int).value));
@@ -639,7 +656,7 @@ PROCEDURE bitShiftImpl(name: STRING; op: Operator.BinaryProc): Symbols.PSymbol;
 
     PROCEDURE CallImpl.make(args: ARRAY OF Expression.PType; cx: LanguageContext.PType): Expression.PType;
     BEGIN
-        checkArguments(args, SELF.args, cx.types);
+        checkArguments(args, SELF.args, cx.language.types);
         ASSERT(LEN(args) = 2);
         RETURN SELF.op(args[0], args[1])
     END CallImpl.make;
@@ -666,7 +683,7 @@ PROCEDURE makeOrd(): Symbols.PSymbol;
         ch: CHAR;
         result: Expression.PType;
     BEGIN
-        arg := checkSingleArgument(args, SELF, cx.types, NIL);
+        arg := checkSingleArgument(args, SELF, cx.language.types, NIL);
         argType := arg.type();
         IF (argType = Types.basic.ch) OR (argType = Types.basic.set) THEN
             value := arg.constValue();
@@ -712,7 +729,7 @@ PROCEDURE makeChr(): Symbols.PSymbol;
     VAR
         arg: Expression.PType;
     BEGIN
-        arg := checkSingleArgument(args, SELF, cx.types, NIL);
+        arg := checkSingleArgument(args, SELF, cx.language.types, NIL);
         RETURN Expression.makeSimple(arg.code(), Types.basic.ch)
     END CallImpl.make;
 BEGIN
@@ -730,7 +747,7 @@ PROCEDURE makePack(): Symbols.PSymbol;
     VAR
         x, y: Expression.PType;
     BEGIN
-        checkArguments(args, SELF.args, cx.types);
+        checkArguments(args, SELF.args, cx.language.types);
         x := args[0];
         y := args[1];
         RETURN Expression.makeSimple(
@@ -753,7 +770,7 @@ PROCEDURE makeUnpk(): Symbols.PSymbol;
     VAR
         x, y: Expression.PType;
     BEGIN
-        checkArguments(args, SELF.args, cx.types);
+        checkArguments(args, SELF.args, cx.language.types);
         x := args[0];
         y := args[1];
         RETURN Expression.makeSimple(
@@ -769,7 +786,7 @@ BEGIN
     RETURN makeSymbol(NEW Std("UNPK", call))
 END makeUnpk;
 
-PROCEDURE dumpProcArgs(proc: Type): STRING;
+PROCEDURE dumpProcArgs(proc: Defined): STRING;
 VAR
     result: STRING;
 BEGIN
@@ -791,9 +808,9 @@ BEGIN
         result := result + ")";
     END;
     RETURN result
-END dumpProcArgs;
+END;
 
-PROCEDURE Type.description(): STRING;
+PROCEDURE Defined.description(): STRING;
 VAR
     result: STRING;
 BEGIN
@@ -805,13 +822,13 @@ BEGIN
         END;
     END;
     RETURN result
-END Type.description;
+END;
 
-PROCEDURE Type.callGenerator(cx: LanguageContext.PType): PCallGenerator;
+PROCEDURE Defined.callGenerator(cx: LanguageContext.PType): PCallGenerator;
     RETURN makeProcCallGenerator(cx, SELF)
-END Type.callGenerator;
+END;
 
-PROCEDURE Type.define(args: ARRAY OF Types.PProcedureArgument; result: Types.PType);
+PROCEDURE Defined.define(args: ARRAY OF Types.PProcedureArgument; result: Types.PType);
 BEGIN
     FOR i <- 0 TO LEN(args) - 1 DO
         ASSERT(args[i].type # NIL);
@@ -821,15 +838,15 @@ BEGIN
         ASSERT(SELF.mArgs[i].type # NIL);
     END;
     SELF.mResult := result;
-END Type.define;
+END;
 
-PROCEDURE Type.args(): Types.ProcedureArguments;
+PROCEDURE Defined.args(): Types.ProcedureArguments;
     RETURN SELF.mArgs
-END Type.args;
+END;
 
-PROCEDURE Type.result(): Types.PType;
+PROCEDURE Defined.result(): Types.PType;
     RETURN SELF.mResult
-END Type.result;
+END;
 
 BEGIN
     predefined.add(makeNew());

src/ob/Types.ob

@@ -104,10 +104,6 @@ TYPE
     END;
     PStaticArray* = POINTER TO StaticArray;
 
-    Procedure* = RECORD(NamedType)
-        PROCEDURE designatorCode*(id: STRING): STRING
-    END;
-
     ProcedureArgument* = RECORD
         PROCEDURE ProcedureArgument*(type: PStorageType; isVar: BOOLEAN);
 
@@ -120,11 +116,11 @@ TYPE
     PProcedureArgument* = POINTER TO ProcedureArgument;
     ProcedureArguments* = ARRAY * OF PProcedureArgument;
 
-    DefinedProcedure* = RECORD(Procedure)
+    Procedure* = RECORD(NamedType)
         PROCEDURE args*(): ProcedureArguments;
-        PROCEDURE result*(): PType
+        PROCEDURE result*(): PType;
+        PROCEDURE designatorCode*(id: STRING): STRING
     END;
-    PDefinedProcedure* = POINTER TO DefinedProcedure;
 
     BasicType* = RECORD(NamedType)
         PROCEDURE BasicType*(name: STRING; initializer: STRING);
@@ -322,10 +318,6 @@ PROCEDURE Procedure.isScalar(): BOOLEAN;
     RETURN TRUE;
 END;
 
-PROCEDURE DefinedProcedure.designatorCode(id: STRING): STRING;
-    RETURN id
-END DefinedProcedure.designatorCode;
-
 PROCEDURE ProcedureArgument.description(): STRING;
 VAR
     result: STRING;

src/ob/Variable.ob

@@ -2,8 +2,8 @@ MODULE Variable;
 IMPORT
     OberonRtl, Types;
 TYPE
-    TypedVariable = RECORD(Types.Variable)
-        PROCEDURE TypedVariable(type: Types.PStorageType);
+    TypedVariable* = RECORD(Types.Variable)
+        PROCEDURE TypedVariable*(type: Types.PStorageType);
 
         mType: Types.PStorageType;
     END;

src/oberon/oberon_context.js

@@ -4,10 +4,13 @@ var Class = require("rtl.js").Class;
 var CodeGenerator = require("js/CodeGenerator.js");
 var Context = require("context.js");
 var ContextExpression = require("js/ContextExpression.js");
+var ContextHierarchy = require("js/ContextHierarchy.js");
+var ContextProcedure = require("js/ContextProcedure.js");
 var ContextType = require("js/ContextType.js");
 var ContextVar = require("js/ContextVar.js");
 var Errors = require("js/Errors.js");
 var Expression = require("js/Expression.js");
+var Module = require("js/Module.js");
 var op = require("js/Operator.js");
 var Record = require("js/Record.js");
 var Type = require("js/Types.js");
@@ -43,7 +46,7 @@ var ProcedureCall = Context.Chained.extend({
             var d = this.attributes.designator;
             this.__type = d.type();
             this.__id = d.code();
-            this.__procCall = Context.makeProcCall(this, this.__type, d.info());
+            this.__procCall = ContextProcedure.makeCall(this, this.__type, d.info());
             this.__callExpression = undefined;
         }
         return this.__procCall;
@@ -73,7 +76,7 @@ var StatementProcedureCall = ProcedureCall.extend({
     },
     endParse: function(){
         var e = this.callExpression();
-        Context.assertProcStatementResult(e.type());
+        Module.assertProcStatementResult(e.type());
         this.parent().codeGenerator().write(e.code());
     }
 });
@@ -107,7 +110,7 @@ var Assignment = Context.Chained.extend({
     handleExpression: function(e){
         var d = this.attributes.designator;
         var left = Expression.make(d.code(), d.type(), d);
-        this.parent().codeGenerator().write(op.assign(left, e, this.root().language()));
+        this.parent().codeGenerator().write(op.assign(left, e, ContextHierarchy.makeLanguageContext(this)));
     }
 });
 

src/oc.js

@@ -131,7 +131,7 @@ function compile(text, language, handleErrors){
                 return new ContextHierarchy.Root(
                     { codeGenerator: language.codeGenerator.make(),
                       moduleGenerator: moduleCode,
-                      rtl: function(){return rtl;},
+                      rtl: rtl,
                       types: language.types,
                       stdSymbols: language.stdSymbols,
                       moduleResolver: moduleResolver

test/test_unit_common.js

@@ -33,7 +33,7 @@ var TestContext = Class.extend.call(ContextHierarchy.Root, {
                 this,
                 { codeGenerator: language.codeGenerator.nil,
                   moduleGenerator: function(){return new TestModuleGenerator();},
-                  rtl: function(){return rtl;},
+                  rtl: rtl,
                   types: language.types,
                   stdSymbols: language.stdSymbols
                 });