source: proto/pablo/src/compiler/codeGenerator/visitors/CPPUnparser.java @ 2702

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

General refactoring (variable names). Added final block XFormer. Move final block operations atEOF/inFile out of carry intro transformer to final block transformer.

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