source: proto/s2k/trunk/framework/src/toolchain/s2k/transformer/visitors/S2K2S2K/TempifyCarrySetBuiltinCalls.java @ 4020

/*
 * Converts carry generating builtins expressions to compiled form.
 * Applied before carry variable insertion.
 *
 * @author Ken Herdy <ksherdy at sfu dot ca>
 * 
 * Case 1: 'assignment' statement
 * 
 * returnValue = pablo.BUILTIN_CALL(args)  
 * 
 * =>
 * 
 * stream temp; 
 * temp = pablo_blk_BUILTIN_CALL(args);
 *   
 * Case 2: 'if' condition
 *
 * if(pablo.BUILTIN_CALL(args) { ... } 
 * 
 * }  
 *
 * =>
 *
 * stream temp;
 * temp = pablo_blk_BUILTIN_CALL(args);
 * if(temp) { ... }
 *
 * Case 3: 'while' condition
 * 
 * while(pablo.BUILTIN_CALL(args) { ... }  
 *
 * =>
 * 
 * stream temp:
 * temp = pablo_blk_BUILTIN_CALL(args);
 * while(temp) {
 *  ...
 *   
 *  stream temp:
 *  temp = pablo_blk_BUILTIN_CALL(args);  
 * }  
 *   
 */
package toolchain.s2k.transformer.visitors.S2K2S2K;

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import s2k.ast.*;
import s2k.inputHandler.Locator;
import toolchain.s2k.ast.Accessors;
import toolchain.s2k.ast.Generators;
import toolchain.s2k.lang.builtin.S2KBuiltinsUtil;
import toolchain.util.Labeller;
import toolchain.util.Pair;
import static toolchain.util.MapUtil.*;

public class TempifyCarrySetBuiltinCalls {
        
        static public ASTNode apply(ASTNode ASTree) {
            
            ASTNode xTree = SplitVarDeclInits.apply(ASTree);
            
            Tempifier tempifier = new Tempifier();
            xTree.accept(tempifier);
                return ASTree;                  
        }   
    
        static private class Tempifier extends VoidVisitor.Default {
            
            Labeller labeller;
            Map<ASTNode, List<ASTNode>> enclBlockStmtTempDecls; 
            Map<ASTNode, List<Pair<ASTNode, List<ASTNode>>>> tempDeclsInsertionChild;
            
            Map<ASTNode, List<ASTNode>> enclBlockStmtTempAssigns; 
            Map<ASTNode, List<Pair<ASTNode, List<ASTNode>>>> tempAssignsInsertionChild;

            public Tempifier() {
                this(0);
            }

            public Tempifier(int nextValue) {
                labeller = new Labeller("_temp");
                labeller.setNextValue(nextValue);

            enclBlockStmtTempDecls = new LinkedHashMap<ASTNode, List<ASTNode>>();
            enclBlockStmtTempAssigns = new LinkedHashMap<ASTNode, List<ASTNode>>();
                
                tempDeclsInsertionChild = new LinkedHashMap<ASTNode, List<Pair<ASTNode, List<ASTNode>>>>();
                tempAssignsInsertionChild = new LinkedHashMap<ASTNode, List<Pair<ASTNode, List<ASTNode>>>>();
            }

        //////////////////////////////////////////////////////////////
        // visitor callbacks
            
            public void visitEnter(FilterDefNode node) {
                labeller.reset();
                
                enclBlockStmtTempDecls.clear();
                enclBlockStmtTempAssigns.clear();
                
                tempDeclsInsertionChild.clear();
                tempAssignsInsertionChild.clear();
            }
            
            public void visitLeave(BlockStmtNode node) {
            insertTempDecls(node);
            insertTempAssigns(node);
            }
    
            public void visitLeave(AssignNode node) {
            bindTempDeclsToBlockStmt(node);
            bindTempAssignToBlockStmt(node);            
            }
            
            public void visitLeave(WhileStmtNode node) {

                appendTempDeclsToWhileBody(node);      // WARNING: appendTemp calls must precede bindTemp calls
            appendTempAssignsToWhileBody(node);
                
                bindTempDeclsToBlockStmt(node);
            bindTempAssignToBlockStmt(node);
            }

