X-Git-Url: https://gerrit.simantics.org/r/gitweb?p=simantics%2Fplatform.git;a=blobdiff_plain;f=bundles%2Forg.simantics.scl.compiler%2Fsrc%2Forg%2Fsimantics%2Fscl%2Fcompiler%2Felaboration%2Fchr%2Fplanning%2FQueryPlanningContext.java;h=61503458cd541ef4d84d2aabe0b06220b13d0813;hp=c083b8fc9693a41b25ba3165bb2df6f5096c65ea;hb=f5c5f79bf2a62515c8c81103a4c8932fc0dcf79d;hpb=ca40974f87c9db00eb77aaf1acc1e9937b37261b

diff --git a/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/chr/planning/QueryPlanningContext.java b/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/chr/planning/QueryPlanningContext.java
index c083b8fc9..61503458c 100644
--- a/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/chr/planning/QueryPlanningContext.java
+++ b/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/chr/planning/QueryPlanningContext.java
@@ -1,240 +1,250 @@
-package org.simantics.scl.compiler.elaboration.chr.planning;
-
-import java.util.ArrayList;
-
-import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;
-import org.simantics.scl.compiler.compilation.CompilationContext;
-import org.simantics.scl.compiler.elaboration.chr.CHRLiteral;
-import org.simantics.scl.compiler.elaboration.chr.plan.AccessFactOp;
-import org.simantics.scl.compiler.elaboration.chr.plan.ClaimOp;
-import org.simantics.scl.compiler.elaboration.chr.plan.ExecuteOp;
-import org.simantics.scl.compiler.elaboration.chr.plan.PlanOp;
-import org.simantics.scl.compiler.elaboration.chr.planning.items.CheckPrePlanItem;
-import org.simantics.scl.compiler.elaboration.chr.planning.items.EqualsPrePlanItem;
-import org.simantics.scl.compiler.elaboration.chr.planning.items.GenericPrePlanItem;
-import org.simantics.scl.compiler.elaboration.chr.planning.items.MemberPrePlanItem;
-import org.simantics.scl.compiler.elaboration.chr.relations.CHRConstraint;
-import org.simantics.scl.compiler.elaboration.chr.relations.SpecialCHRRelation;
-import org.simantics.scl.compiler.elaboration.expressions.EApplyType;
-import org.simantics.scl.compiler.elaboration.expressions.EConstant;
-import org.simantics.scl.compiler.elaboration.expressions.EExternalConstant;
-import org.simantics.scl.compiler.elaboration.expressions.ELiteral;
-import org.simantics.scl.compiler.elaboration.expressions.EVariable;
-import org.simantics.scl.compiler.elaboration.expressions.Expression;
-import org.simantics.scl.compiler.elaboration.expressions.Variable;
-
-import gnu.trove.impl.Constants;
-import gnu.trove.map.hash.TObjectIntHashMap;
-import gnu.trove.procedure.TIntProcedure;
-import gnu.trove.set.hash.TIntHashSet;
-
-public class QueryPlanningContext {
-    CompilationContext compilationContext;
-    public PlanPriorityQueue priorityQueue = new PlanPriorityQueue();
-    ArrayList<Variable> variables;
-    TObjectIntHashMap<Variable> variableMap;
-    ArrayList<ArrayList<PrePlanItem>> itemsContainingVariable;
-    ArrayList<PlanOp> planOps = new ArrayList<PlanOp>(); 
-    
-    public QueryPlanningContext(CompilationContext compilationContext, Variable[] variables) {
-        this.compilationContext = compilationContext;
-        this.variables = new ArrayList<Variable>(variables.length*2);
-        this.variableMap = new TObjectIntHashMap<Variable>(variables.length, Constants.DEFAULT_LOAD_FACTOR, -1);
-        itemsContainingVariable = new ArrayList<ArrayList<PrePlanItem>>(variables.length*2);
-        for(Variable variable : variables)
-            addVariable(variable);
-    }
-    
-    private void addVariable(Variable variable) {
-        int id = variables.size();
-        variables.add(variable);
-        variableMap.put(variable, id);
-        itemsContainingVariable.add(new ArrayList<PrePlanItem>(2));
-    }
-
-    public void add(CHRLiteral literal, int secondaryPriority) {
-        if(literal.relation instanceof SpecialCHRRelation) {
-            switch((SpecialCHRRelation)literal.relation) {
-            case CHECK:
-                addCheck(literal.location, literal.parameters[0], secondaryPriority);
-                return;
-            case EQUALS:
-                addGenericEquals(literal.location, literal.parameters[0], literal.parameters[1], secondaryPriority);
-                return;
-            case MEMBER:
-                addMember(literal.location, literal.parameters[0], literal.parameters[1], secondaryPriority);
-                return;
-            case EXECUTE:
-                throw new InternalCompilerError(literal.location, "EXECUTE constraint is not allowed in query compilation.");
-            }
-        }
-        
-        addGenericConstraint(literal, secondaryPriority);
-    }
-    
-    private TIntHashSet getVars(Expression expression, int initialCapacity) {
-        TIntHashSet variableSet = new TIntHashSet(initialCapacity);
-        expression.collectVars(variableMap, variableSet);
-        return variableSet;
-    }
-    
-    private TIntHashSet[] getVars(Expression[] expressions, int initialCapacity) {
-        TIntHashSet[] variableSets = new TIntHashSet[expressions.length];
-        for(int i=0;i<expressions.length;++i)
-            variableSets[i] = getVars(expressions[i], initialCapacity);
-        return variableSets;
-    }
-    
-    /**
-     * Returns true, if the expression is so simple, it does not involve any computation.
-     */
-    private static boolean isSimpleExpression(Expression expression) {
-        while(expression instanceof EApplyType)
-            expression = ((EApplyType)expression).getExpression();
-        return expression instanceof EVariable 
-                || expression instanceof EConstant
-                || expression instanceof ELiteral
-                || expression instanceof EExternalConstant;
-    }
-    
-    private Expression toSimpleExpression(Expression expression, int secondaryPriority) {
-        if(isSimpleExpression(expression))        
-            return expression;
-        else {
-            Variable temp = new Variable("temp", expression.getType());
-            addVariable(temp);
-            addOneSidedEquals(expression.location, new EVariable(temp), expression, secondaryPriority);
-            return new EVariable(temp);
-        }
-    }
-    
-    private Expression[] toSimpleExpressions(Expression[] expressions, int secondaryPriority) {
-        Expression[] result = new Expression[expressions.length];
-        for(int i=0;i<expressions.length;++i)
-            result[i] = toSimpleExpression(expressions[i], secondaryPriority);
-        return result;
-    }
-
-    private void addGenericConstraint(CHRLiteral literal, int secondaryPriority) {
-        if(literal.killAfterMatch)
-            ((CHRConstraint)literal.relation).setMayBeRemoved();
-        Expression[] parameters = toSimpleExpressions(literal.parameters, secondaryPriority);
-        add(literal.location, new GenericPrePlanItem(literal, literal.relation, parameters, getVars(parameters, 1), secondaryPriority));
-    }
-
-    private void addMember(long location, Expression p1, Expression p2, int secondaryPriority) {
-        Expression expression1 = toSimpleExpression(p1, secondaryPriority);
-        Expression expression2 = toSimpleExpression(p2, secondaryPriority);
-        add(location, new MemberPrePlanItem(expression1, expression2,
-                getVars(expression1, 1), getVars(expression2, 1), secondaryPriority));
-    }
-    
-    private void addOneSidedEquals(long location, Expression expression1, Expression expression2, int secondaryPriority) {
-        add(location, new EqualsPrePlanItem(expression1, expression2,
-                getVars(expression1, 1), getVars(expression2, 4), secondaryPriority));
-    }
-
-    private void addGenericEquals(long location, Expression p1, Expression p2, int secondaryPriority) {
-        if(isSimpleExpression(p1))
-            addOneSidedEquals(location, p1, p2, secondaryPriority);
-        else if(isSimpleExpression(p2))
-            addOneSidedEquals(location, p2, p1, secondaryPriority);
-        else {
-            Variable temp = new Variable("temp", p1.getType());
-            addVariable(temp);
-            addOneSidedEquals(p1.location, new EVariable(temp), p1, secondaryPriority);
-            addOneSidedEquals(p2.location, new EVariable(temp), p2, secondaryPriority);
-        }
-    }
-
-    private void addCheck(long location, Expression condition, int secondaryPriority) {
-        TIntHashSet variableSet = new TIntHashSet(4);
-        condition.collectVars(variableMap, variableSet);
-        add(location, new CheckPrePlanItem(condition, variableSet, secondaryPriority));
-    }
-
-    private void add(long location, PrePlanItem item) {
-        priorityQueue.add(item);
-        item.initializeListeners(this);
-        item.location = location;
-    }
-
-    public void listen(TIntHashSet variableSet, PrePlanItem item) {
-        variableSet.forEach(new TIntProcedure() {
-            @Override
-            public boolean execute(int variableId) {
-                listen(variableId, item);
-                return true;
-            }
-        });
-    }
-
-    public void listen(int variableId, PrePlanItem item) {
-        itemsContainingVariable.get(variableId).add(item);
-    }
-
-    public void createQueryPlan() {
-        while(!priorityQueue.isEmpty()) {
-            PrePlanItem head = priorityQueue.head();
-            priorityQueue.pop();
-            head.generate(this);
-        }
-    }
-    
-    public ArrayList<PlanOp> getPlanOps() {
-        return planOps;
-    }
-    
-    private final TIntProcedure BIND_PROCEDURE = new TIntProcedure() {
-        @Override
-        public boolean execute(int variableId) {
-            ArrayList<PrePlanItem> l = itemsContainingVariable.get(variableId);
-            for(PrePlanItem item : l)
-                item.variableSolved(QueryPlanningContext.this, variableId);
-            l.clear();
-            return true;
-        }
-    };
-
-    public void bind(TIntHashSet variableSet) {
-        variableSet.forEach(BIND_PROCEDURE);
-    }
-
-    public void addPlanOp(PlanOp planOp) {
-        planOps.add(planOp);
-    }
-
-    public CompilationContext getCompilationContext() {
-        return compilationContext;
-    }
-
-    public void activate(CHRLiteral literal, Expression inputFact, int secondaryPriority) {
-        Variable[] variables = new Variable[literal.parameters.length];
-        for(int i=0;i<literal.parameters.length;++i)
-            variables[i] = new Variable("activeFactComponent" + i, literal.parameters[i].getType());
-        if(literal.killAfterMatch)
-            ((CHRConstraint)literal.relation).setMayBeRemoved();
-        planOps.add(new AccessFactOp(literal.location, inputFact, (CHRConstraint)literal.relation, variables, literal.killAfterMatch));
-        for(int i=0;i<literal.parameters.length;++i)
-            addOneSidedEquals(literal.parameters[i].location, new EVariable(variables[i]), literal.parameters[i], secondaryPriority);
-    }
-
-    public void claim(QueryPlanningContext context, CHRLiteral literal) {
-        if(literal.relation instanceof CHRConstraint) {
-            CHRConstraint constraint = (CHRConstraint)literal.relation;
-            addPlanOp(new ClaimOp(literal.location, constraint, literal.parameters));
-        }
-        else if(literal.relation instanceof SpecialCHRRelation) {
-            switch((SpecialCHRRelation)literal.relation) {
-            case EXECUTE:
-                addPlanOp(new ExecuteOp(literal.location, literal.parameters[0]));
-                break;
-            default:
-                context.getCompilationContext().errorLog.log(
-                        literal.location,
-                        "Cannot enforce this constraint.");
-            }
-        }
-    }
-
-}
+package org.simantics.scl.compiler.elaboration.chr.planning;
+
+import java.util.ArrayList;
+
+import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;
+import org.simantics.scl.compiler.compilation.CompilationContext;
+import org.simantics.scl.compiler.elaboration.chr.CHRLiteral;
+import org.simantics.scl.compiler.elaboration.chr.plan.AccessFactOp;
+import org.simantics.scl.compiler.elaboration.chr.plan.ClaimOp;
+import org.simantics.scl.compiler.elaboration.chr.plan.ExecuteOp;
+import org.simantics.scl.compiler.elaboration.chr.plan.PlanOp;
+import org.simantics.scl.compiler.elaboration.chr.planning.items.CheckPrePlanItem;
+import org.simantics.scl.compiler.elaboration.chr.planning.items.EqualsPrePlanItem;
+import org.simantics.scl.compiler.elaboration.chr.planning.items.GenericPrePlanItem;
+import org.simantics.scl.compiler.elaboration.chr.planning.items.MemberPrePlanItem;
+import org.simantics.scl.compiler.elaboration.chr.relations.CHRConstraint;
+import org.simantics.scl.compiler.elaboration.chr.relations.SpecialCHRRelation;
+import org.simantics.scl.compiler.elaboration.expressions.EApplyType;
+import org.simantics.scl.compiler.elaboration.expressions.EConstant;
+import org.simantics.scl.compiler.elaboration.expressions.EExternalConstant;
+import org.simantics.scl.compiler.elaboration.expressions.ELiteral;
+import org.simantics.scl.compiler.elaboration.expressions.EVariable;
+import org.simantics.scl.compiler.elaboration.expressions.Expression;
+import org.simantics.scl.compiler.elaboration.expressions.Variable;
+import org.simantics.scl.compiler.errors.Locations;
+
+import gnu.trove.impl.Constants;
+import gnu.trove.map.hash.TObjectIntHashMap;
+import gnu.trove.procedure.TIntProcedure;
+import gnu.trove.set.hash.TIntHashSet;
+
+public class QueryPlanningContext {
+    CompilationContext compilationContext;
+    public PlanPriorityQueue priorityQueue = new PlanPriorityQueue();
+    ArrayList<Variable> variables;
+    TObjectIntHashMap<Variable> variableMap;
+    ArrayList<ArrayList<PrePlanItem>> itemsContainingVariable;
+    ArrayList<PlanOp> planOps = new ArrayList<PlanOp>(); 
+    
+    public QueryPlanningContext(CompilationContext compilationContext, Variable[] variables) {
+        this.compilationContext = compilationContext;
+        this.variables = new ArrayList<Variable>(variables.length*2);
+        this.variableMap = new TObjectIntHashMap<Variable>(variables.length, Constants.DEFAULT_LOAD_FACTOR, -1);
+        itemsContainingVariable = new ArrayList<ArrayList<PrePlanItem>>(variables.length*2);
+        for(Variable variable : variables)
+            addVariable(variable);
+    }
+    
+    private void addVariable(Variable variable) {
+        int id = variables.size();
+        variables.add(variable);
+        variableMap.put(variable, id);
+        itemsContainingVariable.add(new ArrayList<PrePlanItem>(2));
+    }
+
+    public void add(CHRLiteral literal, int secondaryPriority) {
+        if(literal.relation instanceof SpecialCHRRelation) {
+            switch((SpecialCHRRelation)literal.relation) {
+            case CHECK:
+                addCheck(literal.location, literal.parameters[0], secondaryPriority);
+                return;
+            case EQUALS:
+                addGenericEquals(literal.location, literal.parameters[0], literal.parameters[1], secondaryPriority);
+                return;
+            case MEMBER:
+                addMember(literal.location, literal.parameters[0], literal.parameters[1], secondaryPriority);
+                return;
+            case EXECUTE:
+                throw new InternalCompilerError(literal.location, "EXECUTE constraint is not allowed in query compilation.");
+            }
+        }
+        
+        addGenericConstraint(literal, secondaryPriority);
+    }
+    
+    private TIntHashSet getVars(Expression expression, int initialCapacity) {
+        TIntHashSet variableSet = new TIntHashSet(initialCapacity);
+        expression.collectVars(variableMap, variableSet);
+        return variableSet;
+    }
+    
+    private TIntHashSet[] getVars(Expression[] expressions, int initialCapacity) {
+        TIntHashSet[] variableSets = new TIntHashSet[expressions.length];
+        for(int i=0;i<expressions.length;++i)
+            variableSets[i] = getVars(expressions[i], initialCapacity);
+        return variableSets;
+    }
+    
+    /**
+     * Returns true, if the expression is so simple, it does not involve any computation.
+     */
+    private static boolean isSimpleExpression(Expression expression) {
+        while(expression instanceof EApplyType)
+            expression = ((EApplyType)expression).getExpression();
+        return expression instanceof EVariable 
+                || expression instanceof EConstant
+                || expression instanceof ELiteral
+                || expression instanceof EExternalConstant;
+    }
+    
+    private Expression toSimpleExpression(Expression expression, int secondaryPriority) {
+        if(isSimpleExpression(expression))        
+            return expression;
+        else {
+            Variable temp = new Variable("temp", expression.getType());
+            addVariable(temp);
+            addOneSidedEquals(expression.location, new EVariable(temp), expression, secondaryPriority);
+            return new EVariable(temp);
+        }
+    }
+    
+    private Expression[] toSimpleExpressions(Expression[] expressions, int secondaryPriority) {
+        Expression[] result = new Expression[expressions.length];
+        for(int i=0;i<expressions.length;++i)
+            result[i] = toSimpleExpression(expressions[i], secondaryPriority);
+        return result;
+    }
+
+    private void addGenericConstraint(CHRLiteral literal, int secondaryPriority) {
+        if(literal.killAfterMatch)
+            ((CHRConstraint)literal.relation).setMayBeRemoved();
+        Expression[] parameters = toSimpleExpressions(literal.parameters, secondaryPriority);
+        add(literal.location, new GenericPrePlanItem(literal, literal.relation, parameters, getVars(parameters, 1), secondaryPriority));
+    }
+
+    private void addMember(long location, Expression p1, Expression p2, int secondaryPriority) {
+        Expression expression1 = toSimpleExpression(p1, secondaryPriority);
+        Expression expression2 = toSimpleExpression(p2, secondaryPriority);
+        add(location, new MemberPrePlanItem(expression1, expression2,
+                getVars(expression1, 1), getVars(expression2, 1), secondaryPriority));
+    }
+    
+    private void addOneSidedEquals(long location, Expression expression1, Expression expression2, int secondaryPriority) {
+        add(location, new EqualsPrePlanItem(expression1, expression2,
+                getVars(expression1, 1), getVars(expression2, 4), secondaryPriority));
+    }
+
+    private void addGenericEquals(long location, Expression p1, Expression p2, int secondaryPriority) {
+        if(isSimpleExpression(p1))
+            addOneSidedEquals(location, p1, p2, secondaryPriority);
+        else if(isSimpleExpression(p2))
+            addOneSidedEquals(location, p2, p1, secondaryPriority);
+        else {
+            Variable temp = new Variable("temp", p1.getType());
+            addVariable(temp);
+            addOneSidedEquals(p1.location, new EVariable(temp), p1, secondaryPriority);
+            addOneSidedEquals(p2.location, new EVariable(temp), p2, secondaryPriority);
+        }
+    }
+
+    private void addCheck(long location, Expression condition, int secondaryPriority) {
+        TIntHashSet variableSet = new TIntHashSet(4);
+        condition.collectVars(variableMap, variableSet);
+        add(location, new CheckPrePlanItem(condition, variableSet, secondaryPriority));
+    }
+
+    private void add(long location, PrePlanItem item) {
+        priorityQueue.add(item);
+        item.initializeListeners(this);
+        item.location = location;
+    }
+
+    public void listen(TIntHashSet variableSet, PrePlanItem item) {
+        variableSet.forEach(new TIntProcedure() {
+            @Override
+            public boolean execute(int variableId) {
+                listen(variableId, item);
+                return true;
+            }
+        });
+    }
+
+    public void listen(int variableId, PrePlanItem item) {
+        itemsContainingVariable.get(variableId).add(item);
+    }
+
+    public boolean createQueryPlan() {
+        while(!priorityQueue.isEmpty()) {
+            PrePlanItem head = priorityQueue.head();
+            if(head.primaryPriority == Double.POSITIVE_INFINITY) {
+                compilationContext.errorLog.log(head.location, "Cannot solve the query.");
+                return false;
+            }
+            priorityQueue.pop();
+            head.generate(this);
+        }
+        return true;
+    }
+    
+    public ArrayList<PlanOp> getPlanOps() {
+        return planOps;
+    }
+    
+    private final TIntProcedure BIND_PROCEDURE = new TIntProcedure() {
+        @Override
+        public boolean execute(int variableId) {
+            ArrayList<PrePlanItem> l = itemsContainingVariable.get(variableId);
+            for(PrePlanItem item : l)
+                item.variableSolved(QueryPlanningContext.this, variableId);
+            l.clear();
+            return true;
+        }
+    };
+
+    public void bind(TIntHashSet variableSet) {
+        variableSet.forEach(BIND_PROCEDURE);
+    }
+
+    public void addPlanOp(PlanOp planOp) {
+        planOps.add(planOp);
+    }
+
+    public CompilationContext getCompilationContext() {
+        return compilationContext;
+    }
+
+    public void activate(CHRLiteral literal, Expression inputFact, int secondaryPriority) {
+        Variable[] variables = new Variable[literal.parameters.length];
+        for(int i=0;i<literal.parameters.length;++i)
+            variables[i] = new Variable("activeFactComponent" + i, literal.parameters[i].getType());
+        if(literal.killAfterMatch)
+            ((CHRConstraint)literal.relation).setMayBeRemoved();
+        planOps.add(new AccessFactOp(literal.location, inputFact, (CHRConstraint)literal.relation, variables, literal.killAfterMatch));
+        for(int i=0;i<literal.parameters.length;++i)
+            addOneSidedEquals(literal.parameters[i].location, new EVariable(variables[i]), literal.parameters[i], secondaryPriority);
+    }
+    
+    public void addInitFact(CHRConstraint initConstraint, Expression inputFact) {
+        planOps.add(new AccessFactOp(Locations.NO_LOCATION, inputFact, initConstraint, Variable.EMPTY_ARRAY, false));
+    }
+
+    public void claim(QueryPlanningContext context, CHRLiteral literal) {
+        if(literal.relation instanceof CHRConstraint) {
+            CHRConstraint constraint = (CHRConstraint)literal.relation;
+            addPlanOp(new ClaimOp(literal.location, constraint, literal.parameters));
+        }
+        else if(literal.relation instanceof SpecialCHRRelation) {
+            switch((SpecialCHRRelation)literal.relation) {
+            case EXECUTE:
+                addPlanOp(new ExecuteOp(literal.location, literal.parameters[0]));
+                break;
+            default:
+                context.getCompilationContext().errorLog.log(
+                        literal.location,
+                        "Cannot enforce this constraint.");
+            }
+        }
+    }
+
+}