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

   1 package org.simantics.scl.compiler.elaboration.expressions;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collections;
   5 import java.util.Comparator;
   6
   7 import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;
   8 import org.simantics.scl.compiler.elaboration.contexts.TypingContext;
   9 import org.simantics.scl.compiler.elaboration.query.Query;
  10 import org.simantics.scl.compiler.elaboration.rules.TransformationRule;
  11 import org.simantics.scl.compiler.errors.Locations;
  12 import org.simantics.scl.compiler.internal.elaboration.transformations.TransformationBuilder;
  13 import org.simantics.scl.compiler.top.SCLCompilerConfiguration;
  14 import org.simantics.scl.compiler.types.Types;
  15 import org.simantics.scl.compiler.types.exceptions.MatchException;
  16 import org.slf4j.Logger;
  17 import org.slf4j.LoggerFactory;
  18
  19 public class ETransformation extends SimplifiableExpression {
  20
  21     private static final Logger LOGGER = LoggerFactory.getLogger(ETransformation.class);
  22
  23     public static final Object TRANSFORMATION_RULES_TYPECHECKED = new Object();
  24
  25     public final String name;
  26     public Query seed;
  27
  28     public ETransformation(String name, Query seed) {
  29         this.name = name;
  30         this.seed = seed;
  31     }
  32
  33     @Override
  34     protected void updateType() throws MatchException {
  35         setType(Types.UNIT);
  36     }
  37
  38     @Override
  39     public Expression inferType(TypingContext context) {
  40         context.declareEffect(location, Types.PROC);
  41         seed.checkType(context);
  42         return compile(context);
  43     }
  44
  45     private Expression compile(TypingContext context) {
  46         ArrayList<TransformationRule> rules = new ArrayList<TransformationRule>();
  47         context.getEnvironment().collectRules(rules);
  48         Collections.sort(rules, new Comparator<TransformationRule>() {
  49             @Override
  50             public int compare(TransformationRule o1, TransformationRule o2) {
  51                 return Integer.compare(Locations.beginOf(o1.location), Locations.beginOf(o2.location));
  52             }
  53         });
  54
  55         // Translation
  56         TransformationBuilder tb = new TransformationBuilder(context.getErrorLog(), context);
  57         tb.handleSeed(seed);
  58         for(TransformationRule rule : rules)
  59             if(!rule.isAbstract)
  60                 tb.handleRule(rule);
  61         Expression expression = tb.compileRules();
  62
  63         if(SCLCompilerConfiguration.SHOW_COMPILED_RULES)
  64             LOGGER.info("{}", expression);
  65         return expression;
  66     }
  67
  68     @Override
  69     public Expression resolve(TranslationContext context) {
  70         seed = seed.resolve(context);
  71         return this;
  72     }
  73
  74     @Override
  75     public void setLocationDeep(long loc) {
  76         if(location == Locations.NO_LOCATION) {
  77             location = loc;
  78             seed.setLocationDeep(loc);
  79         }
  80     }
  81
  82     @Override
  83     public void accept(ExpressionVisitor visitor) {
  84         visitor.visit(this);
  85     }
  86
  87     @Override
  88     public Expression accept(ExpressionTransformer transformer) {
  89         return transformer.transform(this);
  90     }
  91
  92 }