js -> eberon transition

src/context.js

@@ -766,7 +766,7 @@ exports.AddOperator = ChainedContext.extend({
         var type = parent.type();
         var o = this.__matchOperator(s, type);
         if (o)
-            parent.handleBinaryOperator(o);
+            parent.handleOperator(o);
     },
     __matchOperator: function(s, type){
         var result;
@@ -880,48 +880,6 @@ exports.SetElement = ChainedContext.extend({
     }
 });
 
-exports.SimpleExpression = ChainedContext.extend({
-    init: function SimpleExpressionContext(context){
-        ChainedContext.prototype.init.call(this, context);
-        this.__unaryOperator = undefined;
-        this.__binaryOperator = undefined;
-        this.__type = undefined;
-        this.__exp = undefined;
-    },
-    handleTerm: function(e){
-        var type = e.type();
-        this.setType(type);
-
-        var o;
-        switch(this.__unaryOperator){
-            case "-":
-                o = ContextExpression.assertNumericOrSetOp(type, this.__unaryOperator, op.negateReal, op.negateInt, op.setComplement);
-                break;
-            case "+":
-                o = ContextExpression.assertNumericOp(type, this.__unaryOperator, op.unaryPlus);
-                break;
-            }
-        if (o){
-            this.__exp = o(e);
-            this.__unaryOperator = undefined;
-        }
-        else
-            this.__exp = this.__exp ? this.__binaryOperator(this.__exp, e) : e;
-    },
-    handleLiteral: function(s){this.__unaryOperator = s;},
-    type: function(){return this.__type;},
-    setType: function(type){
-        if (type === undefined || this.__type === undefined)
-            this.__type = type;
-        else
-            ContextHierarchy.checkImplicitCast(this.root(), type, this.__type);
-    },
-    handleBinaryOperator: function(o){this.__binaryOperator = o;},
-    endParse: function(){
-        this.parent().handleSimpleExpression(this.__exp);
-    }
-});
-
 exports.Expression = ChainedContext.extend({
     init: function ExpressionContext(context, relOps){
         ChainedContext.prototype.init.call(this, context);

src/eberon/eberon_context.js

@@ -970,9 +970,9 @@ var Term = Class.extend.call(ContextExpression.Term, {
     }
 });
 
-var SimpleExpression = Context.SimpleExpression.extend({
+var SimpleExpression = Class.extend.call(ContextExpression.SimpleExpression, {
     init: function EberonContext$SimpleExpression(context){
-        Context.SimpleExpression.prototype.init.call(this, context);
+        ContextExpression.SimpleExpression.call(this, context);
         this.__typePromotion = undefined;
         this.__currentTypePromotion = undefined;
         this.__orHandled = false;
@@ -990,12 +990,12 @@ var SimpleExpression = Context.SimpleExpression.extend({
                 msg.result = p.makeAnd();
             return;
         }
-        return Context.SimpleExpression.prototype.handleMessage.call(this, msg);
+        return ContextExpression.SimpleExpression.prototype.handleMessage.call(this, msg);
     },
     endParse: function(){
         if (this.__typePromotion)
             this.parent().handleTypePromotion(this.__typePromotion);
-        Context.SimpleExpression.prototype.endParse.call(this);
+        ContextExpression.SimpleExpression.prototype.endParse.call(this);
     },
     __getCurrentPromotion: function(){
         if (!this.__currentPromotion){

src/ob/ContextExpression.ob

@@ -4,13 +4,30 @@ IMPORT
 TYPE
     ExpressionHandler = RECORD(ContextHierarchy.Node)
         PROCEDURE handleExpression(e: Code.PExpression);
-        PROCEDURE endParse();
 
         expression: Code.PExpression;
     END;
 
-    SimpleExpression = RECORD(ContextHierarchy.Node)
+    BinaryOperator = PROCEDURE(l, r: Code.PExpression): Code.PExpression;
+
+    Expression = RECORD(ContextHierarchy.Node)
+        PROCEDURE handleSimpleExpression(e: Code.PExpression);
+    END;
+    PExpression = POINTER TO Expression;
+
+    SimpleExpression* = RECORD(ContextHierarchy.Node)
+        PROCEDURE SimpleExpression(parent: PExpression);
+
         PROCEDURE handleTerm(e: Code.PExpression);
+        PROCEDURE type(): Types.PType;
+        PROCEDURE setType(type: Types.PType);
+        PROCEDURE handleOperator(op: BinaryOperator);
+
+        parentExpression: PExpression;  
+        mType: Types.PType;
+        unaryOperator: STRING;
+        binaryOperator: BinaryOperator;
+        expression: Code.PExpression;
     END;
     PSimpleExpression = POINTER TO SimpleExpression;
 
@@ -26,8 +43,6 @@ TYPE
         logicalNot: BOOLEAN;
     END;
 
-    BinaryOperator = PROCEDURE(l, r: Code.PExpression): Code.PExpression;
-
     Term* = RECORD(ExpressionHandler)
         PROCEDURE Term(parent: PSimpleExpression);
 
@@ -79,6 +94,120 @@ VAR
     numericOpTypeCheck: NumericOpTypeCheck;
     numericOrSetOpTypeCheck: NumericOrSetOpTypeCheck;
 
+PROCEDURE throwOperatorTypeMismatch*(op, expect: STRING; type: Types.PType);
+BEGIN
+    Errors.raise(
+        "operator '" + op +
+        "' type mismatch: " + expect + " expected, got '" +
+        type.description() + "'");
+END;
+
+PROCEDURE assertOpType(type: Types.PType; check: OpTypeCheck; literal: STRING);
+BEGIN
+    IF ~check.check(type) THEN
+        throwOperatorTypeMismatch(literal, check.expect(), type);
+    END;
+END;
+
+PROCEDURE assertNumericOp*(type: Types.PType; literal: STRING; op, intOp: BinaryOperator): BinaryOperator;
+VAR
+    result: BinaryOperator;
+BEGIN
+    assertOpType(type, numericOpTypeCheck, literal);
+    IF (intOp # NIL) & Types.isInt(type) THEN
+        result := intOp;
+    ELSE
+        result := op;
+    END;
+    RETURN result;
+END;
+
+PROCEDURE assertNumericOrSetOp*(type: Types.PType; literal: STRING; op: BinaryOperator; intOp, setOp: BinaryOperator): BinaryOperator;
+VAR
+    result: BinaryOperator;
+BEGIN
+    assertOpType(type, numericOrSetOpTypeCheck, literal);
+    IF Types.isInt(type) THEN
+        result := intOp;
+    ELSIF type = Types.basic.set THEN
+        result := setOp;
+    ELSE
+        result := op;
+    END;
+    RETURN result;
+END;
+
+PROCEDURE assertIntOp(type: Types.PType; literal: STRING; op: BinaryOperator): BinaryOperator;
+BEGIN
+    assertOpType(type, intOpTypeCheck, literal);
+    RETURN op;
+END;
+
+PROCEDURE SimpleExpression.SimpleExpression(parent: PExpression)
+    | SUPER(parent),
+      parentExpression(parent);
+END;
+
+PROCEDURE SimpleExpression.handleTerm(e: Code.PExpression);
+VAR
+    o: PROCEDURE(e: Code.PExpression): Code.PExpression;
+BEGIN
+    type <- e.type();
+    SELF.setType(type);
+    
+    IF SELF.unaryOperator = "-" THEN
+        IF Types.isInt(type) THEN
+            o := Operator.negateInt;
+        ELSIF type = Types.basic.set THEN
+            o := Operator.setComplement;
+        ELSIF type = Types.basic.real THEN
+            o := Operator.negateReal;
+        ELSE
+            throwOperatorTypeMismatch(SELF.unaryOperator, numericOrSetOpTypeCheck.expect(), type);
+        END;
+    ELSIF SELF.unaryOperator = "+" THEN
+        assertOpType(type, numericOpTypeCheck, SELF.unaryOperator);
+        o := Operator.unaryPlus;
+    END;
+
+    IF o # NIL THEN
+        SELF.expression := o(e);
+        SELF.unaryOperator := "";
+    ELSIF SELF.expression # NIL THEN
+        SELF.expression := SELF.binaryOperator(SELF.expression, e);
+    ELSE
+        SELF.expression := e;
+    END;
+END;
+
+PROCEDURE SimpleExpression.handleLiteral(s: STRING);
+BEGIN
+    SELF.unaryOperator := s;
+END;
+
+PROCEDURE SimpleExpression.type(): Types.PType;
+    RETURN SELF.mType;
+END;
+
+PROCEDURE SimpleExpression.setType(type: Types.PType);
+BEGIN
+    IF (type = NIL) OR (SELF.mType = NIL) THEN
+        SELF.mType := type;
+    ELSE
+        ContextHierarchy.checkImplicitCast(SELF.root()^, type, SELF.mType);
+    END;
+END;
+
+PROCEDURE SimpleExpression.handleOperator(o: BinaryOperator);
+BEGIN
+    SELF.binaryOperator := o;
+END;
+
+PROCEDURE SimpleExpression.endParse();
+BEGIN
+    SELF.parentExpression.handleSimpleExpression(SELF.expression);
+END;
+
 PROCEDURE Factor.Factor(parent: PFactor)
     | SUPER(parent),
       factorParent(parent);
@@ -172,55 +301,6 @@ BEGIN
     SELF.simpleExpression.handleTerm(e);
 END;
 
-PROCEDURE throwOperatorTypeMismatch*(op, expect: STRING; type: Types.PType);
-BEGIN
-    Errors.raise(
-        "operator '" + op +
-        "' type mismatch: " + expect + " expected, got '" +
-        type.description() + "'");
-END;
-
-PROCEDURE assertOpType(type: Types.PType; check: OpTypeCheck; literal: STRING);
-BEGIN
-    IF ~check.check(type) THEN
-        throwOperatorTypeMismatch(literal, check.expect(), type);
-    END;
-END;
-
-PROCEDURE assertNumericOp*(type: Types.PType; literal: STRING; op, intOp: BinaryOperator): BinaryOperator;
-VAR
-    result: BinaryOperator;
-BEGIN
-    assertOpType(type, numericOpTypeCheck, literal);
-    IF (intOp # NIL) & Types.isInt(type) THEN
-        result := intOp;
-    ELSE
-        result := op;
-    END;
-    RETURN result;
-END;
-
-PROCEDURE assertNumericOrSetOp*(type: Types.PType; literal: STRING; op: BinaryOperator; intOp, setOp: BinaryOperator): BinaryOperator;
-VAR
-    result: BinaryOperator;
-BEGIN
-    assertOpType(type, numericOrSetOpTypeCheck, literal);
-    IF Types.isInt(type) THEN
-        result := intOp;
-    ELSIF type = Types.basic.set THEN
-        result := setOp;
-    ELSE
-        result := op;
-    END;
-    RETURN result;
-END;
-
-PROCEDURE assertIntOp(type: Types.PType; literal: STRING; op: BinaryOperator): BinaryOperator;
-BEGIN
-    assertOpType(type, intOpTypeCheck, literal);
-    RETURN op;
-END;
-
 PROCEDURE MulOperator.handleLiteral(s: STRING);
 VAR
     o: BinaryOperator;

src/ob/ContextHierarchy.ob

@@ -30,6 +30,7 @@ TYPE
         PROCEDURE qualifyScope(scope: Scope.PType): STRING;
         PROCEDURE handleLiteral*(s: STRING);
         PROCEDURE genTypeName(): STRING;
+        PROCEDURE endParse*();
 
         mParent: PNode;
         attributes*: Attributes;

src/ob/Operator.ob

@@ -683,7 +683,7 @@ PROCEDURE not*(x: Code.PExpression): Code.PExpression;
     RETURN unary(x, opNot, "!")
 END not;
 
-PROCEDURE negateInt*(x: Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
+PROCEDURE negateInt*(x: Code.PExpression): Code.PExpression;
 VAR
     result: Code.PExpression;
 BEGIN
@@ -699,15 +699,15 @@ BEGIN
     RETURN result;
 END;
 
-PROCEDURE negateReal*(x: Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
+PROCEDURE negateReal*(x: Code.PExpression): Code.PExpression;
     RETURN promoteToWideIfNeeded(unary(x, opNegateReal, "-"))
 END negateReal;
 
-PROCEDURE unaryPlus*(x: Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
+PROCEDURE unaryPlus*(x: Code.PExpression): Code.PExpression;
     RETURN unary(x, opUnaryPlus, "")
 END unaryPlus;
 
-PROCEDURE setComplement*(x: Code.PExpression; cx: LanguageContext.PType): Code.PExpression;
+PROCEDURE setComplement*(x: Code.PExpression): Code.PExpression;
     RETURN unary(x, opSetComplement, "~")
 END setComplement;
 

src/oberon/oberon_grammar.js

@@ -116,7 +116,7 @@ exports.language = {
             Term:               ContextExpression.Term,
             AddOperator:        Context.AddOperator,
             MulOperator:        ContextExpression.MulOperator,
-            SimpleExpression:   Context.SimpleExpression, 
+            SimpleExpression:   ContextExpression.SimpleExpression, 
             Expression:         Context.Expression,
             For:                Context.For,
             While:              Context.While,