expression parsing refactoring

build.py

@@ -129,7 +129,7 @@ def recompile(bin, cwd):
     sources = ['ContextAssignment.ob', 
                'EberonSymbols.ob', 
                'EberonContextCase.ob', 'EberonContextExpression.ob', 'EberonContextIdentdef.ob', 
-               'EberonContextIf.ob', 'EberonContextInPlace.ob', 'EberonContextType.ob', 
+               'EberonContextIf.ob', 'EberonContextInPlace.ob', 'EberonContextProcedure', 'EberonContextType.ob', 
                'EberonContextVar.ob', 'EberonLanguageContext.ob',
                'OberonContext.ob', 'OberonContextType.ob', 'OberonContextVar.ob',
                'OberonSymbols.ob', 'Lexer.ob', 'Module.ob']

src/eberon/EberonContextExpression.ob

@@ -2,7 +2,7 @@ MODULE EberonContextExpression;
 IMPORT
     Cast,
     Context, ContextExpression, ContextHierarchy, 
-    EberonContextDesignator, EberonContextProcedure, 
+    EberonContextDesignator, 
     EberonMap, EberonOperator, EberonString, EberonTypePromotion, 
     Errors, Expression, ExpressionTree, LanguageContext,
     JS,
@@ -29,34 +29,51 @@ TYPE
     Ops = RECORD(ExpressionTree.Ops)
     END;
 
-    Node = RECORD(ExpressionTree.Node)
-        PROCEDURE Node();
+    PSimpleList = POINTER TO SimpleList;
 
-        currentTypePromotion: EberonTypePromotion.PCombined;
+    TermList = RECORD(ExpressionTree.TermList)
+        PROCEDURE TermList(parentSimple: PSimpleList);
+
+        parentSimple: PSimpleList;
+
+        typePromotion: EberonTypePromotion.PCombined;
+        currentPromotion: EberonTypePromotion.PMaybe;
+        andHandled: BOOLEAN;
     END;
-    PNode = POINTER TO Node;
+    PTermList = POINTER TO TermList;
 
     SimpleList = RECORD(ExpressionTree.SimpleList)
+        PROCEDURE SimpleList(parentTerm: PTermList);
+
+        parentTerm: PTermList;
+
         typePromotion: EberonTypePromotion.PCombined;
         currentPromotion: EberonTypePromotion.PMaybe;
         orHandled: BOOLEAN;
     END;
-    PSimpleList = POINTER TO SimpleList;
 
-    TermList = RECORD(ExpressionTree.TermList)
-        typePromotion: EberonTypePromotion.PCombined;
-        currentPromotion: EberonTypePromotion.PMaybe;
-        andHandled: BOOLEAN;
+    Node = RECORD(ExpressionTree.Node)
+        PROCEDURE Node(parentTerm: PTermList);
+
+        parentTerm: PTermList;
+        currentTypePromotion: EberonTypePromotion.PCombined;
     END;
-    PTermList = POINTER TO TermList;
+    PNode = POINTER TO Node;
 
     ETFactor = RECORD(ExpressionTree.Factor)
-        PROCEDURE ETFactor(cx: PTerm);
+        PROCEDURE ETFactor(termList: PTermList);
 
-        cx: PTerm;
+        termList: PTermList;
     END;
 
+    ExpressionTypePromotion* = RECORD(ContextHierarchy.Message)
+        PROCEDURE ExpressionTypePromotion(typePromotion: EberonTypePromotion.PType);
+
+        typePromotion-: EberonTypePromotion.PType;
+    END;         
+
 VAR
+    setTermTypePromotion: PROCEDURE(VAR term: TermList): EberonTypePromotion.PMaybe;
     globalOps: POINTER TO Ops;
 
 PROCEDURE hierarchyDepth(t: Record.Type): INTEGER;
@@ -148,8 +165,19 @@ BEGIN
     RETURN TRUE;
 END;
 
+PROCEDURE parentTerm(VAR cx: ContextHierarchy.Node): PTermList;
+VAR
+    result: PTermList;
+BEGIN
+    maybeFactor <- cx.parent();
+    IF maybeFactor^ IS ContextExpression.Factor THEN
+        result := maybeFactor.factor^(ETFactor).termList;
+    END;
+    RETURN result;
+END;
+
 PROCEDURE RelationExpression.RelationExpression(parent: ContextExpression.PExpressionHandler)
-    | SUPER(parent, NEW Node());
+    | SUPER(parent, NEW Node(parentTerm(parent^)));
 END;
 
 PROCEDURE RelationExpression.handleMessage(VAR msg: ContextHierarchy.Message): Object.PType;
@@ -186,13 +214,28 @@ BEGIN
     RETURN SUPER();
 END;
 
