bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/query/Query.java

   1 package org.simantics.scl.compiler.elaboration.query;
   2
   3 import java.util.ArrayList;
   4 import java.util.Set;
   5
   6 import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;
   7 import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;
   8 import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;
   9 import org.simantics.scl.compiler.elaboration.contexts.TypingContext;
  10 import org.simantics.scl.compiler.elaboration.expressions.EError;
  11 import org.simantics.scl.compiler.elaboration.expressions.Expression;
  12 import org.simantics.scl.compiler.elaboration.expressions.QueryTransformer;
  13 import org.simantics.scl.compiler.elaboration.expressions.StandardExpressionVisitor;
  14 import org.simantics.scl.compiler.elaboration.expressions.Variable;
  15 import org.simantics.scl.compiler.elaboration.expressions.VariableProcedure;
  16 import org.simantics.scl.compiler.elaboration.expressions.printing.ExpressionToStringVisitor;
  17 import org.simantics.scl.compiler.elaboration.expressions.visitors.CollectRefsVisitor;
  18 import org.simantics.scl.compiler.elaboration.expressions.visitors.ForVariablesUsesVisitor;
  19 import org.simantics.scl.compiler.elaboration.query.compilation.ConstraintCollectionContext;
  20 import org.simantics.scl.compiler.elaboration.query.compilation.DerivateException;
  21 import org.simantics.scl.compiler.elaboration.query.compilation.DynamicProgrammingOrdering;
  22 import org.simantics.scl.compiler.elaboration.query.compilation.EnforcingContext;
  23 import org.simantics.scl.compiler.elaboration.query.compilation.QueryCompilationContext;
  24 import org.simantics.scl.compiler.elaboration.query.compilation.QueryConstraint;
  25 import org.simantics.scl.compiler.elaboration.query.compilation.UnsolvableQueryException;
  26 import org.simantics.scl.compiler.elaboration.relations.CompositeRelation;
  27 import org.simantics.scl.compiler.elaboration.relations.LocalRelation;
  28 import org.simantics.scl.compiler.elaboration.relations.SCLRelation;
  29 import org.simantics.scl.compiler.internal.parsing.Symbol;
  30
  31 import gnu.trove.map.hash.THashMap;
  32 import gnu.trove.map.hash.TIntObjectHashMap;
  33 import gnu.trove.map.hash.TObjectIntHashMap;
  34 import gnu.trove.set.hash.THashSet;
  35 import gnu.trove.set.hash.TIntHashSet;
  36
  37 public abstract class Query extends Symbol {
  38     public static final Query[] EMPTY_ARRAY = new Query[0];
  39
  40     public abstract void collectFreeVariables(THashSet<Variable> vars);
  41     public abstract void collectVars(TObjectIntHashMap<Variable> allVars, TIntHashSet vars);
  42     public abstract void checkType(TypingContext context);
  43
  44     public Query resolve(TranslationContext context) {
  45         throw new InternalCompilerError(location, getClass().getSimpleName() + " does not support resolve.");
  46     }
  47
  48     public Expression generateEnforce(EnforcingContext context) {
  49         context.getErrorLog().log(location, getClass().getSimpleName() + " does not support enforcing.");
  50         return new EError(location);
  51     }
  52
  53     public abstract void collectConstraints(ConstraintCollectionContext context) throws UnsolvableQueryException;
  54
  55     protected QueryConstraint[] getOrderedConstraints(QueryCompilationContext context) throws UnsolvableQueryException {
  56         ConstraintCollectionContext collectionContext = new ConstraintCollectionContext(context);
  57         collectConstraints(collectionContext);
  58         QueryConstraint[] constraints = collectionContext.getConstraints();
  59         DynamicProgrammingOrdering.order(collectionContext, constraints, 0L);
  60         return constraints;
  61     }
  62
  63     protected void applyConstraints(QueryCompilationContext context, QueryConstraint[] constraints) {
  64         for(int i=constraints.length-1;i>=0;--i)
  65             constraints[i].generateAndUpdateCost(context);
  66     }
  67
  68     public void generate(QueryCompilationContext context) throws UnsolvableQueryException {
  69         applyConstraints(context, getOrderedConstraints(context));
  70     }
  71
  72     protected static final TIntObjectHashMap<ArrayList<Query>> NO_DERIVATE = new TIntObjectHashMap<ArrayList<Query>>();
  73
  74     public static class Diffable {
  75         public int id;
  76         SCLRelation relation;
  77         public Variable[] parameters;
  78         public Diffable(int id, SCLRelation relation, Variable[] parameters) {
  79             this.id = id;
  80             this.relation = relation;
  81             this.parameters = parameters;
  82         }
  83     }
  84
  85     public static class Diff {
  86         public int id;
  87         public Query query;
  88
  89         public Diff(int id, Query query) {
  90             this.id = id;
  91             this.query = query;
  92         }
  93     }
  94
  95     public static final Diff[] NO_DIFF = new Diff[0];
  96
  97     public Diff[] derivate(THashMap<LocalRelation, Diffable> diffables) throws DerivateException {
  98         throw new DerivateException(location);
  99     }
 100
 101     public static final QDisjunction EMPTY_QUERY = new QDisjunction();
 102
 103     public Query removeRelations(Set<SCLRelation> relations) {
 104         throw new UnsupportedOperationException();
 105     }
 106
 107     public Query copy() {
 108         return replace(new ReplaceContext(null));
 109     }
 110
 111     public Query copy(TypingContext context) {
 112         return replace(new ReplaceContext(context));
 113     }
 114
 115     public abstract Query replace(ReplaceContext context);
 116
 117     public abstract void setLocationDeep(long loc);
 118
 119     public abstract void accept(QueryVisitor visitor);
 120
 121     public void collectRelationRefs(
 122             final TObjectIntHashMap<SCLRelation> allRefs, final TIntHashSet refs) {
 123         accept(new StandardExpressionVisitor() {
 124             @Override
 125             public void visit(QAtom query) {
 126                 visit(query.relation);
 127             }
 128             private void visit(SCLRelation relation) {
 129                 int id = allRefs.get(relation);
 130                 if(id >= 0)
 131                     refs.add(id);
 132                 else if(relation instanceof CompositeRelation)
 133                     for(SCLRelation subrelation : ((CompositeRelation)relation).getSubrelations())
 134                         visit(subrelation);
 135             }
 136         });
 137     }
 138
 139     public TIntObjectHashMap<ArrayList<Query>> splitToPhases() {
 140         TIntObjectHashMap<ArrayList<Query>> result = new TIntObjectHashMap<ArrayList<Query>>(2);
 141         splitToPhases(result);
 142         return result;
 143     }
 144
 145     public void splitToPhases(TIntObjectHashMap<ArrayList<Query>> result) {
 146         throw new UnsupportedOperationException(getClass().getSimpleName() + " does not support splitToPhases.");
 147     }
 148
 149     @Override
 150     public String toString() {
 151         StringBuilder b = new StringBuilder();
 152         ExpressionToStringVisitor visitor = new ExpressionToStringVisitor(b);
 153         accept(visitor);
 154         return b.toString();
 155     }
 156
 157     public abstract Query accept(QueryTransformer transformer);
 158
 159     public void forVariables(VariableProcedure procedure) {
 160         accept(new ForVariablesUsesVisitor(procedure));
 161     }
 162     public void collectRefs(TObjectIntHashMap<Object> allRefs, TIntHashSet refs) {
 163         accept(new CollectRefsVisitor(allRefs, refs));
 164     }
 165 }