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

Last change on this file since 3774 was 3774, checked in by ksherdy, 4 years ago

Updated toolchain for filter definitions.

File size: 7.3 KB
Line 
1/*
2 * Converts carry generating builtins expressions to compiled form.
3 * Applied before carry variable insertion.
4 *
5 * @author Ken Herdy <ksherdy at sfu dot ca>
6 *
7 * Case 1: 'assignment' statement
8 *
9 * returnValue = pablo.BUILTIN_CALL(args) 
10 *
11 * =>
12 *
13 * stream temp;
14 * temp = pablo_blk_BUILTIN_CALL(args);
15 *   
16 * Case 2: 'if' condition
17 *
18 * if(pablo.BUILTIN_CALL(args) { ... }
19 *
20 * } 
21 *
22 * =>
23 *
24 * stream temp;
25 * temp = pablo_blk_BUILTIN_CALL(args);
26 * if(temp) { ... }
27 *
28 * Case 3: 'while' condition
29 *
30 * while(pablo.BUILTIN_CALL(args) { ... } 
31 *
32 * =>
33 *
34 * stream temp:
35 * temp = pablo_blk_BUILTIN_CALL(args);
36 * while(temp) {
37 *  ...
38 *   
39 *  stream temp:
40 *  temp = pablo_blk_BUILTIN_CALL(args); 
41 * } 
42 *   
43 */
44package toolchain.s2k.transformer.visitors.S2K2S2K;
45
46import java.util.LinkedHashMap;
47import java.util.List;
48import java.util.Map;
49
50import s2k.ast.*;
51import s2k.inputHandler.Locator;
52import toolchain.s2k.ast.Accessors;
53import toolchain.s2k.ast.Generators;
54import toolchain.s2k.lang.BuiltinCallUtil;
55import toolchain.util.Labeller;
56import toolchain.util.Pair;
57import static toolchain.util.MapUtil.*;
58
59public class TempifyCarrySetBuiltinCalls {
60       
61        static public ASTNode apply(ASTNode ASTree) {
62           
63            ASTNode xTree = SplitVarDeclInits.apply(ASTree);
64           
65            Tempifier tempifier = new Tempifier();
66            xTree.accept(tempifier);
67                return ASTree;                 
68        }   
69   
70        static private class Tempifier extends VoidVisitor.Default {
71           
72            Labeller labeller;
73            Map<ASTNode, List<ASTNode>> enclBlockStmtTempDecls; 
74            Map<ASTNode, List<Pair<ASTNode, List<ASTNode>>>> tempDeclsInsertionChild;
75           
76            Map<ASTNode, List<ASTNode>> enclBlockStmtTempAssigns; 
77            Map<ASTNode, List<Pair<ASTNode, List<ASTNode>>>> tempAssignsInsertionChild;
78
79            public Tempifier() {
80                this(0);
81            }
82
83            public Tempifier(int nextValue) {
84                labeller = new Labeller("_temp");
85                labeller.setNextValue(nextValue);
86
87            enclBlockStmtTempDecls = new LinkedHashMap<ASTNode, List<ASTNode>>();
88            enclBlockStmtTempAssigns = new LinkedHashMap<ASTNode, List<ASTNode>>();
89               
90                tempDeclsInsertionChild = new LinkedHashMap<ASTNode, List<Pair<ASTNode, List<ASTNode>>>>();
91                tempAssignsInsertionChild = new LinkedHashMap<ASTNode, List<Pair<ASTNode, List<ASTNode>>>>();
92            }
93
94        //////////////////////////////////////////////////////////////
95        // visitor callbacks
96           
97            public void visitEnter(FuncDefNode node) {
98                labeller.reset();
99               
100                enclBlockStmtTempDecls.clear();
101                enclBlockStmtTempAssigns.clear();
102               
103                tempDeclsInsertionChild.clear();
104                tempAssignsInsertionChild.clear();
105            }
106           
107            public void visitLeave(BlockStmtNode node) {
108            insertTempDecls(node);
109            insertTempAssigns(node);
110            }
111   
112            public void visitLeave(AssignNode node) {
113            bindTempDeclsToBlockStmt(node);
114            bindTempAssignToBlockStmt(node);           
115            }
116           
117            public void visitLeave(WhileStmtNode node) {
118
119                appendTempDeclsToWhileBody(node);      // WARNING: appendTemp calls must precede bindTemp calls
120            appendTempAssignsToWhileBody(node);
121               
122                bindTempDeclsToBlockStmt(node);
123            bindTempAssignToBlockStmt(node);
124            }
125
126        public void visitLeave(IfStmtNode node) {
127            bindTempDeclsToBlockStmt(node);
128            bindTempAssignToBlockStmt(node);
129        }
130
131        public void visitLeave(FuncCallNode node) { 
132           
133           
134            if(BuiltinCallUtil.isCarry(node)) {
135               
136                if(!(node.getParent() instanceof AssignNode)) {
137               
138                    BlockStmtNode blockStmt          = Accessors.getEnclosingBlockStmt(node);
139                    Locator locator                  = blockStmt;
140                    IdentifierNode name              = Generators.makeIdentifierNode(locator, labeller.newLabel());
141                    StreamTypeNode type              = Generators.makeStreamType(locator);
142                    VarDeclNode varDecl              = Generators.makeVarDeclNode(locator, type, name.deepCopy());
143                    AssignNode assignStmt            = Generators.makeAssignNode(locator, name.deepCopy(), node.deepCopy());
144
145                    addValueToList(enclBlockStmtTempDecls, blockStmt, varDecl);
146                    addValueToList(enclBlockStmtTempAssigns, blockStmt, assignStmt);
147
148                    node.updateSelf(name);               
149                }
150            }
151        }
152       
153        //////////////////////////////////////////////////////////////
154        // helpers
155       
156        private void appendTempAssignsToWhileBody(WhileStmtNode node) {
157            BlockStmtNode whileBody    = Accessors.body(node);
158            BlockStmtNode blockStmt    = Accessors.getEnclosingBlockStmt(node);
159            if(enclBlockStmtTempAssigns.containsKey(blockStmt)) {
160                for(ASTNode tempAssign : enclBlockStmtTempAssigns.get(blockStmt)) {
161                    whileBody.appendChild(tempAssign);
162                }
163            }
164        }
165
166        private void appendTempDeclsToWhileBody(WhileStmtNode node) {
167            BlockStmtNode whileBody    = Accessors.body(node);
168            BlockStmtNode blockStmt    = Accessors.getEnclosingBlockStmt(node);
169            if(enclBlockStmtTempDecls.containsKey(blockStmt)) {
170                for(ASTNode tempDecl : enclBlockStmtTempDecls.get(blockStmt)) {
171                    whileBody.appendChild(tempDecl);
172                }
173            }
174        }
175       
176        private void insertTempAssigns(BlockStmtNode node) {
177            if(tempAssignsInsertionChild.containsKey(node)) {
178                List<Pair<ASTNode, List<ASTNode>>> pairs = tempAssignsInsertionChild.get(node);
179                for(Pair<ASTNode, List<ASTNode>> pair : pairs) {
180                    for(ASTNode predecessor : pair.right()) {
181                        node.insertBeforeChild(pair.left(), predecessor);
182                    }
183                }
184            }
185        }
186
187        private void insertTempDecls(BlockStmtNode node) {
188            if(tempDeclsInsertionChild.containsKey(node)) {
189                List<Pair<ASTNode, List<ASTNode>>> pairs = tempDeclsInsertionChild.get(node);
190                for(Pair<ASTNode, List<ASTNode>> pair : pairs) {
191                    for(ASTNode predecessor : pair.right()) {
192                        node.insertBeforeChild(pair.left(), predecessor);
193                    }
194                }
195            }
196        }
197       
198        private void bindTempAssignToBlockStmt(ASTNode node) {
199            BlockStmtNode blockStmt          = Accessors.getEnclosingBlockStmt(node);
200            if(enclBlockStmtTempAssigns.containsKey(blockStmt)) {
201                addValueToList(tempAssignsInsertionChild, blockStmt, new Pair<ASTNode, List<ASTNode>>(node, enclBlockStmtTempAssigns.get(blockStmt)));
202                enclBlockStmtTempAssigns.remove(blockStmt);
203            }
204        }
205
206        private void bindTempDeclsToBlockStmt(ASTNode node) {
207            BlockStmtNode blockStmt          = Accessors.getEnclosingBlockStmt(node);
208            if(enclBlockStmtTempDecls.containsKey(blockStmt)) {
209                addValueToList(tempDeclsInsertionChild, blockStmt, new Pair<ASTNode, List<ASTNode>>(node, enclBlockStmtTempDecls.get(blockStmt)));
210                enclBlockStmtTempDecls.remove(blockStmt);
211            }
212        }           
213
214    }
215}
216
Note: See TracBrowser for help on using the repository browser.