X-Git-Url: https://gerrit.simantics.org/r/gitweb?p=simantics%2Fplatform.git;a=blobdiff_plain;f=bundles%2Forg.simantics.scl.compiler%2Fsrc%2Forg%2Fsimantics%2Fscl%2Fcompiler%2Felaboration%2Fexpressions%2FEBlock.java;h=c21732557ba555f5ce950058e0eddaaab468182a;hp=ff131254081f7c4ce0a27b3bf9a18cf29fbc9195;hb=82a87b8535628d47d9c381e1a3a2296fb67c7fd0;hpb=06718abb2b3cc780748553811c4857c165499809

diff --git a/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/expressions/EBlock.java b/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/expressions/EBlock.java
old mode 100755
new mode 100644
index ff1312540..c21732557
--- a/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/expressions/EBlock.java
+++ b/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/expressions/EBlock.java
@@ -1,43 +1,59 @@
 package org.simantics.scl.compiler.elaboration.expressions;
 
 import java.util.ArrayList;
-import java.util.LinkedList;
 import java.util.List;
 
-import org.simantics.scl.compiler.common.exceptions.InternalCompilerError;
+import org.simantics.scl.compiler.elaboration.chr.CHRRule;
+import org.simantics.scl.compiler.elaboration.chr.CHRRuleset;
+import org.simantics.scl.compiler.elaboration.chr.ast.CHRQueryTranslationMode;
+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.BlockType;
+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.IncludeStatement;
 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 {
 
-    LinkedList<Statement> statements = new LinkedList<Statement>();
-    boolean monadic;
+    public ArrayList<Statement> statements = new ArrayList<Statement>();
+    BlockType blockType = BlockType.Normal;
     
     public EBlock() {
+        this.blockType = blockType;
+    }
+    
+    public void setBlockType(BlockType blockType) {
+        this.blockType = blockType;
     }
 
     public void addStatement(Statement statement) {
         statements.add(statement);
     }
     
-    public void setMonadic(boolean monadic) {
-        this.monadic = monadic;
+    public ArrayList<Statement> getStatements() {
+        return statements;
+    }
+    
+    public Statement getFirst() {
+        return statements.get(0);
     }
     
-    public LinkedList<Statement> getStatements() {
-        return statements;
+    public Statement getLast() {
+        return statements.get(statements.size()-1);
     }
 
     @Override
     public Expression resolve(TranslationContext context) {
         if(statements.isEmpty()) {
-            context.getErrorLog().log(location, "Block must contain at least one statement.");
+            context.getErrorLog().log(location, "Block should not be empty.");
             return new EError(location);
-        } 
+        }
         int i = statements.size()-1;
         Statement last = statements.get(i);
         if(!(last instanceof GuardStatement)) {
@@ -48,21 +64,29 @@ public class EBlock extends ASTExpression {
         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, blockType, 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: {
+                    CHRRuleset ruleset = extractCHRRules(context, i, endId);
+                    long location = Locations.combine(ruleset.location, in.location);
+                    in = new ECHRRuleset(ruleset, in);
+                    in.location = location;
+                    break;
+                }
+                }
             }
-            else
-                in = cur.toExpression(context, monadic, in);
         }
         return in.resolve(context);
     }
@@ -70,7 +94,32 @@ public class EBlock extends ASTExpression {
     private Expression extractRules(int begin, int end, Expression in) {
         return new EPreRuleset(statements.subList(begin, end).toArray(new RuleStatement[end-begin]), in);
     }
+    
+    private CHRRuleset extractCHRRules(TranslationContext context, int begin, int end) {
+        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) {
+                CHRStatement chrStatement = (CHRStatement)statement;
+                ruleset.addRule(new CHRRule(chrStatement.location,
+                        chrStatement.head.translate(context, CHRQueryTranslationMode.RULE_HEAD),
+                        chrStatement.body.translate(context, CHRQueryTranslationMode.RULE_BODY)));
+            }
+            else if(statement instanceof ConstraintStatement)
+                ruleset.constraints.add(CHRTranslation.convertConstraintStatement(context, (ConstraintStatement)statement));
+            else if(statement instanceof IncludeStatement)
+                ruleset.includes.add((IncludeStatement)statement);
+            else
+                context.getErrorLog().log(statement.location, "Invalid CHR statement.");
+        }
+        return ruleset;
+    }
 
+    public CHRRuleset extractCHRRules(TranslationContext context) {
+        return extractCHRRules(context, 0, statements.size());
+    }
+    
     @SuppressWarnings("unchecked")
     private Expression extractLet(int begin, int end, Expression in) {
         return new EPreLet((List<LetStatement>)(List<?>)statements.subList(begin, end), in);
@@ -97,4 +146,18 @@ public class EBlock extends ASTExpression {
         return transformer.transform(this);
     }
 
+    @Override
+    public int getSyntacticFunctionArity() {
+        if(blockType != BlockType.Normal)
+            return 0;
+        Statement lastStatement = statements.get(statements.size()-1);
+        if(!(lastStatement instanceof GuardStatement))
+            return 0;
+        return ((GuardStatement)lastStatement).value.getSyntacticFunctionArity();
+    }
+    
+    @Override
+    public void accept(ExpressionVisitor visitor) {
+        visitor.visit(this);
+    }
 }