bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/expressions/EWhen.java

   1 package org.simantics.scl.compiler.elaboration.expressions;
   2
   3 import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;
   4 import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;
   5 import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;
   6 import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;
   7 import org.simantics.scl.compiler.elaboration.contexts.TypingContext;
   8 import org.simantics.scl.compiler.elaboration.query.QExists;
   9 import org.simantics.scl.compiler.elaboration.query.Query;
  10 import org.simantics.scl.compiler.elaboration.query.compilation.QueryCompilationContext;
  11 import org.simantics.scl.compiler.elaboration.query.compilation.QueryCompilationMode;
  12 import org.simantics.scl.compiler.elaboration.query.compilation.UnsolvableQueryException;
  13 import org.simantics.scl.compiler.errors.Locations;
  14 import org.simantics.scl.compiler.internal.elaboration.utils.ExpressionDecorator;
  15 import org.simantics.scl.compiler.types.Type;
  16 import org.simantics.scl.compiler.types.Types;
  17 import org.simantics.scl.compiler.types.exceptions.MatchException;
  18 import org.simantics.scl.compiler.types.exceptions.UnificationException;
  19 import org.simantics.scl.compiler.types.kinds.Kinds;
  20
  21 import gnu.trove.map.hash.TObjectIntHashMap;
  22 import gnu.trove.set.hash.THashSet;
  23 import gnu.trove.set.hash.TIntHashSet;
  24
  25 public class EWhen extends SimplifiableExpression {
  26
  27     public Query query;
  28     public Expression action;
  29     Variable[] variables;
  30
  31     public EWhen(Query query, Expression action) {
  32         this.query = query;
  33         this.action = action;
  34     }
  35
  36     public EWhen(long location, Query query, Expression action, Variable[] variables) {
  37         if(variables == null)
  38             throw new NullPointerException();
  39         if(location == Locations.NO_LOCATION)
  40             new Exception().printStackTrace();
  41         this.location = location;
  42         this.query = query;
  43         this.action = action;
  44         this.variables = variables;
  45     }
  46
  47     @Override
  48     public void collectRefs(TObjectIntHashMap<Object> allRefs,
  49             TIntHashSet refs) {
  50         query.collectRefs(allRefs, refs);
  51         action.collectRefs(allRefs, refs);
  52     }
  53
  54     @Override
  55     public void collectVars(TObjectIntHashMap<Variable> allVars,
  56             TIntHashSet vars) {
  57         query.collectVars(allVars, vars);
  58         action.collectVars(allVars, vars);
  59     }
  60
  61     @Override
  62     public void collectEffects(THashSet<Type> effects) {
  63         throw new InternalCompilerError(location, getClass().getSimpleName() + " does not support collectEffects.");
  64     }
  65
  66     @Override
  67     protected void updateType() throws MatchException {
  68         setType(Types.UNIT);
  69     }
  70
  71     @Override
  72     public Expression checkBasicType(TypingContext context, Type requiredType) {
  73         try {
  74             Types.unify(requiredType, Types.UNIT);
  75         } catch (UnificationException e) {
  76             context.typeError(location, requiredType, Types.UNIT);
  77             return this;
  78         }
  79         for(Variable variable : variables)
  80             variable.setType(Types.metaVar(Kinds.STAR));
  81         query.checkType(context);
  82         action.checkIgnoredType(context);
  83
  84         // Compile query
  85         return compile(context);
  86     }
  87
  88     public Expression compile(TypingContext context) {
  89         try {
  90             QueryCompilationContext queryCompilationContext =
  91                     new QueryCompilationContext(context, QueryCompilationMode.ITERATE, null, action);
  92             new QExists(variables, query).generate(queryCompilationContext);
  93             return queryCompilationContext.getContinuation();
  94         } catch(UnsolvableQueryException e) {
  95             context.getErrorLog().log(getLocation(), "Failed to compile the query.\n" +  e.getMessage());
  96             return new EError(getLocation());
  97         }
  98     }
  99
 100     @Override
 101     public void collectFreeVariables(THashSet<Variable> vars) {
 102         action.collectFreeVariables(vars);
 103         query.collectFreeVariables(vars);
 104         for(Variable var : variables)
 105             vars.remove(var);
 106     }
 107
 108     @Override
 109     public Expression resolve(TranslationContext context) {
 110         context.pushExistentialFrame();
 111         query = query.resolve(context);
 112         action = action.resolve(context);
 113         variables = context.popExistentialFrame();
 114         return this;
 115     }
 116
 117     @Override
 118     public Expression decorate(ExpressionDecorator decorator) {
 119         return decorator.decorate(this);
 120     }
 121
 122     @Override
 123     public Expression replace(ReplaceContext context) {
 124         Variable[] newVariables = new Variable[variables.length];
 125         for(int i=0;i<variables.length;++i) {
 126             Variable variable = variables[i];
 127             Variable newVariable = new Variable(variable.name, variable.getType());
 128             newVariables[i] = newVariable;
 129             context.varMap.put(variable, new EVariable(newVariable));
 130         }
 131         EWhen result = new EWhen(location, query.replace(context), action.replace(context), newVariables);
 132         for(int i=0;i<variables.length;++i)
 133             context.varMap.remove(variables[i]);
 134         return result;
 135     }
 136
 137     @Override
 138     public void setLocationDeep(long loc) {
 139         if(location == Locations.NO_LOCATION) {
 140             location = loc;
 141             query.setLocationDeep(loc);
 142             action.setLocationDeep(loc);
 143         }
 144     }
 145
 146     @Override
 147     public void accept(ExpressionVisitor visitor) {
 148         visitor.visit(this);
 149     }
 150
 151     public Query getQuery() {
 152         return query;
 153     }
 154
 155     public Expression getAction() {
 156         return action;
 157     }
 158
 159     @Override
 160     public void forVariables(VariableProcedure procedure) {
 161         query.forVariables(procedure);
 162         action.forVariables(procedure);
 163     }
 164
 165     @Override
 166     public Expression simplify(SimplificationContext context) {
 167         throw new UnsupportedOperationException();
 168     }
 169
 170     @Override
 171     public Expression accept(ExpressionTransformer transformer) {
 172         return transformer.transform(this);
 173     }
 174
 175 }