expression parsing refactoring

src/eberon/EberonContextExpression.ob

@@ -20,23 +20,12 @@ TYPE
     END;
 
     Term* = RECORD(ContextExpression.Term)
-        PROCEDURE handleLogicalAnd();
-
-        typePromotion: EberonTypePromotion.PCombined;
-        currentPromotion: EberonTypePromotion.PMaybe;
-        andHandled: BOOLEAN;
     END;
     PTerm = POINTER TO Term;
 
     Factor* = RECORD(ContextExpression.Factor)
     END;
 
-    AddOperator* = RECORD(ContextExpression.AddOperator)
-    END;
-
-    MulOperator* = RECORD(ContextExpression.MulOperator)
-    END;
-
     Ops = RECORD(ExpressionTree.Ops)
     END;
 
@@ -55,7 +44,11 @@ TYPE
     PSimpleList = POINTER TO SimpleList;
 
     TermList = RECORD(ExpressionTree.TermList)
+        typePromotion: EberonTypePromotion.PCombined;
+        currentPromotion: EberonTypePromotion.PMaybe;
+        andHandled: BOOLEAN;
     END;
+    PTermList = POINTER TO TermList;
 
     ETFactor = RECORD(ExpressionTree.Factor)
         PROCEDURE ETFactor(cx: PTerm);
@@ -210,10 +203,11 @@ BEGIN
     RETURN e.currentPromotion;
 END;
 
-PROCEDURE setTermTypePromotion(VAR term: Term): EberonTypePromotion.PMaybe;
+PROCEDURE setTermTypePromotion(VAR cx: Term): EberonTypePromotion.PMaybe;
 BEGIN
+    term <- cx.list(PTermList);
     IF term.currentPromotion = NIL THEN
-        p <- setSimpleExpressionTypePromotion(term.parent()^(SimpleExpression));
+        p <- setSimpleExpressionTypePromotion(cx.parent()^(SimpleExpression));
         IF p # NIL THEN
             term.typePromotion := p.makeAnd();
         END;
@@ -249,8 +243,10 @@ BEGIN
     RETURN result;
 END;
 
-PROCEDURE Term.handleLogicalAnd();
+PROCEDURE TermList.addOp(op: STRING);
 BEGIN
+    SUPER(op);
+
     IF SELF.typePromotion # NIL THEN
         SELF.currentPromotion := SELF.typePromotion.next();
     ELSE
@@ -274,12 +270,6 @@ PROCEDURE Ops.plusExpect(): STRING;
     RETURN "numeric type or SET or STRING";
 END;
 
-PROCEDURE MulOperator.endParse(): BOOLEAN;
-BEGIN
-    SELF.parent()^(Term).handleLogicalAnd();
-    RETURN TRUE;
-END;
-
 PROCEDURE Ops.eq(type: Types.PType): ExpressionTree.BinaryOperatorCx;
 VAR
     result: ExpressionTree.BinaryOperatorCx;

src/eberon/eberon_grammar.js

@@ -170,8 +170,6 @@ exports.language = {
             FormalParameters:   EberonContextProcedure.FormalParameters,
             FormalType:         EberonContextType.FormalType,
             Term:               EberonContextExpression.Term,
-            AddOperator:        EberonContextExpression.AddOperator,
-            MulOperator:        EberonContextExpression.MulOperator,
             SimpleExpression:   EberonContextExpression.SimpleExpression, 
             For:                EberonContextLoop.For,
             While:              EberonContextLoop.While,

src/grammar.js

@@ -92,8 +92,8 @@ var factor = context(
      )
     , contexts.Factor);
 
-var addOperator = context(or("+", "-", "OR"), contexts.AddOperator);
-var mulOperator = context(or("*", "/", "DIV", "MOD", "&"), contexts.MulOperator);
+var addOperator = context(or("+", "-", "OR"), ContextExpression.AddOperator);
+var mulOperator = context(or("*", "/", "DIV", "MOD", "&"), ContextExpression.MulOperator);
 var term = context(and(factor, repeat(and(mulOperator, factor))), contexts.Term);
 var simpleExpression = context(
         and(optional(or("+", "-"))

src/ob/ContextExpression.ob

@@ -35,7 +35,7 @@ TYPE
     Term* = RECORD(ContextHierarchy.Node)
         PROCEDURE Term*(parent: ContextHierarchy.PNode); 
 
-        list: ExpressionTree.PTermList;
+        list-: ExpressionTree.PTermList;
     END;
     PTerm = POINTER TO Term;
 

src/oberon/oberon_grammar.js

@@ -131,8 +131,6 @@ exports.language = {
             FormalParameters:   ContextProcedure.FormalParameters,
             FormalType:         ContextType.FormalType,
             Term:               ContextExpression.Term,
-            AddOperator:        ContextExpression.AddOperator,
-            MulOperator:        ContextExpression.MulOperator,
             SimpleExpression:   ContextExpression.SimpleExpression, 
             For:                ContextLoop.For,
             While:              ContextLoop.While,