-PROCEDURE setSimpleExpressionTypePromotion(VAR s: SimpleExpression): EberonTypePromotion.PMaybe;
+PROCEDURE SimpleExpression.endParse(): BOOLEAN;
+BEGIN
+    s <- SELF.list(PSimpleList);
+    IF (s.parentTerm = NIL) & (s.typePromotion # NIL) THEN 
+        msg <- ExpressionTypePromotion(s.typePromotion);
+        void <- SELF.parent().handleMessage(msg);
+    END;
+    RETURN SUPER();
+END;
+
+PROCEDURE setSimpleExpressionTypePromotion(VAR e: SimpleList): EberonTypePromotion.PMaybe;
 BEGIN
-    e <- s.list(PSimpleList);
     IF e.currentPromotion = NIL THEN
-        msg <- EberonContextProcedure.BeginTypePromotionOrMsg();
-        void <- s.parent().handleMessage(msg);
-        e.typePromotion := msg.result;
+        IF e.parentTerm # NIL THEN
+            p <- setTermTypePromotion(e.parentTerm^);
+            IF p # NIL THEN
+                e.typePromotion := p.makeOr();
+            END;
+        ELSE
+            e.typePromotion := NEW EberonTypePromotion.Or(FALSE);
+        END;
+
         IF e.typePromotion # NIL THEN
             IF e.orHandled THEN
                 unused <- e.typePromotion.next();
@@ -203,11 +246,10 @@ BEGIN
     RETURN e.currentPromotion;
 END;
 
-PROCEDURE setTermTypePromotion(VAR cx: Term): EberonTypePromotion.PMaybe;
+PROCEDURE setTermTypePromotionProc(VAR term: TermList): EberonTypePromotion.PMaybe;
 BEGIN
-    term <- cx.list(PTermList);
     IF term.currentPromotion = NIL THEN
-        p <- setSimpleExpressionTypePromotion(cx.parent()^(SimpleExpression));
+        p <- setSimpleExpressionTypePromotion(term.parentSimple^);
         IF p # NIL THEN
             term.typePromotion := p.makeAnd();
         END;
@@ -228,15 +270,10 @@ VAR
 BEGIN
     IF msg IS EberonContextDesignator.PromoteTypeMsg THEN
         promoted <- msg.info;
-        p <- setTermTypePromotion(SELF);
+        p <- setTermTypePromotion(SELF.list^(TermList));
         IF p # NIL THEN
             p.promote(promoted, msg.type);
         END;
-    ELSIF msg IS EberonContextProcedure.BeginTypePromotionOrMsg THEN
-        p <- setTermTypePromotion(SELF);
-        IF p # NIL THEN
-            msg.result := p.makeOr();
-        END;
     ELSE
         result := SUPER(msg);
     END;
@@ -380,12 +417,13 @@ BEGIN
     RETURN result;
 END;
 
-PROCEDURE Node.Node()
-    | SUPER(globalOps);
+PROCEDURE Node.Node(parentTerm: PTermList)
+    | SUPER(globalOps),
+      parentTerm(parentTerm);
 END;
 
 PROCEDURE Node.makeSimple(): ExpressionTree.PSimpleList;
-    RETURN NEW SimpleList();
+    RETURN NEW SimpleList(SELF.parentTerm);
 END;
 
 PROCEDURE Node.addSimple(s: ExpressionTree.PSimpleList);
@@ -407,8 +445,12 @@ BEGIN
     SUPER(op);
 END;
 
+PROCEDURE SimpleList.SimpleList(parentTerm: PTermList)
+    | parentTerm(parentTerm);
+END;
+
 PROCEDURE SimpleList.makeTerm(): ExpressionTree.PTermList;
-    RETURN NEW TermList();
+    RETURN NEW TermList(SELF(POINTER));
 END;
 
 PROCEDURE SimpleList.addOp(op: STRING);
@@ -422,24 +464,35 @@ BEGIN
     END;
 END;
 
-PROCEDURE TermList.makeFactor(cx: ContextHierarchy.PNode): ExpressionTree.PFactor;
-    RETURN NEW ETFactor(cx(PTerm));
+PROCEDURE TermList.TermList(parentSimple: PSimpleList)
+    | parentSimple(parentSimple);
+END;
+
+PROCEDURE TermList.makeFactor(): ExpressionTree.PFactor;
+    RETURN NEW ETFactor(SELF(POINTER));
 END;
 
-PROCEDURE ETFactor.ETFactor(cx: PTerm)
-    | cx(cx);
+PROCEDURE ETFactor.ETFactor(termList: PTermList)
+    | termList(termList);
 END;
 
 PROCEDURE ETFactor.logicalNot();
 BEGIN
     SUPER();
 
-    p <- setTermTypePromotion(SELF.cx^);
+    p <- setTermTypePromotion(SELF.termList^);
     IF p # NIL THEN
         p.invert()
     END;
 END;
 
+PROCEDURE ExpressionTypePromotion.ExpressionTypePromotion(typePromotion: EberonTypePromotion.PType)
+    | typePromotion(typePromotion);
+END;
+
 BEGIN
+    (*resolve recursive calls*)
+    setTermTypePromotion := setTermTypePromotionProc;
+    
     NEW(globalOps);
 END EberonContextExpression.

src/eberon/EberonContextProcedure.ob

@@ -3,8 +3,8 @@ IMPORT
     Chars, CodeGenerator,
     Context, ContextDesignator, ContextExpression, ContextHierarchy, ContextModule, 
     ContextProcedure, ContextType, 
-    EberonConstructor, EberonContext, EberonContextDesignator, 
-    EberonDynamicArray, EberonMap, EberonRecord, EberonTypePromotion, EberonTypes,
+    EberonConstructor, EberonContext, EberonContextDesignator, EberonContextExpression, 
+    EberonDynamicArray, EberonMap, EberonRecord, EberonTypes,
     Errors, Expression, ExpressionTree, LanguageContext, Object, Procedure, Record, Types, Variable;
 TYPE
     ProcOrMethodDeclaration* = RECORD(ContextProcedure.Declaration)
@@ -62,10 +62,6 @@ TYPE
         type: EberonRecord.PRecord;
     END;
 
-    BeginTypePromotionOrMsg* = RECORD(ContextHierarchy.Message)
-        result*: EberonTypePromotion.PCombined;
-    END;
-
 PROCEDURE superMethodCallGenerator(cx: LanguageContext.PType; type: Procedure.Type): Procedure.PCallGenerator;
 BEGIN
     args <- Procedure.makeArgumentsCode(cx);
@@ -119,8 +115,7 @@ BEGIN
     result <- FALSE;
     IF EberonContextDesignator.breakTypePromotion(msg) THEN
         result := TRUE;
-    ELSIF msg IS BeginTypePromotionOrMsg THEN
-        msg.result := NEW EberonTypePromotion.Or(FALSE);
+    ELSIF msg IS EberonContextExpression.ExpressionTypePromotion THEN
         result := TRUE;
     END
     RETURN result;

src/eberon/EberonContextTypePromotion.ob

@@ -1,7 +1,7 @@
 MODULE EberonContextTypePromotion;
 IMPORT
     ContextHierarchy, 
-    EberonContextDesignator, EberonContextProcedure,
+    EberonContextDesignator, EberonContextExpression,
     EberonTypePromotion;
 TYPE
     Type* = RECORD
@@ -27,11 +27,9 @@ BEGIN
         SELF.typePromotion := NEW EberonTypePromotion.ForVariable(msg.info, msg.type, FALSE);
         SELF.typePromotions.add(SELF.typePromotion);
         result := TRUE;
-    ELSIF msg IS EberonContextProcedure.BeginTypePromotionOrMsg THEN
-        tp <- NEW EberonTypePromotion.Or(FALSE);
-        SELF.typePromotion := tp;
-        SELF.typePromotions.add(tp);
-        msg.result := tp;
+    ELSIF msg IS EberonContextExpression.ExpressionTypePromotion THEN
+        SELF.typePromotion := msg.typePromotion;
+        SELF.typePromotions.add(SELF.typePromotion);
         result := TRUE;
     END;
     RETURN result;

src/ob/ContextExpression.ob

@@ -29,7 +29,7 @@ TYPE
     Factor* = RECORD(ExpressionHandler)
         PROCEDURE Factor*(parent: ContextHierarchy.PNode);
 
-        factor: ExpressionTree.PFactor;
+        factor-: ExpressionTree.PFactor;
     END;
 
     Term* = RECORD(ContextHierarchy.Node)
@@ -139,7 +139,7 @@ BEGIN
     IF parent^ IS Factor THEN
         SELF.factor := parent.factor;
     ELSE
-        SELF.factor := parent^(Term).list.makeFactor(parent);
+        SELF.factor := parent^(Term).list.makeFactor();
     END;
 END; 
 

src/ob/ExpressionTree.ob

@@ -48,7 +48,7 @@ TYPE
     END;
 
     TermList* = RECORD (TermItem)
-        PROCEDURE makeFactor*(cx: ContextHierarchy.PNode): PFactor;
+        PROCEDURE makeFactor*(): PFactor;
         PROCEDURE addFactor*(f: PFactor);
         PROCEDURE addOp*(op: STRING);
 
@@ -721,7 +721,7 @@ PROCEDURE ItemOp.ItemOp(op: STRING)
     | op(op);
 END;
 
-PROCEDURE TermList.makeFactor(cx: ContextHierarchy.PNode): PFactor;
+PROCEDURE TermList.makeFactor(): PFactor;
     RETURN NEW Factor();
 END;