source: proto/pablo/src/compiler/backend/visitors/CPPUnparser.java @ 2710

Last change on this file since 2710 was 2710, checked in by ksherdy, 6 years ago

General refactoring.

File size: 15.5 KB
Line 
1package compiler.backend.visitors;
2
3import ast.*;
4
5import java.util.Iterator;
6import java.util.List;
7
8import compiler.ast.Accessors;
9import compiler.backend.visitors.helpers.CodeStore;
10import compiler.backend.visitors.helpers.UnparserUtil;
11import compiler.codeGenerator.visitors.helpers.*;
12import compiler.lang.carryset.CarrySet2CPP;
13import compiler.lang.pablo.Builtins2CPP;
14
15//
16// Design:      This class clones the AST function body in the visit(FuncDefNode) method and
17//                      modifies the FuncDefNode body to handle atEOF, inFile and EOF_mask in block     
18//                      final block processing.
19//
20
21// Target
22/*             
23struct @name
24{
25  @name() {}
26  IDISA_INLINE void do_block(@parameters)
27  {
28        @do_block                               
29  }
30  IDISA_INLINE void do_final_block(@parameters)
31  {
32    @do_final_block
33  }                             
34  CarryArray<@carry_count, @carry_n_count> carryQ;
35};
36*/
37
38public class CPPUnparser extends Unparser {
39       
40        //////////////////////////////////////////////////////////////
41        // constructor and helpers     
42        public CPPUnparser() {}
43
44        public String getCode(ASTNode node) {
45                CodeStore codeStore = (CodeStore)node.accept(this);             
46                return codeStore.toStringIndented(0);
47        }               
48
49        public String getCode(ASTNode node, int indent) {
50                CodeStore codeStore = (CodeStore)node.accept(this);             
51                return codeStore.toStringIndented(indent);
52        }
53       
54        //////////////////////////////////////////////////////////////
55        // visitors
56        public CodeStore visitLeave(ProgramNode node, List<CodeStore> childResults) {   
57                return  UnparserUtil.concatenatedChildrenCode(new CodeStore(), childResults, false);
58        }
59
60        //public void visitEnter(DeclsNode node) {
61
62        //}
63       
64        //public CodeStore visitLeave(DeclsNode node, List<CodeStore> childResults) {   
65        //      return UnparserUtil.concatenatedChildrenCode(new CodeStore(), childResults, true);             
66        //}     
67
68        public CodeStore visitLeave(TypeDefNode node, List<CodeStore> childResults) {
69                CodeStore code = new CodeStore();
70               
71                String type = childResults.get(0).getResultVarName();
72                String alias = childResults.get(1).getResultVarName();
73               
74                code.addFormattedLine("typedef %s %s;", type, alias);
75               
76                return code;
77        }       
78       
79        public CodeStore visitLeave(TypeDeclNode node, List<CodeStore> childResults) {
80                CodeStore code = new CodeStore();
81                String type = childResults.get(0).getResultVarName();
82                String DeclList;
83                if (Accessors.hasDeclList(node)) {
84                        DeclList = childResults.get(1).getResultVarName();
85                        code.addFormattedLine("%s %s;", type, DeclList);
86                       
87                } else {
88                        code.addFormattedLine("%s;", type);
89                }
90                return code;           
91        }               
92
93        public CodeStore visitLeave(DeclListNode node, List<CodeStore> childResults) {
94                CodeStore code = new CodeStore();
95                Iterator<CodeStore> iter = childResults.iterator();
96                code.setResultVarName(UnparserUtil.makeDelimitedList(iter, ", "));
97                return code;           
98        }               
99       
100        ////////////////////////////////////////////////////////////////////////////
101        // Stream Funcs - User defined stream function (language extension point)
102        ////////////////////////////////////////////////////////////////////////////
103        public CodeStore visitLeave(FuncDefNode node, List<CodeStore> childResults) {
104               
105               
106               
107                CodeStore code = new CodeStore();
108                // CodeStore returnType = childResults.get(0);
109                 
110                String funcName = childResults.get(1).getResultVarName();
111                String parameters = new String();
112                               
113                if(Accessors.hasParameters(node)) {
114                        parameters = childResults.get(2).getResultVarName();
115                }
116               
117                // TODO - CarryArray carry_count ...
118               
119                boolean isFinalBlock = false;
120                CodeStore nonFinalBlockCodeStore = XFormBlockStmt(Accessors.blockStmtNode(node), isFinalBlock);
121                       
122                isFinalBlock = true;
123                CodeStore finalBlockCodeStore = XFormBlockStmt(Accessors.blockStmtNode(node), isFinalBlock);
124               
125                code.addFormattedLine("struct %s", funcName);
126                code.addLine("{");
127                code.indentedFormattedLine("%s () {}", funcName);
128                code.addFormattedLine("IDISA_INLINE void do_block(%s)", parameters);
129                code.addLine("{");
130                code.addAll(nonFinalBlockCodeStore, 1);
131                code.dedentedLine("}");
132                code.addFormattedLine("IDISA_INLINE void do_final_block(%s)", parameters);
133                code.addLine("{");
134                code.addAll(finalBlockCodeStore, 1);
135                code.dedentedLine("}");
136                code.addFormattedLine("CarryArray<%s,%s> carryQ;", "99", "99"); // CGO
137                code.dedentedLine("};");
138                               
139                return code;
140        }
141
142        private CodeStore XFormBlockStmt(BlockStmtNode node, boolean isFinalBlock) {
143                BlockStmtNode copy = node.deepCopy();
144                Pablo2CarryXFormer pablo2CarryQ = new Pablo2CarryXFormer(copy, new Builtins2CPP(), new CarrySet2CPP()); 
145                pablo2CarryQ.XForm(isFinalBlock);                   
146                CodeStore codeStore = copy.accept(new CPPUnparser());
147                return codeStore;
148        }
149
150        public CodeStore visitLeave(ParameterListNode node, List<CodeStore> childResults) { 
151                CodeStore code = new CodeStore();               
152                Iterator<CodeStore> iter = childResults.iterator();
153                code.setResultVarName(UnparserUtil.makeDelimitedList(iter, ", "));             
154                return code;
155        }
156       
157        // Parameter
158        public CodeStore visitLeave(ParameterNode node, List<CodeStore> childResults) { 
159                CodeStore code = new CodeStore();
160               
161                String type = childResults.get(0).getResultVarName();
162                String identifier = childResults.get(1).getResultVarName();
163                code.setResultVarName(type + " & " + identifier);
164               
165                return code;
166        }
167               
168        ////////////////////////////////////////////////////////////////////////////
169        // Stmts
170        ////////////////////////////////////////////////////////////////////////////   
171       
172        // Assign Stmt
173        public CodeStore visitLeave(AssignNode node, List<CodeStore> childResults) {
174                CodeStore code = new CodeStore();
175                CodeStore lhs = childResults.get(0);
176                CodeStore rhs = childResults.get(1);
177                code.addFormattedLine("%s %s %s;", lhs.getResultVarName()
178                                                                                 , Accessors.assignOperator(node)
179                                                                                 , rhs.getResultVarName());
180               
181                return code;
182        }
183
184        // FuncCall Stmt 
185        public CodeStore visitLeave(FuncCallNode node, List<CodeStore> childResults) { 
186                CodeStore code = new CodeStore();
187               
188                StringBuilder resultVar = new StringBuilder();
189               
190                resultVar.append(childResults.get(0).getResultVarName());
191                resultVar.append("(");
192                resultVar.append(childResults.get(1).getResultVarName());
193                resultVar.append(")");
194               
195                code.setResultVarName(resultVar.toString());            // Function invocation as an expression
196               
197                code.addFormattedLine("%s;", resultVar.toString()); // Function invocation as a statement
198               
199                return code;
200        }       
201       
202        public CodeStore visitLeave(FuncCallArgListNode node, List<CodeStore> childResults) { 
203                CodeStore code = new CodeStore();
204                Iterator<CodeStore> iter = childResults.iterator();
205                code.setResultVarName(UnparserUtil.makeDelimitedList(iter, ", "));
206                return code;
207        }
208               
209        // if Stmt
210        public CodeStore visitLeave(IfStmtNode node, List<CodeStore> childResults) {
211                CodeStore code = new CodeStore();
212                CodeStore ifTest                        = childResults.get(0);
213                CodeStore ifBlockStmt   = childResults.get(1);
214                code.addFormattedLine("if (%s)", ifTest.getResultVarName());
215                code.addLine("{");
216                code.addAll(ifBlockStmt, 1);
217                code.dedentedLine("}");
218                if(Accessors.hasElseBlockStmt(node)) {
219                        CodeStore elseBlockStmt = childResults.get(2);
220                        code.addLine("else");
221                        code.addLine("{");
222                        code.addAll(elseBlockStmt, 1);
223                        code.dedentedLine("}");
224                }
225                return code;
226        }
227       
228        // while Stmt
229        public CodeStore visitLeave(WhileStmtNode node, List<CodeStore> childResults) {
230                CodeStore code = new CodeStore();
231                CodeStore ifTest                        = childResults.get(0);
232                CodeStore blockStmt     = childResults.get(1);
233                code.addFormattedLine("while (%s)", ifTest.getResultVarName());
234                code.addLine("{");
235                code.addAll(blockStmt, 1);
236                code.dedentedLine("}");
237                return code;
238        }       
239       
240        // return Stmt
241        public CodeStore visitLeave(ReturnStmtNode node, List<CodeStore> childResults) {
242                CodeStore code = new CodeStore();
243                CodeStore child = childResults.get(0);
244                code.addFormattedLine("return %s;", child.getResultVarName());
245                return code;
246        }
247                               
248        // Var Decl
249        public CodeStore visitLeave(LocalVarDeclNode node, List<CodeStore> childResults) {
250       
251                CodeStore code = new CodeStore();
252               
253                CodeStore type                                  = (CodeStore)childResults.get(0);
254                CodeStore identifier                    = (CodeStore)childResults.get(1);
255               
256                if(Accessors.hasInitializationAssign(node)) {
257               
258                        CodeStore expression                    = (CodeStore)childResults.get(2);
259               
260                        code.addFormattedLine("%s %s %s %s;", 
261                                                                type.getResultVarName(),
262                                                                identifier.getResultVarName(),
263                                                                Accessors.assignOperator(node),
264                                                                expression.getResultVarName());
265                } else {
266                       
267                        code.addFormattedLine("%s %s;", 
268                                        type.getResultVarName(),
269                                        identifier.getResultVarName());
270                }
271               
272                return code;           
273        }       
274       
275//      public CodeStore visitLeave(AssignStmtNode node, List<CodeStore> childResults) {
276//              CodeStore code = new CodeStore();
277//              code.setResultVarName(Accessors.AssignOperator(node));
278//              return code;
279//      }
280
281        // block Stmts
282        public CodeStore visitLeave(BlockStmtNode node, List<CodeStore> childResults) {
283                CodeStore code = new CodeStore();
284               
285                if (childResults.isEmpty()) {
286                        code.addLine(""); // empty if / while
287                }
288               
289                for (CodeStore child: childResults) {
290                        code.addAll(child, 0);
291                }
292                               
293                return code;
294        }       
295               
296        ////////////////////////////////////////////////////////////////////////////   
297        // Expressions
298        ////////////////////////////////////////////////////////////////////////////
299       
300        // BinaryOperator
301        public CodeStore visitLeave(BinaryOperatorNode node, List<CodeStore> childResults) {
302                CodeStore code = new CodeStore();
303                CodeStore lhs = childResults.get(0);
304                CodeStore rhs = childResults.get(1);
305                String lhsCode = lhs.getResultVarName();
306                String rhsCode = rhs.getResultVarName();       
307               
308                StringBuffer resultVar = new StringBuffer();
309               
310                if(!Accessors.isTerminal(Accessors.lhs(node))) {
311                        lhsCode = bracketExpressionCode(lhsCode);
312                }
313                resultVar.append(lhsCode);
314               
315                resultVar.append(" ");
316                resultVar.append(Accessors.operator(node));
317                resultVar.append(" ");
318               
319                if(!Accessors.isTerminal(Accessors.rhs(node))) {
320                        rhsCode = bracketExpressionCode(rhsCode);
321                }
322                resultVar.append(rhsCode);
323               
324                code.setResultVarName(resultVar.toString());
325               
326                return code;
327        }
328
329        ////////////////////////////////////////////////////////////////////////////
330        // UnaryOperator
331        ////////////////////////////////////////////////////////////////////////////
332        public CodeStore visitLeave(UnaryOperatorNode node, List<CodeStore> childResults) {
333                CodeStore code = new CodeStore();
334                CodeStore child = childResults.get(0);
335                String childCode = child.getResultVarName();
336                       
337                StringBuffer resultVar = new StringBuffer();
338                resultVar.append(Accessors.operator(node));
339               
340                if(!Accessors.isTerminal(Accessors.operand(node))) {
341                        childCode = bracketExpressionCode(childCode);
342                }
343                resultVar.append(childCode);
344                               
345                code.setResultVarName(resultVar.toString());
346                return code;
347        }       
348       
349        private String bracketExpressionCode(String code) {
350                StringBuffer buffer = new StringBuffer();
351                buffer.append("(");
352                buffer.append(code);
353                buffer.append(")");
354                return buffer.toString();
355        }               
356       
357        ////////////////////////////////////////////////////////////////////////////
358        // StringConstant
359        ////////////////////////////////////////////////////////////////////////////
360        public CodeStore visitLeave(StringConstantNode node, List<CodeStore> childResults) {
361                CodeStore code = new CodeStore();
362                code.setResultVarName(Accessors.stringConstant(node));
363                return code;
364        }       
365       
366        ////////////////////////////////////////////////////////////////////////////
367        // IntegerConstant
368        ////////////////////////////////////////////////////////////////////////////
369        public CodeStore visitLeave(IntegerConstantNode node, List<CodeStore> childResults) {
370                CodeStore code = new CodeStore();
371                code.setResultVarName(Accessors.integerConstant(node));
372                return code;
373        }
374       
375       
376        ////////////////////////////////////////////////////////////////////////////
377        // Types
378        ////////////////////////////////////////////////////////////////////////////
379       
380        ////////////////////////////////////////////////////////////////////////////
381        // Stream Structures
382        ////////////////////////////////////////////////////////////////////////////
383        // Struct Type - used both as a variable and as sequence of lines
384        //
385        public CodeStore visitLeave(StructTypeNode node, List<CodeStore> childResults) { 
386
387                CodeStore code = new CodeStore();
388               
389                StringBuffer resultVar = new StringBuffer();
390               
391                CodeStore structName = (CodeStore) childResults.get(0);
392
393                // set variable
394                resultVar.append("struct");
395                resultVar.append(" ");
396                resultVar.append(structName.getResultVarName());
397               
398                if (Accessors.hasStructBody(node)) {                   
399                        resultVar.append(CodeStore.NEWLINE);
400                        resultVar.append("{");
401                        resultVar.append(CodeStore.NEWLINE);
402                        resultVar.append(childResults.get(1).toStringIndented(0));
403                        resultVar.append("}");
404                }
405                code.setResultVarName(resultVar.toString());
406
407                // code store lines
408                code.addFormattedLine("struct %s", structName.getResultVarName());
409                code.addLine("{");
410                if(Accessors.hasStructBody(node)) {                             
411                        code.addAll(childResults.get(1),0);
412                }
413                code.dedentedLine("}");
414
415                return code;
416               
417        }
418       
419        // Struct Body
420        public CodeStore visitLeave(StructTypeBodyNode node, List<CodeStore> childResults) {
421                CodeStore code = new CodeStore();
422               
423                for (CodeStore child: childResults.subList(0, 1)) {
424                        code.addAll(child,1);
425                }
426                for (CodeStore child: childResults.subList(1, childResults.size())) {
427                        code.addAll(child,0);
428                }       
429               
430                return code;
431        }
432       
433        // Struct Member
434        public CodeStore visitLeave(StructMemberNode node, List<CodeStore> childResults) { // a line of code
435                CodeStore code = new CodeStore();
436                CodeStore type = childResults.get(0);
437                CodeStore memberName = childResults.get(1);
438                code.addFormattedLine("%s %s;", type.getResultVarName(), memberName.getResultVarName());               
439                return code;
440        }
441               
442        // Type
443        //public CodeStore visitLeave(TypeNode node, List<CodeStore> childResults) {
444        //      return concatenatedChildrenCode(new CodeStore(), childResults, false);
445        //}
446       
447        // Stream
448        public CodeStore visitLeave(StreamTypeNode node, List<CodeStore> childResults) { 
449                CodeStore code = new CodeStore();
450                // TODO - Map stream --> BitBlock <-- stream, BitBlock <-- stream<1>
451                // code.setResultVarName(Accessors.streamTypeName(node));
452                code.setResultVarName("BitBlock");
453               
454                /*
455                 * TODO - 2^k field width types.
456                 *
457                if(Accessors.hasFieldWidth(node)) {
458                        CodeStore fieldWidth;
459                        fieldWidth = childResults.get(0);
460                        code.setResultVarName(code.getResultVarName() + "<" + fieldWidth.getResultVarName() + ">");
461                }
462                *
463                *
464                */             
465               
466                return code;
467        }               
468       
469        // Field Width
470        public CodeStore visitLeave(FieldWidthNode node, List<CodeStore> childResults) { 
471                CodeStore code = new CodeStore();
472                code.setResultVarName(Accessors.fieldWidthValue(node));         
473                return code;
474        }       
475
476        // Void
477        public CodeStore visitLeave(VoidNode node, List<CodeStore> childResults) { 
478                CodeStore code = new CodeStore();
479                code.setResultVarName(Accessors.voidValue(node));
480                return code;
481        }               
482       
483        // Compound Identifiers
484        public CodeStore visitLeave(CompoundIdentifierNode node, List<CodeStore> childResults) { 
485                CodeStore code = new CodeStore();
486                Iterator<CodeStore> iter = childResults.iterator();
487                code.setResultVarName(UnparserUtil.makeDelimitedList(iter, "."));
488                return code;
489        }
490       
491        // Identifiers
492        public CodeStore visitLeave(IdentifierNode node, List<CodeStore> childResults) { 
493                CodeStore code = new CodeStore();
494                code.setResultVarName(Accessors.name(node));
495                return code;
496        }
497       
498}
Note: See TracBrowser for help on using the repository browser.