package org.simantics.scl.compiler.internal.elaboration.transformations;
-import gnu.trove.map.hash.THashMap;
-import gnu.trove.map.hash.TIntObjectHashMap;
-import gnu.trove.map.hash.TObjectIntHashMap;
-import gnu.trove.set.hash.THashSet;
-
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
-import org.simantics.scl.compiler.common.names.Name;
+import org.simantics.scl.compiler.common.names.Names;
import org.simantics.scl.compiler.constants.Constant;
import org.simantics.scl.compiler.elaboration.contexts.EnvironmentalContext;
import org.simantics.scl.compiler.elaboration.contexts.TypingContext;
import org.simantics.scl.compiler.elaboration.expressions.Expressions;
import org.simantics.scl.compiler.elaboration.expressions.Variable;
import org.simantics.scl.compiler.elaboration.expressions.VariableProcedure;
+import org.simantics.scl.compiler.elaboration.expressions.block.BlockType;
import org.simantics.scl.compiler.elaboration.expressions.block.GuardStatement;
import org.simantics.scl.compiler.elaboration.expressions.block.LetStatement;
import org.simantics.scl.compiler.elaboration.expressions.block.Statement;
import org.simantics.scl.compiler.internal.codegen.references.IVal;
import org.simantics.scl.compiler.internal.elaboration.utils.ForcedClosure;
import org.simantics.scl.compiler.top.SCLCompilerConfiguration;
-import org.simantics.scl.compiler.top.SCLExpressionCompilationException;
-import org.simantics.scl.compiler.types.TCon;
import org.simantics.scl.compiler.types.Type;
import org.simantics.scl.compiler.types.Types;
-public class TransformationBuilder {
- private static final TCon UMap = Types.con("Unification", "UMap");
- private static final Name createUMap = Name.create("Unification", "createUMap");
-
- private static final TCon Unifiable = Types.con("Unification", "Unifiable");
- private static final Name uVar = Name.create("Unification", "uVar");
+import gnu.trove.map.hash.THashMap;
+import gnu.trove.map.hash.TIntObjectHashMap;
+import gnu.trove.map.hash.TObjectIntHashMap;
+import gnu.trove.set.hash.THashSet;
+public class TransformationBuilder {
private final ErrorLog errorLog;
private final TypingContext context;
private final UnifiableFactory unifiableFactory;
mappingRelation.parameterTypes[0]
});
mapping.umap = new Variable("map_" + mappingRelation.name.name,
- Types.apply(UMap, mappingRelation.parameterTypes)
+ Types.apply(Names.Unifiable_UMap, mappingRelation.parameterTypes)
);
mappings.put(mappingRelation, mapping);
mappingStatements.add(new LetStatement(new EVariable(mapping.umap),
- Expressions.apply(context, Types.PROC, createUMap,
+ Expressions.apply(context.getCompilationContext(), Types.PROC, Names.Unifiable_createUMap,
mappingRelation.parameterTypes[0],
mappingRelation.parameterTypes[1],
Expressions.punit())));
private static Expression statementsToExpression(EnvironmentalContext context, List<Statement> statements, Expression in) {
for(int i=statements.size()-1;i>=0;--i)
- in = statements.get(i).toExpression(context, false, in);
+ in = statements.get(i).toExpression(context, BlockType.Normal, in);
return in;
}
}
};
for(QMapping mapping : decomposed.targetMappings)
- mapping.parameters[0].forVariables(check);
+ mapping.parameters[0].forVariableUses(check);
sourceVariables = sourceVariableList.toArray(new Variable[sourceVariableList.size()]);
}
}
else {
PatternAnalyzer analyzer = new PatternAnalyzer(variableSet, mappedVariableUseCount);
- expression.forVariables(analyzer);
+ expression.forVariableUses(analyzer);
if(analyzer.containsVariables)
semiopenMappings.add(mapping);
int count = mappedVariableUseCount.get(variable);
if(count > 1) {
Variable uniVariable = new Variable("uvar_" + variable.getName(),
- Types.apply(Unifiable, variable.getType()));
+ Types.apply(Names.Unifiable_Unifiable, variable.getType()));
phase2Actions.add(new LetStatement(new EVariable(uniVariable),
- Expressions.apply(context, Types.PROC,
- uVar,
+ Expressions.apply(context.getCompilationContext(), Types.PROC,
+ Names.Unifiable_uVar,
variable.getType(),
Expressions.tuple())));
uniVariableMap.put(variable, uniVariable);
new QAtom(decomposed.ruleMatchingRelation,
Type.EMPTY_ARRAY,
Expressions.vars(sourceVariables)),
- statementsToExpression(context, phase2Actions),
+ statementsToExpression(context.getCompilationContext(), phase2Actions),
sourceVariables).compile(context)));
// Enforcing statement
for(int phase : phases.keys()) {
ArrayList<Query> targetQuery = phases.get(phase);
Expression enforcing = new EEnforce(new QConjunction(targetQuery.toArray(new Query[targetQuery.size()]))).compile(context);
- enforcing = statementsToExpression(context, phase3Actions, enforcing);
+ enforcing = statementsToExpression(context.getCompilationContext(), phase3Actions, enforcing);
enforcing = new EWhen(
rule.location,
new QAtom(decomposed.ruleMatchingRelation,
for(int phase : phases)
allEnforcingStatements.addAll(enforcingStatements.get(phase));
}
- Expression expression = statementsToExpression(context, allEnforcingStatements);
- expression = statementsToExpression(context, mappingStatements, expression);
+ Expression expression = statementsToExpression(context.getCompilationContext(), allEnforcingStatements);
+ expression = statementsToExpression(context.getCompilationContext(), mappingStatements, expression);
// Matching
Expression result = new ERuleset(