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