-package org.simantics.scl.compiler.elaboration.expressions;\r
-\r
-import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;\r
-import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;\r
-import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;\r
-import org.simantics.scl.compiler.elaboration.contexts.TypingContext;\r
-import org.simantics.scl.compiler.environment.Environment;\r
-import org.simantics.scl.compiler.errors.Locations;\r
-import org.simantics.scl.compiler.internal.codegen.continuations.ICont;\r
-import org.simantics.scl.compiler.internal.codegen.references.IVal;\r
-import org.simantics.scl.compiler.internal.codegen.ssa.exits.Throw;\r
-import org.simantics.scl.compiler.internal.codegen.writer.CodeWriter;\r
-import org.simantics.scl.compiler.internal.elaboration.utils.ExpressionDecorator;\r
-import org.simantics.scl.compiler.types.Type;\r
-import org.simantics.scl.compiler.types.Types;\r
-import org.simantics.scl.compiler.types.exceptions.MatchException;\r
-\r
-import gnu.trove.map.hash.TObjectIntHashMap;\r
-import gnu.trove.set.hash.THashSet;\r
-import gnu.trove.set.hash.TIntHashSet;\r
-\r
-public class GuardedExpressionGroup extends Expression {\r
- public GuardedExpression[] expressions;\r
-\r
- public GuardedExpressionGroup(GuardedExpression[] expressions) {\r
- this.expressions = expressions;\r
- }\r
-\r
- @Override\r
- public void collectRefs(TObjectIntHashMap<Object> allRefs,\r
- TIntHashSet refs) {\r
- for(GuardedExpression expression : expressions) {\r
- for(Expression guard : expression.guards)\r
- guard.collectRefs(allRefs, refs);\r
- expression.value.collectRefs(allRefs, refs);\r
- }\r
- }\r
-\r
- @Override\r
- public void collectVars(TObjectIntHashMap<Variable> allVars,\r
- TIntHashSet vars) {\r
- for(GuardedExpression expression : expressions) {\r
- for(Expression guard : expression.guards)\r
- guard.collectVars(allVars, vars);\r
- expression.value.collectVars(allVars, vars);\r
- }\r
- }\r
-\r
- @Override\r
- protected void updateType() throws MatchException {\r
- setType(expressions[0].value.getType());\r
- }\r
-\r
- @Override\r
- public IVal toVal(Environment env, CodeWriter w) {\r
- CodeWriter success = w.createBlock(getType());\r
- IVal result = success.getParameters()[0];\r
- CodeWriter failure = w.createBlock();\r
- compile(env, w, success.getContinuation(), failure.getContinuation());\r
- w.continueAs(success);\r
- failure.throw_(location, Throw.MatchingException, "Matching failure at: " + toString());\r
- return result;\r
- //throw new InternalCompilerError("GuardedExpressionGroup should be handled in match compilation.");\r
- }\r
-\r
- @Override\r
- public void collectFreeVariables(THashSet<Variable> vars) {\r
- for(GuardedExpression expression : expressions) {\r
- for(Expression guard : expression.guards)\r
- guard.collectFreeVariables(vars);\r
- expression.value.collectFreeVariables(vars);\r
- }\r
- }\r
-\r
- @Override\r
- public Expression simplify(SimplificationContext context) {\r
- for(GuardedExpression expression : expressions) {\r
- for(int i=0;i<expression.guards.length;++i)\r
- expression.guards[i] = expression.guards[i].simplify(context);\r
- expression.value = expression.value.simplify(context);\r
- }\r
- return this;\r
- }\r
-\r
- @Override\r
- public Expression resolve(TranslationContext context) {\r
- for(GuardedExpression expression : expressions) {\r
- for(int i=0;i<expression.guards.length;++i)\r
- expression.guards[i] = expression.guards[i].resolve(context);\r
- expression.value = expression.value.resolve(context);\r
- }\r
- return this;\r
- }\r
- \r
- @Override\r
- public Expression checkBasicType(TypingContext context, Type requiredType) {\r
- for(GuardedExpression expression : expressions) {\r
- for(int i=0;i<expression.guards.length;++i)\r
- expression.guards[i] = expression.guards[i].checkType(context, Types.BOOLEAN);\r
- expression.value = expression.value.checkType(context, requiredType);\r
- }\r
- return this;\r
- }\r
- \r
- public void compile(Environment env, CodeWriter firstWriter, ICont success,\r
- ICont lastFailure) {\r
- // Create all code blocks\r
- CodeWriter[] writers = new CodeWriter[expressions.length]; \r
- ICont[] failures = new ICont[expressions.length];\r
- writers[0] = firstWriter;\r
- failures[expressions.length-1] = lastFailure;\r
- for(int i=1;i<expressions.length;++i) {\r
- CodeWriter writer = firstWriter.createBlock();\r
- writers[i] = writer;\r
- failures[i-1] = writer.getContinuation();\r
- }\r
- \r
- // Compile\r
- for(int i=0;i<expressions.length;++i) {\r
- CodeWriter w = writers[i];\r
- ICont failure = failures[i];\r
- \r
- for(Expression guard : expressions[i].guards) {\r
- CodeWriter nextW = w.createBlock();\r
- w.if_(guard.toVal(env, w), nextW.getContinuation(), failure);\r
- w = nextW;\r
- }\r
- \r
- w.jump(success, expressions[i].value.toVal(env, w));\r
- }\r
- }\r
- \r
- @Override\r
- public Expression replace(ReplaceContext context) {\r
- GuardedExpression[] newExpressions = new GuardedExpression[expressions.length];\r
- for(int i=0;i<expressions.length;++i)\r
- newExpressions[i] = expressions[i].replace(context);\r
- return new GuardedExpressionGroup(newExpressions); \r
- }\r
-\r
- @Override\r
- public Expression decorate(ExpressionDecorator decorator) {\r
- for(GuardedExpression expression : expressions)\r
- expression.decorate(decorator);\r
- return decorator.decorate(this);\r
- }\r
-\r
- @Override\r
- public void collectEffects(THashSet<Type> effects) {\r
- for(GuardedExpression ge : expressions) {\r
- for(Expression guard : ge.guards)\r
- guard.collectEffects(effects);\r
- ge.value.collectEffects(effects);\r
- }\r
- }\r
- \r
- @Override\r
- public void setLocationDeep(long loc) {\r
- if(location == Locations.NO_LOCATION) {\r
- location = loc;\r
- for(GuardedExpression expression : expressions)\r
- expression.setLocationDeep(loc);\r
- }\r
- }\r
- \r
- @Override\r
- public void accept(ExpressionVisitor visitor) {\r
- visitor.visit(this);\r
- }\r
-\r
- @Override\r
- public void forVariables(VariableProcedure procedure) {\r
- for(GuardedExpression expression : expressions)\r
- expression.forVariables(procedure);\r
- }\r
-\r
- @Override\r
- public Expression accept(ExpressionTransformer transformer) {\r
- return transformer.transform(this);\r
- }\r
-}\r
+package org.simantics.scl.compiler.elaboration.expressions;
+
+import org.simantics.scl.compiler.elaboration.contexts.ReplaceContext;
+import org.simantics.scl.compiler.elaboration.contexts.SimplificationContext;
+import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;
+import org.simantics.scl.compiler.elaboration.contexts.TypingContext;
+import org.simantics.scl.compiler.environment.Environment;
+import org.simantics.scl.compiler.errors.Locations;
+import org.simantics.scl.compiler.internal.codegen.continuations.ICont;
+import org.simantics.scl.compiler.internal.codegen.references.IVal;
+import org.simantics.scl.compiler.internal.codegen.ssa.exits.Throw;
+import org.simantics.scl.compiler.internal.codegen.writer.CodeWriter;
+import org.simantics.scl.compiler.internal.elaboration.utils.ExpressionDecorator;
+import org.simantics.scl.compiler.types.Type;
+import org.simantics.scl.compiler.types.Types;
+import org.simantics.scl.compiler.types.exceptions.MatchException;
+
+import gnu.trove.map.hash.TObjectIntHashMap;
+import gnu.trove.set.hash.THashSet;
+import gnu.trove.set.hash.TIntHashSet;
+
+public class GuardedExpressionGroup extends Expression {
+ public GuardedExpression[] expressions;
+
+ public GuardedExpressionGroup(GuardedExpression[] expressions) {
+ this.expressions = expressions;
+ }
+
+ @Override
+ public void collectRefs(TObjectIntHashMap<Object> allRefs,
+ TIntHashSet refs) {
+ for(GuardedExpression expression : expressions) {
+ for(Expression guard : expression.guards)
+ guard.collectRefs(allRefs, refs);
+ expression.value.collectRefs(allRefs, refs);
+ }
+ }
+
+ @Override
+ public void collectVars(TObjectIntHashMap<Variable> allVars,
+ TIntHashSet vars) {
+ for(GuardedExpression expression : expressions) {
+ for(Expression guard : expression.guards)
+ guard.collectVars(allVars, vars);
+ expression.value.collectVars(allVars, vars);
+ }
+ }
+
+ @Override
+ protected void updateType() throws MatchException {
+ setType(expressions[0].value.getType());
+ }
+
+ @Override
+ public IVal toVal(Environment env, CodeWriter w) {
+ CodeWriter success = w.createBlock(getType());
+ IVal result = success.getParameters()[0];
+ CodeWriter failure = w.createBlock();
+ compile(env, w, success.getContinuation(), failure.getContinuation());
+ w.continueAs(success);
+ failure.throw_(location, Throw.MatchingException, "Matching failure at: " + toString());
+ return result;
+ //throw new InternalCompilerError("GuardedExpressionGroup should be handled in match compilation.");
+ }
+
+ @Override
+ public void collectFreeVariables(THashSet<Variable> vars) {
+ for(GuardedExpression expression : expressions) {
+ for(Expression guard : expression.guards)
+ guard.collectFreeVariables(vars);
+ expression.value.collectFreeVariables(vars);
+ }
+ }
+
+ @Override
+ public Expression simplify(SimplificationContext context) {
+ for(GuardedExpression expression : expressions) {
+ for(int i=0;i<expression.guards.length;++i)
+ expression.guards[i] = expression.guards[i].simplify(context);
+ expression.value = expression.value.simplify(context);
+ }
+ return this;
+ }
+
+ @Override
+ public Expression resolve(TranslationContext context) {
+ for(GuardedExpression expression : expressions) {
+ for(int i=0;i<expression.guards.length;++i)
+ expression.guards[i] = expression.guards[i].resolve(context);
+ expression.value = expression.value.resolve(context);
+ }
+ return this;
+ }
+
+ @Override
+ public Expression checkBasicType(TypingContext context, Type requiredType) {
+ for(GuardedExpression expression : expressions) {
+ for(int i=0;i<expression.guards.length;++i)
+ expression.guards[i] = expression.guards[i].checkType(context, Types.BOOLEAN);
+ expression.value = expression.value.checkType(context, requiredType);
+ }
+ return this;
+ }
+
+ public void compile(Environment env, CodeWriter firstWriter, ICont success,
+ ICont lastFailure) {
+ // Create all code blocks
+ CodeWriter[] writers = new CodeWriter[expressions.length];
+ ICont[] failures = new ICont[expressions.length];
+ writers[0] = firstWriter;
+ failures[expressions.length-1] = lastFailure;
+ for(int i=1;i<expressions.length;++i) {
+ CodeWriter writer = firstWriter.createBlock();
+ writers[i] = writer;
+ failures[i-1] = writer.getContinuation();
+ }
+
+ // Compile
+ for(int i=0;i<expressions.length;++i) {
+ CodeWriter w = writers[i];
+ ICont failure = failures[i];
+
+ for(Expression guard : expressions[i].guards) {
+ CodeWriter nextW = w.createBlock();
+ w.if_(guard.toVal(env, w), nextW.getContinuation(), failure);
+ w = nextW;
+ }
+
+ w.jump(success, expressions[i].value.toVal(env, w));
+ }
+ }
+
+ @Override
+ public Expression replace(ReplaceContext context) {
+ GuardedExpression[] newExpressions = new GuardedExpression[expressions.length];
+ for(int i=0;i<expressions.length;++i)
+ newExpressions[i] = expressions[i].replace(context);
+ return new GuardedExpressionGroup(newExpressions);
+ }
+
+ @Override
+ public Expression decorate(ExpressionDecorator decorator) {
+ for(GuardedExpression expression : expressions)
+ expression.decorate(decorator);
+ return decorator.decorate(this);
+ }
+
+ @Override
+ public void collectEffects(THashSet<Type> effects) {
+ for(GuardedExpression ge : expressions) {
+ for(Expression guard : ge.guards)
+ guard.collectEffects(effects);
+ ge.value.collectEffects(effects);
+ }
+ }
+
+ @Override
+ public void setLocationDeep(long loc) {
+ if(location == Locations.NO_LOCATION) {
+ location = loc;
+ for(GuardedExpression expression : expressions)
+ expression.setLocationDeep(loc);
+ }
+ }
+
+ @Override
+ public void accept(ExpressionVisitor visitor) {
+ visitor.visit(this);
+ }
+
+ @Override
+ public void forVariables(VariableProcedure procedure) {
+ for(GuardedExpression expression : expressions)
+ expression.forVariables(procedure);
+ }
+
+ @Override
+ public Expression accept(ExpressionTransformer transformer) {
+ return transformer.transform(this);
+ }
+
+ @Override
+ public int getSyntacticFunctionArity() {
+ return expressions[0].value.getSyntacticFunctionArity();
+ }
+}
Code Review / simantics / platform.git / blobdiff