1 package org.simantics.scl.compiler.top;
3 import java.io.StringReader;
4 import java.lang.reflect.Method;
5 import java.util.ArrayList;
6 import java.util.ListIterator;
9 import org.simantics.scl.compiler.common.names.Name;
10 import org.simantics.scl.compiler.compilation.CodeGeneration;
11 import org.simantics.scl.compiler.compilation.CompilationContext;
12 import org.simantics.scl.compiler.constants.JavaStaticMethod;
13 import org.simantics.scl.compiler.constants.SCLConstant;
14 import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;
15 import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;
16 import org.simantics.scl.compiler.elaboration.contexts.TypingContext;
17 import org.simantics.scl.compiler.elaboration.errors.NotPatternException;
18 import org.simantics.scl.compiler.elaboration.expressions.EApply;
19 import org.simantics.scl.compiler.elaboration.expressions.EBlock;
20 import org.simantics.scl.compiler.elaboration.expressions.EConstant;
21 import org.simantics.scl.compiler.elaboration.expressions.EExternalConstant;
22 import org.simantics.scl.compiler.elaboration.expressions.EVar;
23 import org.simantics.scl.compiler.elaboration.expressions.Expression;
24 import org.simantics.scl.compiler.elaboration.expressions.block.GuardStatement;
25 import org.simantics.scl.compiler.elaboration.expressions.block.LetStatement;
26 import org.simantics.scl.compiler.elaboration.expressions.block.Statement;
27 import org.simantics.scl.compiler.elaboration.java.Builtins;
28 import org.simantics.scl.compiler.environment.Environment;
29 import org.simantics.scl.compiler.environment.LocalEnvironment;
30 import org.simantics.scl.compiler.errors.CompilationError;
31 import org.simantics.scl.compiler.errors.ErrorLog;
32 import org.simantics.scl.compiler.internal.codegen.references.IVal;
33 import org.simantics.scl.compiler.internal.codegen.ssa.SSAModule;
34 import org.simantics.scl.compiler.internal.codegen.types.DummyJavaReferenceValidator;
35 import org.simantics.scl.compiler.internal.codegen.types.JavaTypeTranslator;
36 import org.simantics.scl.compiler.internal.codegen.utils.CodeBuildingException;
37 import org.simantics.scl.compiler.internal.codegen.utils.JavaNamingPolicy;
38 import org.simantics.scl.compiler.internal.codegen.utils.ModuleBuilder;
39 import org.simantics.scl.compiler.internal.codegen.utils.TransientClassBuilder;
40 import org.simantics.scl.compiler.internal.codegen.utils.ValueFromMethod;
41 import org.simantics.scl.compiler.internal.codegen.writer.CodeWriter;
42 import org.simantics.scl.compiler.internal.codegen.writer.ExternalConstant;
43 import org.simantics.scl.compiler.internal.codegen.writer.ModuleWriter;
44 import org.simantics.scl.compiler.internal.elaboration.decomposed.DecomposedExpression;
45 import org.simantics.scl.compiler.internal.elaboration.utils.ExpressionDecorator;
46 import org.simantics.scl.compiler.internal.interpreted.IExpression;
47 import org.simantics.scl.compiler.internal.parsing.exceptions.SCLSyntaxErrorException;
48 import org.simantics.scl.compiler.internal.parsing.parser.SCLBlockParser;
49 import org.simantics.scl.compiler.internal.parsing.parser.SCLParserImpl;
50 import org.simantics.scl.compiler.internal.parsing.parser.SCLParserOptions;
51 import org.simantics.scl.compiler.runtime.MutableClassLoader;
52 import org.simantics.scl.compiler.runtime.RuntimeEnvironment;
53 import org.simantics.scl.compiler.types.TVar;
54 import org.simantics.scl.compiler.types.Type;
55 import org.simantics.scl.compiler.types.Types;
56 import org.simantics.scl.compiler.types.kinds.Kinds;
57 import org.simantics.scl.compiler.types.util.Polarity;
58 import org.simantics.scl.compiler.types.util.ProcedureType;
59 import org.simantics.scl.runtime.function.FunctionImpl1;
60 import org.simantics.scl.runtime.tuple.Tuple0;
62 import gnu.trove.set.hash.THashSet;
64 public class ExpressionEvaluator {
66 public static final boolean TRACE_INTERPRETATION_VS_COMPILATION = false;
67 private static final String COMPUTATION_METHOD_NAME = "main";
69 private final RuntimeEnvironment runtimeEnvironment;
70 private final String expressionText;
71 private Expression expression;
72 private Type expressionType;
74 private Type expectedEffect;
75 private boolean decorateExpression;
76 private Type expectedType;
77 private LocalEnvironment localEnvironment;
78 private LocalStorage localStorage;
79 private boolean interpretIfPossible = true;
80 private ExpressionParseMode parseMode = ExpressionParseMode.EXPRESSION;
81 private boolean validateOnly;
83 public ExpressionEvaluator(RuntimeEnvironment runtimeEnvironment,
84 String expressionText) {
85 if(runtimeEnvironment == null)
86 throw new NullPointerException();
87 if(expressionText == null)
88 throw new NullPointerException();
89 this.runtimeEnvironment = runtimeEnvironment;
90 this.expressionText = expressionText;
93 public ExpressionEvaluator(RuntimeEnvironment runtimeEnvironment,
94 LocalStorage localStorage, Expression expression) {
95 if(runtimeEnvironment == null)
96 throw new NullPointerException();
97 if(expression == null)
98 throw new NullPointerException();
99 this.runtimeEnvironment = runtimeEnvironment;
100 this.localStorage = localStorage;
101 this.expressionText = null;
102 this.expression = expression;
105 public ExpressionEvaluator expectedEffect(Type expectedEffect) {
106 this.expectedEffect = expectedEffect;
110 public ExpressionEvaluator decorateExpression(boolean decorateExpression) {
111 this.decorateExpression = decorateExpression;
115 public ExpressionEvaluator expectedType(Type expectedType) {
116 this.expectedType = expectedType;
120 public ExpressionEvaluator validateOnly(boolean validateOnly) {
121 this.validateOnly = validateOnly;
126 * Sets a local environment that can arbitrarily modify the resolving of the expression.
128 public ExpressionEvaluator localEnvironment(LocalEnvironment localEnvironment) {
129 this.localEnvironment = localEnvironment;
134 * Evaluates the expression by interpretation instead of compilation to bytecode
135 * if the expression does not contain language constructs that interpretation does
138 public ExpressionEvaluator interpretIfPossible(boolean interpretIfPossible) {
139 this.interpretIfPossible = interpretIfPossible;
144 * Assumes that top level of the expression is similar to the content
147 public ExpressionEvaluator parseAsBlock(boolean parseAsBlock) {
148 this.parseMode = parseAsBlock ? ExpressionParseMode.BLOCK : ExpressionParseMode.EXPRESSION;
152 public ExpressionEvaluator parseModel(ExpressionParseMode parseMode) {
153 this.parseMode = parseMode;
157 private void fillDefaults() {
158 if(expectedEffect == null)
159 expectedEffect = Types.metaVar(Kinds.EFFECT);
160 if(expectedType == null)
161 expectedType = Types.metaVar(Kinds.STAR);
164 private static class StoreFunction extends FunctionImpl1<Object, Object> {
165 final LocalStorage storage;
168 public StoreFunction(LocalStorage storage, String name, Type type) {
169 this.storage = storage;
174 public Object apply(Object value) {
175 Type type = Types.closure(this.type.convertMetaVarsToVars());
176 storage.store(name, value, type);
177 return Tuple0.INSTANCE;
181 public String toString() {
182 return "store_" + name;
186 public CompilationError[] validate() {
190 return CompilationError.EMPTY_ARRAY;
191 } catch(SCLExpressionCompilationException e) {
192 return e.getErrors();
196 public Object eval() throws SCLExpressionCompilationException {
199 final CompilationContext compilationContext = new CompilationContext();
200 final ErrorLog errorLog = compilationContext.errorLog;
201 final Environment environment = runtimeEnvironment.getEnvironment();
202 compilationContext.environment = environment;
205 if(expressionText != null) {
209 SCLBlockParser parser = new SCLBlockParser(new StringReader(expressionText));
210 parser.parseCommands();
211 expression = parser.block;
214 SCLParserImpl parser = new SCLParserImpl(new StringReader(expressionText));
215 expression = (Expression)parser.parseExp();
217 case EQUATION_BLOCK: {
218 SCLParserImpl parser = new SCLParserImpl(new StringReader(expressionText));
219 SCLParserOptions parserOptions = new SCLParserOptions();
220 parserOptions.supportEq = true;
221 parser.setParserOptions(parserOptions);
222 expression = (Expression)parser.parseEquationBlock();
225 } catch(SCLSyntaxErrorException e) {
226 errorLog.log(e.location, e.getMessage());
227 //System.out.println(errorLog.getErrorsAsString());
228 throw new SCLExpressionCompilationException(errorLog.getErrors());
229 } catch(Exception e) {
231 throw new SCLExpressionCompilationException(errorLog.getErrors());
235 // Store local variables
236 ArrayList<Type> lvTypes = new ArrayList<Type>();
237 if(expression instanceof EBlock) {
238 EBlock block = (EBlock)expression;
239 if(localStorage != null && !(block.getLast() instanceof GuardStatement)) {
240 THashSet<String> localVariables = new THashSet<String>();
241 ListIterator<Statement> it = block.getStatements().listIterator();
242 while(it.hasNext()) {
243 Statement stat = it.next();
244 if(!(stat instanceof LetStatement))
248 variableName = ((LetStatement)stat).pattern.getPatternHead().name;
249 } catch (NotPatternException e) {
252 localVariables.add(variableName);
254 for(String variableName : localVariables) {
255 Type type = Types.metaVar(Kinds.STAR);
257 block.addStatement(new GuardStatement(new EApply(
258 new EExternalConstant(
259 new StoreFunction(localStorage, variableName, type),
260 Types.functionE(type, Types.PROC, Types.UNIT)),
261 new EVar(variableName)
264 localStorage.store(variableName, null, type);
267 if(!(block.getLast() instanceof GuardStatement))
268 block.addStatement(new GuardStatement(new EConstant(Builtins.TUPLE_CONSTRUCTORS[0])));
273 TranslationContext context = new TranslationContext(compilationContext, localEnvironment);
274 expression = expression.resolve(context);
275 if(!errorLog.hasNoErrors())
276 throw new SCLExpressionCompilationException(errorLog.getErrors());
279 // Apply local environment
280 if(localEnvironment != null) {
281 expression = localEnvironment.preDecorateExpression(expression);
282 ProcedureType procedureType = localEnvironment.decorateExpectedType(expectedType, expectedEffect);
283 expectedType = procedureType.type;
284 expectedEffect = procedureType.effect;
289 TypingContext context = new TypingContext(compilationContext);
291 context.pushEffectUpperBound(expression.location, expectedEffect);
292 expression = expression.checkType(context, expectedType);
293 context.popEffectUpperBound();
295 for(Type lvType : lvTypes)
296 lvType.addPolarity(Polarity.POSITIVE);
298 expectedType.addPolarity(Polarity.POSITIVE);
299 context.solveSubsumptions(expression.location);
300 if(!errorLog.hasNoErrors())
301 throw new SCLExpressionCompilationException(errorLog.getErrors());
302 if(decorateExpression && Types.canonical(expectedEffect) != Types.NO_EFFECTS) {
303 ExpressionDecorator decorator =
304 new ToplevelEffectDecorator(errorLog, environment);
305 expression = expression.decorate(decorator);
307 expression = context.solveConstraints(environment, expression);
308 expressionType = expression.getType();
310 if(!errorLog.hasNoErrors())
311 throw new SCLExpressionCompilationException(errorLog.getErrors());
313 if(localEnvironment != null)
314 expression = localEnvironment.postDecorateExpression(expression);
319 Type type = expression.getType();
320 type = type.convertMetaVarsToVars();
322 for(Type lvType : lvTypes)
323 lvType.convertMetaVarsToVars();
325 ArrayList<TVar> varsList = Types.freeVars(type);
326 expression = expression.closure(varsList.toArray(new TVar[varsList.size()]));
329 // Initialize code generation
330 MutableClassLoader classLoader = runtimeEnvironment.getMutableClassLoader();
331 String moduleName = classLoader.getFreshPackageName();
332 JavaTypeTranslator javaTypeTranslator = new JavaTypeTranslator(environment);
333 compilationContext.javaTypeTranslator = javaTypeTranslator;
334 JavaNamingPolicy namingPolicy = new JavaNamingPolicy(moduleName);
335 compilationContext.namingPolicy = namingPolicy;
337 ModuleBuilder moduleBuilder = new ModuleBuilder(namingPolicy, javaTypeTranslator);
340 SimplificationContext context =
341 new SimplificationContext(compilationContext, DummyJavaReferenceValidator.INSTANCE);
342 expression = expression.simplify(context);
344 if(!errorLog.hasNoErrors())
345 throw new SCLExpressionCompilationException(errorLog.getErrors());
347 if(SCLCompilerConfiguration.SHOW_EXPRESSION_BEFORE_EVALUATION)
348 System.out.println(expression);
350 if(interpretIfPossible) {
353 ExpressionInterpretationContext expressionInterpretationContext =
354 new ExpressionInterpretationContext(runtimeEnvironment,
355 new TransientClassBuilder(classLoader, javaTypeTranslator));
356 IExpression iexp = expression.toIExpression(expressionInterpretationContext);
357 if(TRACE_INTERPRETATION_VS_COMPILATION)
358 System.out.println("INTERPRETED " + expressionText);
359 if(SCLCompilerConfiguration.SHOW_INTERPRETED_EXPRESSION)
360 System.out.println("INTERPRETED AS: " + iexp);
361 return iexp.execute(new Object[expressionInterpretationContext.getMaxVariableId()]);
362 } catch(UnsupportedOperationException e) {
363 // This is normal when expression cannot be interpreted. We compile it instead.
368 ModuleWriter mw = new ModuleWriter(namingPolicy.getModuleClassName());
369 DecomposedExpression decomposed =
370 DecomposedExpression.decompose(errorLog, expression);
372 SCLConstant constant = new SCLConstant(
373 Name.create(moduleName, COMPUTATION_METHOD_NAME),
374 expression.getType());
375 constant.setBase(new JavaStaticMethod(
376 moduleName, COMPUTATION_METHOD_NAME,
378 decomposed.typeParameters,
379 decomposed.returnType,
380 decomposed.parameterTypes));
382 CodeWriter w = mw.createFunction(constant,
383 decomposed.typeParameters,
385 decomposed.returnType,
386 decomposed.parameterTypes);
387 constant.setDefinition(w.getFunction());
388 IVal[] parameterVals = w.getParameters();
389 for(int i=0;i<decomposed.parameters.length;++i)
390 decomposed.parameters[i].setVal(parameterVals[i]);
391 w.return_(decomposed.body.toVal(compilationContext, w));
392 } catch(RuntimeException e) {
393 errorLog.setExceptionPosition(expression.location);
394 throw new SCLExpressionCompilationException(errorLog.getErrors());
397 SSAModule ssaModule = mw.getModule();
398 if(SCLCompilerConfiguration.SHOW_SSA_BEFORE_OPTIMIZATION) {
399 System.out.println("=== SSA before optimization ==================================");
400 System.out.println(ssaModule);
402 if(SCLCompilerConfiguration.DEBUG)
403 ssaModule.validate();
405 ExternalConstant[] externalConstants = mw.getExternalConstants();
408 for(int phase=0;phase<CodeGeneration.OPTIMIZATION_PHASES;++phase) {
410 while(optCount++ < 4 && ssaModule.simplify(environment, phase)) {
411 //System.out.println("simplify " + optCount);
414 if(SCLCompilerConfiguration.SHOW_SSA_BEFORE_LAMBDA_LIFTING) {
415 System.out.println("=== SSA before lambda lifting ==================================");
416 System.out.println(ssaModule);
418 //ssaModule.saveInlinableDefinitions();
419 ssaModule.lambdaLift(errorLog);
420 //ssaModule.validate();
421 ssaModule.markGenerateOnFly();
424 if(SCLCompilerConfiguration.SHOW_FINAL_SSA)
425 System.out.println(ssaModule);
427 ssaModule.generateCode(moduleBuilder);
428 } catch (CodeBuildingException e) {
430 throw new SCLExpressionCompilationException(errorLog.getErrors());
432 Map<String, byte[]> classes = moduleBuilder.getClasses();
435 // Load generated code and execute
437 classLoader.addClasses(classes);
438 Class<?> clazz = classLoader.loadClass(MutableClassLoader.SCL_PACKAGE_PREFIX + moduleName);
439 for(ExternalConstant externalConstant : externalConstants)
440 clazz.getField(externalConstant.fieldName).set(null, externalConstant.value);
441 for(Method method : clazz.getMethods()) {
442 if(method.getName().equals(COMPUTATION_METHOD_NAME))
443 return ValueFromMethod.getValueFromStaticMethod(method);
445 errorLog.log("Internal compiler error: didn't find method " +
446 COMPUTATION_METHOD_NAME + " from generated byte code.");
447 throw new SCLExpressionCompilationException(errorLog.getErrors());
448 } catch(ReflectiveOperationException e) {
450 throw new SCLExpressionCompilationException(errorLog.getErrors());
454 public Type getType() {
455 return expressionType;
458 public String getExpressionText() {
459 return expressionText;