X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.scl.compiler%2Fsrc%2Forg%2Fsimantics%2Fscl%2Fcompiler%2Felaboration%2Fexpressions%2Fprinting%2FExpressionToStringVisitor.java;fp=bundles%2Forg.simantics.scl.compiler%2Fsrc%2Forg%2Fsimantics%2Fscl%2Fcompiler%2Felaboration%2Fexpressions%2Fprinting%2FExpressionToStringVisitor.java;h=c5f8f3621187b02caf6e19b4437071bddbd4105c;hb=969bd23cab98a79ca9101af33334000879fb60c5;hp=0000000000000000000000000000000000000000;hpb=866dba5cd5a3929bbeae85991796acb212338a08;p=simantics%2Fplatform.git

diff --git a/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/expressions/printing/ExpressionToStringVisitor.java b/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/expressions/printing/ExpressionToStringVisitor.java
new file mode 100644
index 000000000..c5f8f3621
--- /dev/null
+++ b/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/expressions/printing/ExpressionToStringVisitor.java
@@ -0,0 +1,497 @@
+package org.simantics.scl.compiler.elaboration.expressions.printing;
+
+import java.util.Map.Entry;
+
+import org.simantics.scl.compiler.elaboration.expressions.Assignment;
+import org.simantics.scl.compiler.elaboration.expressions.Case;
+import org.simantics.scl.compiler.elaboration.expressions.EApply;
+import org.simantics.scl.compiler.elaboration.expressions.EApplyType;
+import org.simantics.scl.compiler.elaboration.expressions.EAsPattern;
+import org.simantics.scl.compiler.elaboration.expressions.EBind;
+import org.simantics.scl.compiler.elaboration.expressions.EConstant;
+import org.simantics.scl.compiler.elaboration.expressions.EEnforce;
+import org.simantics.scl.compiler.elaboration.expressions.EEquations;
+import org.simantics.scl.compiler.elaboration.expressions.EError;
+import org.simantics.scl.compiler.elaboration.expressions.EExternalConstant;
+import org.simantics.scl.compiler.elaboration.expressions.EFieldAccess;
+import org.simantics.scl.compiler.elaboration.expressions.EGetConstraint;
+import org.simantics.scl.compiler.elaboration.expressions.EIf;
+import org.simantics.scl.compiler.elaboration.expressions.EIntegerLiteral;
+import org.simantics.scl.compiler.elaboration.expressions.ELambda;
+import org.simantics.scl.compiler.elaboration.expressions.ELambdaType;
+import org.simantics.scl.compiler.elaboration.expressions.ELet;
+import org.simantics.scl.compiler.elaboration.expressions.EListComprehension;
+import org.simantics.scl.compiler.elaboration.expressions.EListLiteral;
+import org.simantics.scl.compiler.elaboration.expressions.ELiteral;
+import org.simantics.scl.compiler.elaboration.expressions.EMatch;
+import org.simantics.scl.compiler.elaboration.expressions.EPlaceholder;
+import org.simantics.scl.compiler.elaboration.expressions.ECoveringBranchPoint;
+import org.simantics.scl.compiler.elaboration.expressions.ERealLiteral;
+import org.simantics.scl.compiler.elaboration.expressions.ERuleset;
+import org.simantics.scl.compiler.elaboration.expressions.ESelect;
+import org.simantics.scl.compiler.elaboration.expressions.ESimpleLambda;
+import org.simantics.scl.compiler.elaboration.expressions.ESimpleLet;
+import org.simantics.scl.compiler.elaboration.expressions.ETransformation;
+import org.simantics.scl.compiler.elaboration.expressions.ETypeAnnotation;
+import org.simantics.scl.compiler.elaboration.expressions.EVariable;
+import org.simantics.scl.compiler.elaboration.expressions.EWhen;
+import org.simantics.scl.compiler.elaboration.expressions.Expression;
+import org.simantics.scl.compiler.elaboration.expressions.ExpressionVisitor;
+import org.simantics.scl.compiler.elaboration.expressions.GuardedExpression;
+import org.simantics.scl.compiler.elaboration.expressions.GuardedExpressionGroup;
+import org.simantics.scl.compiler.elaboration.expressions.Variable;
+import org.simantics.scl.compiler.elaboration.java.EqRelation;
+import org.simantics.scl.compiler.elaboration.java.MemberRelation;
+import org.simantics.scl.compiler.elaboration.query.QAlternative;
+import org.simantics.scl.compiler.elaboration.query.QAtom;
+import org.simantics.scl.compiler.elaboration.query.QConjunction;
+import org.simantics.scl.compiler.elaboration.query.QDisjunction;
+import org.simantics.scl.compiler.elaboration.query.QExists;
+import org.simantics.scl.compiler.elaboration.query.QIf;
+import org.simantics.scl.compiler.elaboration.query.QMapping;
+import org.simantics.scl.compiler.elaboration.query.QNegation;
+import org.simantics.scl.compiler.elaboration.query.Query;
+import org.simantics.scl.compiler.elaboration.query.QueryVisitor;
+import org.simantics.scl.compiler.elaboration.rules.SectionName;
+import org.simantics.scl.compiler.elaboration.rules.TransformationRule;
+
+public class ExpressionToStringVisitor implements ExpressionVisitor, QueryVisitor {
+
+    StringBuilder b = new StringBuilder();
+    int indentation;
+    
+    public ExpressionToStringVisitor(StringBuilder b) {
+        this.b = b;
+    }
+
+    public void show(Variable variable) {
+        if(variable == null)
+            b.append("NULL_VARIABLE");
+        else
+            b.append(variable.getName());
+    }
+    
+    private void newLine() {
+        b.append('\n');
+        for(int i=0;i<indentation;++i)
+            b.append("  ");
+    }
+    
+    public void showPar(Expression expression) {
+        boolean needsPar = false;
+        while(true) {
+            if(expression instanceof EPlaceholder)
+                expression = ((EPlaceholder)expression).expression;
+            else if(expression instanceof ETypeAnnotation)
+                expression = ((ETypeAnnotation)expression).getValue();
+            else if(expression instanceof EApplyType)
+                expression = ((EApplyType)expression).getExpression();
+            else if(expression instanceof ELambdaType)
+                expression = ((ELambdaType)expression).value;
+            else if(expression instanceof ECoveringBranchPoint)
+                expression = ((ECoveringBranchPoint)expression).expression;
+            else
+                break;
+        }
+        if(expression instanceof EApply ||
+                expression instanceof EIf ||
+                expression instanceof ESimpleLambda ||
+                expression instanceof ESimpleLet)
+            needsPar = true;
+        if(needsPar)
+            b.append('(');
+        expression.accept(this);
+        if(needsPar)
+            b.append(')');
+    }
+    
+    @Override
+    public void visit(EApply expression) {
+        showPar(expression.getFunction());
+        for(Expression parameter : expression.getParameters()) {
+            b.append(' ');
+            showPar(parameter);
+        }
+    }
+
+    @Override
+    public void visit(EApplyType expression) {
+        expression.getExpression().accept(this);
+    }
+
+    @Override
+    public void visit(EAsPattern expression) {
+        show(expression.getVariable());
+        b.append('@');
+        showPar(expression.getPattern());
+    }
+
+    @Override
+    public void visit(EBind expression) {
+        b.append("EBind");
+    }
+
+    @Override
+    public void visit(EConstant expression) {
+        String name = expression.getValue().getName().name;
+        if(Character.isJavaIdentifierStart(name.charAt(0)))
+            b.append(name);
+        else
+            b.append('(').append(name).append(')');
+    }
+
+    @Override
+    public void visit(EEnforce expression) {
+        b.append("enforce ");
+        expression.getQuery().accept(this);
+    }
+
+    @Override
+    public void visit(EError expression) {
+        b.append("EError");
+    }
+
+    @Override
+    public void visit(EExternalConstant expression) {
+        b.append(expression.getValue());
+    }
+
+    @Override
+    public void visit(EFieldAccess expression) {
+        b.append("EFieldAccess");
+    }
+
+    @Override
+    public void visit(EGetConstraint expression) {
+        b.append("EGetConstraint");
+    }
+
+    @Override
+    public void visit(EIf expression) {
+        b.append("if ");
+        expression.getCondition().accept(this);
+        ++indentation;
+        newLine();
+        b.append("then ");
+        expression.getThen().accept(this);
+        newLine();
+        b.append("else ");
+        expression.getElse().accept(this);
+        --indentation;
+    }
+    
+    @Override
+    public void visit(QIf query) {
+        b.append("if ");
+        query.condition.accept(this);
+        ++indentation;
+        newLine();
+        b.append("then ");
+        query.thenQuery.accept(this);
+        newLine();
+        b.append("else ");
+        query.elseQuery.accept(this);
+        --indentation;
+    }
+
+    @Override
+    public void visit(EIntegerLiteral expression) {
+        b.append(expression.getValue());
+    }
+
+    @Override
+    public void visit(ELambda expression) {
+        b.append('\\');
+        ++indentation;
+        for(Case case_ : expression.getCases()) {
+            newLine();
+            for(Expression pat : case_.patterns) {
+                showPar(pat);
+                b.append(' ');
+            }
+            b.append("-> ");
+            ++indentation;
+            case_.value.accept(this);
+            --indentation;
+        }
+        --indentation;
+    }
+
+    @Override
+    public void visit(ELambdaType expression) {
+        expression.value.accept(this);
+    }
+
+    @Override
+    public void visit(ELet expression) {
+        b.append("do");
+        ++indentation;
+        printAsDo(expression);
+        --indentation;
+    }
+
+    @Override
+    public void visit(EListComprehension expression) {
+        b.append("EListComprehension");
+    }
+
+    @Override
+    public void visit(EListLiteral expression) {
+        b.append('[');
+        boolean first = true;
+        for(Expression component : expression.getComponents()) {
+            if(first)
+                first = false;
+            else
+                b.append(',');
+            component.accept(this);
+        }
+        b.append(']');
+    }
+
+    @Override
+    public void visit(ELiteral expression) {
+        b.append(expression.getValue().toString());
+    }
+
+    @Override
+    public void visit(EMatch expression) {
+        b.append("match");
+        for(Expression s : expression.getScrutinee()) {
+            b.append(' ');
+            showPar(s);
+        }
+        b.append(" with");
+        ++indentation;
+        for(Case case_ : expression.getCases()) {
+            newLine();
+            for(Expression pat : case_.patterns) {
+                showPar(pat);
+                b.append(' ');
+            }
+            b.append("-> ");
+            ++indentation;
+            case_.value.accept(this);
+            --indentation;
+        }
+        --indentation;
+    }
+
+    @Override
+    public void visit(EPlaceholder expression) {
+        expression.expression.accept(this);
+    }
+
+    @Override
+    public void visit(ERealLiteral expression) {
+        b.append(expression.getValue());
+    }
+
+    @Override
+    public void visit(ERuleset expression) {
+        b.append("let\n");
+        ++indentation;
+        for(ERuleset.DatalogRule rule : expression.getRules()) {
+            newLine();
+            visit(rule);
+        }
+        --indentation;
+        b.append("\nin ");
+        expression.getIn().accept(this);
+    }
+
+    @Override
+    public void visit(ESelect expression) {
+        b.append("ESelect");
+    }
+
+    @Override
+    public void visit(ESimpleLambda expression) {
+        b.append('\\');
+        show(expression.getParameter());
+        while(expression.getValue() instanceof ESimpleLambda) {
+            expression = (ESimpleLambda)expression.getValue();
+            b.append(' ');
+            show(expression.getParameter());
+        }
+        b.append(" -> ");
+        expression.getValue().accept(this);
+    }
+
+    @Override
+    public void visit(ESimpleLet expression) {
+        b.append("do");
+        ++indentation;
+        printAsDo(expression);
+        --indentation;
+    }
+    
+    private void printAsDo(Expression expression) {
+        if(expression instanceof ESimpleLet) {
+            ESimpleLet let = (ESimpleLet)expression;
+            Variable variable = let.getVariable();
+            Expression value = let.getValue();
+            if("_".equals(variable.getName()))
+                printAsDo(value);
+            else {
+                newLine();
+                show(variable);
+                b.append(" = ");
+                value.accept(this);
+            }
+            printAsDo(let.getIn());
+        }
+        else if(expression instanceof ELet) {
+            ELet let = (ELet)expression;
+            for(Assignment assignment : let.assignments) {
+                newLine();
+                assignment.pattern.accept(this);
+                b.append(" = ");
+                assignment.value.accept(this);
+            }
+            printAsDo(let.in);
+        }
+        else {
+            newLine();
+            expression.accept(this);
+        }
+    }
+
+    @Override
+    public void visit(ETransformation expression) {
+        b.append("<transformation>");
+    }
+
+    @Override
+    public void visit(ETypeAnnotation expression) {
+        expression.getValue().accept(this);
+    }
+
+    @Override
+    public void visit(EVariable expression) {
+        show(expression.getVariable());
+    }
+
+    @Override
+    public void visit(EWhen expression) {
+        b.append("when ");
+        expression.getQuery().accept(this);
+        b.append("\n");
+        expression.getAction().accept(this);
+    }
+
+    @Override
+    public void visit(GuardedExpressionGroup expression) {
+        boolean first = true;
+        for(GuardedExpression gexp : expression.expressions) {
+            if(first)
+                first = false;
+            else
+                newLine();
+            b.append("| ");
+            for(int i=0;i<gexp.guards.length;++i) {
+                if(i > 0)
+                    b.append(", ");
+                gexp.guards[i].accept(this);
+            }
+            b.append(" = ");
+            gexp.value.accept(this);
+        }
+    }
+
+    @Override
+    public void visit(QAlternative query) {
+        b.append("QAlternative");
+    }
+
+    @Override
+    public void visit(QAtom query) {
+        if(query.relation == EqRelation.INSTANCE) {
+            query.parameters[0].accept(this);
+            b.append(" = ");
+            query.parameters[1].accept(this);
+        }
+        else if(query.relation == MemberRelation.INSTANCE) {
+            query.parameters[0].accept(this);
+            b.append(" <- ");
+            query.parameters[1].accept(this);
+        }
+        else {
+            b.append(query.relation);
+            for(Expression parameter : query.parameters) {
+                b.append(' ');
+                showPar(parameter);
+            }
+        }
+    }
+
+    @Override
+    public void visit(QConjunction query) {
+        boolean first = true;
+        for(Query q : query.queries) {
+            if(first)
+                first = false;
+            else
+                newLine();
+            q.accept(this);
+        }
+    }
+
+    @Override
+    public void visit(QDisjunction query) {
+        b.append("QDisjunction");
+    }
+
+    @Override
+    public void visit(QExists query) {
+        b.append("QExists");
+    }
+
+    @Override
+    public void visit(QNegation query) {
+        b.append("QNegation");
+    }
+
+    @Override
+    public void visit(QMapping query) {
+        b.append(query.mappingRelation.name.name);
+        for(Expression parameter : query.parameters) {
+            b.append(' ');
+            parameter.accept(this);
+        }
+    }
+
+    public void visit(ERuleset.DatalogRule rule) {
+        b.append(rule.headRelation.getName());
+        for(Expression parameter : rule.headParameters) {
+            b.append(' ');
+            showPar(parameter);
+        }
+        b.append(" :-\n");
+        ++indentation;
+        rule.body.accept(this);
+        --indentation;
+    }
+
+    public void visit(TransformationRule rule) {
+        b.append("rule ").append(rule.name.name).append(" where");
+        for(Entry<SectionName, Query[]> section : rule.sections.entrySet()) {
+            b.append("\n@").append(section.getKey().name());
+            for(Query query : section.getValue()) {
+                b.append('\n');
+                query.accept(this);
+            }
+        }
+    }
+
+
+    @Override
+    public void visit(ECoveringBranchPoint expression) {
+        expression.expression.accept(this);
+    }
+
+    @Override
+    public void visit(EEquations eEquations) {
+        b.append("eq");
+    }
+}