import java.util.List;
import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;
+import org.simantics.scl.compiler.elaboration.chr.CHRRuleset;
+import org.simantics.scl.compiler.elaboration.chr.translation.CHRTranslation;
import org.simantics.scl.compiler.elaboration.contexts.TranslationContext;
+import org.simantics.scl.compiler.elaboration.expressions.block.CHRStatement;
+import org.simantics.scl.compiler.elaboration.expressions.block.ConstraintStatement;
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.RuleStatement;
import org.simantics.scl.compiler.elaboration.expressions.block.Statement;
+import org.simantics.scl.compiler.elaboration.expressions.block.StatementGroup;
import org.simantics.scl.compiler.errors.Locations;
public class EBlock extends ASTExpression {
@Override
public Expression resolve(TranslationContext context) {
- if(statements.isEmpty()) {
- context.getErrorLog().log(location, "Block must contain at least one statement.");
- return new EError(location);
- }
+ if(statements.isEmpty())
+ throw new InternalCompilerError();
int i = statements.size()-1;
Statement last = statements.get(i);
if(!(last instanceof GuardStatement)) {
Expression in = ((GuardStatement)last).value;
while(--i >= 0) {
Statement cur = statements.get(i);
- if(cur instanceof RuleStatement) {
- int endId = i+1;
- while(i>0 && statements.get(i-1) instanceof RuleStatement)
- --i;
- in = extractRules(i, endId, in);
- }
- else if(cur instanceof LetStatement && ((LetStatement)cur).pattern.isFunctionPattern()) {
+ StatementGroup group = cur.getStatementGroup();
+ if(group == null)
+ in = cur.toExpression(context, monadic, in);
+ else {
int endId = i+1;
- while(i>0 && (cur = statements.get(i-1)) instanceof LetStatement &&
- ((LetStatement)cur).pattern.isFunctionPattern())
+ while(i>0 && statements.get(i-1).getStatementGroup() == group)
--i;
- in = extractLet(i, endId, in);
+ switch(group) {
+ case LetFunction:
+ in = extractLet(i, endId, in);
+ break;
+ case Rule:
+ in = extractRules(i, endId, in);
+ break;
+ case CHR:
+ in = extractCHRRules(context, i, endId, in);
+ break;
+ }
}
- else
- in = cur.toExpression(context, monadic, in);
}
return in.resolve(context);
}
private Expression extractRules(int begin, int end, Expression in) {
return new EPreRuleset(statements.subList(begin, end).toArray(new RuleStatement[end-begin]), in);
}
+
+ private Expression extractCHRRules(TranslationContext context, int begin, int end, Expression in) {
+ CHRRuleset ruleset = new CHRRuleset();
+ ruleset.location = Locations.combine(statements.get(begin).location, statements.get(end-1).location);
+ for(int i=begin;i<end;++i) {
+ Statement statement = statements.get(i);
+ if(statement instanceof CHRStatement)
+ ruleset.rules.add(CHRTranslation.convertCHRStatement(context, (CHRStatement)statement));
+ else if(statement instanceof ConstraintStatement)
+ ruleset.constraints.add(CHRTranslation.convertConstraintStatement(context, (ConstraintStatement)statement));
+ else
+ throw new InternalCompilerError("Invalid CHR statement.");
+ }
+ return new ECHRRuleset(ruleset, in);
+ }
@SuppressWarnings("unchecked")
private Expression extractLet(int begin, int end, Expression in) {
return transformer.transform(this);
}
+ @Override
+ public int getSyntacticFunctionArity() {
+ if(monadic)
+ return 0;
+ Statement lastStatement = statements.getLast();
+ if(!(lastStatement instanceof GuardStatement))
+ return 0;
+ return ((GuardStatement)lastStatement).value.getSyntacticFunctionArity();
+ }
+
+ @Override
+ public void accept(ExpressionVisitor visitor) {
+ visitor.visit(this);
+ }
}