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