        public void visitLeave(IfStmtNode node) {
            bindTempDeclsToBlockStmt(node);
            bindTempAssignToBlockStmt(node);
        }

        public void visitLeave(FuncCallNode node) { 
            
            
            if(S2KBuiltinsUtil.isCarry(node)) {
                
                if(!(node.getParent() instanceof AssignNode)) {
                
                    BlockStmtNode blockStmt          = Accessors.getEnclosingBlockStmt(node);
                    Locator locator                  = blockStmt;
                    IdentifierNode name              = Generators.makeIdentifierNode(locator, labeller.newLabel());
                    StreamTypeNode type              = Generators.makeStreamType(locator);
                    VarDeclNode varDecl              = Generators.makeVarDeclNode(locator, type, name.deepCopy());
                    AssignNode assignStmt            = Generators.makeAssignNode(locator, name.deepCopy(), node.deepCopy());

                    addValueToList(enclBlockStmtTempDecls, blockStmt, varDecl);
                    addValueToList(enclBlockStmtTempAssigns, blockStmt, assignStmt);

                    node.updateSelf(name);                
                }
            }
        }
        
        //////////////////////////////////////////////////////////////
        // helpers
        
        private void appendTempAssignsToWhileBody(WhileStmtNode node) {
            BlockStmtNode whileBody    = Accessors.body(node);
            BlockStmtNode blockStmt    = Accessors.getEnclosingBlockStmt(node);
            if(enclBlockStmtTempAssigns.containsKey(blockStmt)) {
                for(ASTNode tempAssign : enclBlockStmtTempAssigns.get(blockStmt)) {
                    whileBody.appendChild(tempAssign);
                }
            }
        }

        private void appendTempDeclsToWhileBody(WhileStmtNode node) {
            BlockStmtNode whileBody    = Accessors.body(node);
            BlockStmtNode blockStmt    = Accessors.getEnclosingBlockStmt(node);
            if(enclBlockStmtTempDecls.containsKey(blockStmt)) {
                for(ASTNode tempDecl : enclBlockStmtTempDecls.get(blockStmt)) {
                    whileBody.appendChild(tempDecl);
                }
            }
        }
        
        private void insertTempAssigns(BlockStmtNode node) {
            if(tempAssignsInsertionChild.containsKey(node)) {
                List<Pair<ASTNode, List<ASTNode>>> pairs = tempAssignsInsertionChild.get(node);
                for(Pair<ASTNode, List<ASTNode>> pair : pairs) {
                    for(ASTNode predecessor : pair.right()) {
                        node.insertBeforeChild(pair.left(), predecessor);
                    }
                }
            }
        }

        private void insertTempDecls(BlockStmtNode node) {
            if(tempDeclsInsertionChild.containsKey(node)) {
                List<Pair<ASTNode, List<ASTNode>>> pairs = tempDeclsInsertionChild.get(node);
                for(Pair<ASTNode, List<ASTNode>> pair : pairs) {
                    for(ASTNode predecessor : pair.right()) {
                        node.insertBeforeChild(pair.left(), predecessor);
                    }
                }
            }
        }
        
        private void bindTempAssignToBlockStmt(ASTNode node) {
            BlockStmtNode blockStmt          = Accessors.getEnclosingBlockStmt(node);
            if(enclBlockStmtTempAssigns.containsKey(blockStmt)) {
                addValueToList(tempAssignsInsertionChild, blockStmt, new Pair<ASTNode, List<ASTNode>>(node, enclBlockStmtTempAssigns.get(blockStmt)));
                enclBlockStmtTempAssigns.remove(blockStmt);
            }
        }

        private void bindTempDeclsToBlockStmt(ASTNode node) {
            BlockStmtNode blockStmt          = Accessors.getEnclosingBlockStmt(node);
            if(enclBlockStmtTempDecls.containsKey(blockStmt)) {
                addValueToList(tempDeclsInsertionChild, blockStmt, new Pair<ASTNode, List<ASTNode>>(node, enclBlockStmtTempDecls.get(blockStmt)));
                enclBlockStmtTempDecls.remove(blockStmt);
            }
        }           

    }
}