source: proto/s2k/trunk/framework/src/toolchain/b2k/codeGenerator/visitors/Unparser.java @ 3777

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

Renamed structDecl to structDef

File size: 14.3 KB
Line 
1/*
2 * b2k to C++ translation.
3 * 
4 * @author Ken Herdy <ksherdy at sfu dot ca>
5 */
6
7// C++ stream structure translation target
8/*
9struct $name
10{
11        $members
12};
13*/
14 
15// C++ stream function translation target
16/*             
17struct $name
18{
19  $name() {
20    ...
21  };   
22
23  IDISA_INLINE $ReturnType do_block($parameters)
24  {
25        $block_statements                               
26  }
27  IDISA_INLINE $ReturnType do_final_block($parameters)
28  {
29    $block_statements
30  }                             
31 
32  CarryDeclare(name, count1, countN);
33};
34*/
35
36package toolchain.b2k.codeGenerator.visitors;
37
38import b2k.ast.*;
39import toolchain.b2k.ast.Accessors;
40import toolchain.b2k.codeGenerator.idisa.AbstractIDISABuiltin2Lang;
41import toolchain.b2k.codeGenerator.idisa.AbstractIDISABuiltinGenerator;
42import toolchain.b2k.codeGenerator.util.CodeStore;
43import toolchain.b2k.codeGenerator.util.UnparserUtil;
44import toolchain.b2k.lang.idisa.IDISABuiltin;
45
46import java.util.Iterator;
47import java.util.List;
48
49public class Unparser extends AbstractUnparser {
50       
51        //////////////////////////////////////////////////////////////
52        // constructor and helpers     
53        public Unparser(AbstractIDISABuiltin2Lang idisaBuiltins2Lang) {
54                this.idisaBuiltins2Lang = idisaBuiltins2Lang;
55        }
56
57        public String getCode(ASTNode node) {
58                CodeStore codeStore = (CodeStore)node.accept(this);             
59                return codeStore.toStringIndented(0);
60        }               
61
62        public String getCode(ASTNode node, int indent) {
63                CodeStore codeStore = (CodeStore)node.accept(this);             
64                return codeStore.toStringIndented(indent);
65        }
66               
67    @SuppressWarnings("unused")
68    private boolean hasCode(List<CodeStore> childResults) {
69        boolean hasCode = false;
70        for(CodeStore child: childResults) {
71            if(!child.hasCode()) {
72                hasCode = true;
73            }
74        }
75        return hasCode;
76    }
77       
78        //////////////////////////////////////////////////////////////
79        // visitors
80        public CodeStore visitLeave(ProgramNode node, List<CodeStore> childResults) {   
81                return  UnparserUtil.concatenatedChildrenCode(new CodeStore(), childResults, true);
82        }
83       
84        public CodeStore visitLeave(StructDefNode node, List<CodeStore> childResults) {
85                CodeStore code = new CodeStore();
86               
87                CodeStore structName = (CodeStore) childResults.get(0);
88                code.addFormattedLine("struct %s", structName.getResultVarName());
89                code.addLine("{");
90                code.addAll(childResults.get(1),0);
91                code.dedentedLine("};");
92                code.addLine(" "); // add blank line
93               
94                return code;
95               
96        }
97       
98        public CodeStore visitLeave(KernelDefNode node, List<CodeStore> childResults) {
99                CodeStore code = new CodeStore();
100               
101                String kernelName = childResults.get(0).getResultVarName();
102                               
103                CodeStore initDef = childResults.get(1);
104               
105                CodeStore funcDefCodeStore = childResults.get(2);
106               
107                code.addFormattedLine("struct %s ", kernelName);
108                code.addLine("{");
109               
110                code.indentedFormattedLine("%s()", kernelName);
111                code.addLine("{");
112                code.addAll(initDef, 1);
113               
114                if(!initDef.hasCode()) {
115                    code.dedentedLine("}");
116                } else {
117                    code.addLine("}");
118                }
119               
120                code.addLine("");
121               
122                funcDefCodeStore.prependToFirst("IDISA_INLINE ");
123                code.addAll(funcDefCodeStore, 0);
124               
125                if(Accessors.hasFinalBlockFuncDef(node)) { // KH: refactor - eliminate has() calls
126                        CodeStore optFuncDefCodeStore = childResults.get(3);
127                        // optFuncDefCodeStore.prependToFirst("IDISA_INLINE ");
128                        code.addAll(optFuncDefCodeStore, 0);
129                }
130
131                //
132                CodeStore clearFuncDefCodeStore = childResults.get(4);
133                code.addAll(clearFuncDefCodeStore, 0);
134               
135                CodeStore carryDeclareCodeStore;
136                if(Accessors.hasFinalBlockFuncDef(node)) {
137                    carryDeclareCodeStore = childResults.get(5);
138                } else {
139                        carryDeclareCodeStore = childResults.get(4);
140                }
141                code.addAll(carryDeclareCodeStore, 0);
142                       
143                code.dedentedLine("};");
144               
145                code.addLine(" "); // a blank line
146                       
147                return code;
148        }
149
150        ////////////////////////////////////////////////////////////////////////////
151        // Kernel Initialization
152        ////////////////////////////////////////////////////////////////////////////
153       
154        public CodeStore visitLeave(InitDefNode node, List<CodeStore> childResults) {
155                CodeStore code = new CodeStore();
156       
157        if (childResults.isEmpty()) {
158            code.addLine(""); // empty if / while
159        }
160       
161        for (CodeStore child: childResults) {
162            code.addAll(child, 0);
163        }
164               
165        return code;
166       
167        }
168
169        public CodeStore visitLeave(KernelPropertyNode node, List<CodeStore> childResults) {
170                CodeStore code = new CodeStore();               
171                return code;
172        }
173
174        public CodeStore visitLeave(PropertyValueNode node, List<CodeStore> childResults) {
175                CodeStore code = new CodeStore();               
176                return code;
177        }
178
179        public CodeStore visitLeave(FuncDefNode node, List<CodeStore> childResults) {
180                       
181                CodeStore code = new CodeStore();
182               
183                // String returnType = childResults.get(0).getResultVarName();   
184                String funcName = childResults.get(0).getResultVarName();
185                String parameters = new String();
186                               
187                CodeStore blockStmtCodeStore = null;
188                if(Accessors.hasParameters(node)) {
189                        parameters = childResults.get(1).getResultVarName();
190                       
191                } 
192               
193                blockStmtCodeStore = childResults.get(2);
194               
195                code.addFormattedLine("void %s(%s)", funcName, parameters);
196                code.addLine("{");
197                code.addAll(blockStmtCodeStore, 1);
198               
199                if(!blockStmtCodeStore.hasCode()) {
200                    code.dedentedLine("}");
201                } else {
202                    code.addLine("}");
203                }
204               
205                code.addLine("");
206                               
207                return code;
208        }
209
210        public CodeStore visitLeave(ParameterListNode node, List<CodeStore> childResults) { 
211                CodeStore code = new CodeStore();               
212                Iterator<CodeStore> iter = childResults.iterator();
213                code.setResultVarName(UnparserUtil.makeDelimitedList(iter, ","));               
214                return code;
215        }
216       
217        // Parameter
218        public CodeStore visitLeave(ParameterNode node, List<CodeStore> childResults) { 
219                CodeStore code = new CodeStore();
220               
221                String type = childResults.get(0).getResultVarName();
222                String identifier = childResults.get(1).getResultVarName();
223                code.setResultVarName(type + " & " + identifier);
224               
225                return code;
226        }
227               
228        ////////////////////////////////////////////////////////////////////////////
229        // Statements
230        ////////////////////////////////////////////////////////////////////////////   
231       
232        // Assignment statement
233        public CodeStore visitLeave(AssignNode node, List<CodeStore> childResults) {
234                CodeStore code = new CodeStore();
235                CodeStore lhs = childResults.get(0);
236                CodeStore rhs = childResults.get(1);
237                code.addFormattedLine("%s %s %s;", lhs.getResultVarName()
238                                                                                 , Accessors.assignOperatorLexeme(node)
239                                                                                 , rhs.getResultVarName());
240               
241                return code;
242        }
243                               
244        public CodeStore visitLeave(IfStmtNode node, List<CodeStore> childResults) {
245                CodeStore code = new CodeStore();
246                CodeStore ifTest                = childResults.get(0);
247                CodeStore ifBlockStmt   = childResults.get(1);
248                code.addFormattedLine("if (%s)", ifTest.getResultVarName());
249                code.addLine("{");
250                code.addAll(ifBlockStmt, 1);
251                code.dedentedLine("}");
252                if(Accessors.hasElseBlockStmt(node)) {
253                        CodeStore elseBlockStmt = childResults.get(2);
254                        code.addLine("else");
255                        code.addLine("{");
256                        code.addAll(elseBlockStmt, 1);
257                        code.dedentedLine("}");
258                }
259                return code;
260        }
261       
262        public CodeStore visitLeave(WhileStmtNode node, List<CodeStore> childResults) {
263                CodeStore code = new CodeStore();
264                CodeStore ifTest                = childResults.get(0);
265                CodeStore blockStmt     = childResults.get(1);
266                code.addFormattedLine("while (%s)", ifTest.getResultVarName());
267                code.addLine("{");
268                code.addAll(blockStmt, 1);
269                code.dedentedLine("}");
270                return code;
271        }       
272       
273        public CodeStore visitLeave(ReturnStmtNode node, List<CodeStore> childResults) {
274                CodeStore code = new CodeStore();
275                CodeStore child = childResults.get(0);
276                code.addFormattedLine("return %s;", child.getResultVarName());
277                return code;
278        }
279                               
280       
281        public CodeStore visitLeave(VarDeclNode node, List<CodeStore> childResults) {
282       
283                CodeStore code = new CodeStore();
284               
285                CodeStore type                                  = (CodeStore)childResults.get(0);
286                CodeStore identifier                    = (CodeStore)childResults.get(1);
287               
288                code.addFormattedLine("%s %s;", 
289                                        type.getResultVarName(),
290                                        identifier.getResultVarName());
291
292                return code;           
293        }       
294       
295       
296        public CodeStore visitLeave(BlockStmtNode node, List<CodeStore> childResults) {
297                CodeStore code = new CodeStore();
298               
299                if (childResults.isEmpty()) {
300                        code.addLine(""); // empty if / while
301                }
302               
303                for (CodeStore child: childResults) {
304                        code.addAll(child, 0);
305                }
306                               
307                return code;
308        }       
309               
310        ////////////////////////////////////////////////////////////////////////////   
311        // Expressions
312        ////////////////////////////////////////////////////////////////////////////
313         
314        public CodeStore visitLeave(FuncCallNode node, List<CodeStore> childResults) { 
315                CodeStore code = new CodeStore();
316               
317                StringBuilder resultVar = new StringBuilder();
318               
319                resultVar.append(childResults.get(0).getResultVarName());
320                resultVar.append("(");
321                resultVar.append(childResults.get(1).getResultVarName());
322                resultVar.append(")");
323               
324                code.setResultVarName(resultVar.toString());            // function invocation as an expression
325               
326                code.addFormattedLine("%s;", resultVar.toString()); // function invocation as a statement
327               
328                return code;
329        }       
330       
331        public CodeStore visitLeave(FuncCallArgListNode node, List<CodeStore> childResults) { 
332                CodeStore code = new CodeStore();
333                Iterator<CodeStore> iter = childResults.iterator();
334                code.setResultVarName(UnparserUtil.makeDelimitedList(iter, ","));
335                return code;
336        }       
337
338        public CodeStore visitLeave(IdisaFuncCallNode node, List<CodeStore> childResults) { 
339                CodeStore code = new CodeStore();
340               
341                String idisaFullyQualifiedName  = childResults.get(0).getResultVarName();
342                String idisaOperationName               = Accessors.idisaBaseName(idisaFullyQualifiedName);
343                String idisaPackageName                 = Accessors.idisaPackageName(idisaFullyQualifiedName);
344                String fieldWidth                               = childResults.get(1).getResultVarName();
345                String arguments                                = childResults.get(2).getResultVarName();
346               
347                IDISABuiltin idisaBuiltin = IDISABuiltin.fromString(idisaFullyQualifiedName);
348                assert idisaBuiltin != null : "Unknown IDISA Operation: " + idisaOperationName;
349                assert idisaBuiltin.hasSignature(Integer.valueOf(fieldWidth)) : "Unknown IDISA signature.";
350               
351                // AbstractIDISABuiltinGenerator
352                AbstractIDISABuiltinGenerator idisaBuiltinsGenerator
353                        = idisaBuiltin.getSignature(Integer.valueOf(fieldWidth)).getIDISABuiltinsGenerator();           
354               
355                String idisaFuncCallString = idisaBuiltinsGenerator.makeIDISAFuncCall(idisaBuiltins2Lang, idisaPackageName, idisaOperationName, fieldWidth, arguments);         
356               
357                code.setResultVarName(idisaFuncCallString);             // Function invocation as an expression
358                code.addFormattedLine("%s;", idisaFuncCallString);      // Function invocation as a statement
359               
360                return code;
361        }               
362       
363        public CodeStore visitLeave(IdisaFuncCallArgListNode node, List<CodeStore> childResults) { 
364                CodeStore code = new CodeStore();
365                Iterator<CodeStore> iter = childResults.iterator();
366                code.setResultVarName(UnparserUtil.makeDelimitedList(iter, ","));
367                return code;
368        }               
369       
370        public CodeStore visitLeave(StringConstantNode node, List<CodeStore> childResults) {
371                CodeStore code = new CodeStore();
372                code.setResultVarName(Accessors.stringConstantLexeme(node));
373                return code;
374        }       
375       
376        public CodeStore visitLeave(IntegerConstantNode node, List<CodeStore> childResults) {
377                CodeStore code = new CodeStore();
378                code.setResultVarName(Accessors.integerConstantLexeme(node));
379                return code;
380        }
381       
382        ////////////////////////////////////////////////////////////////////////////
383        // Types
384        ////////////////////////////////////////////////////////////////////////////
385       
386        // Stream Structures are used both as a variable and as sequence of code lines
387        public CodeStore visitLeave(StructTypeNode node, List<CodeStore> childResults) { 
388                CodeStore code = new CodeStore();
389               
390                StringBuilder resultVar = new StringBuilder();
391                resultVar.append(Accessors.structTypeLexeme(node));
392                resultVar.append(" ");
393                resultVar.append(childResults.get(0).getResultVarName());
394                code.setResultVarName(resultVar.toString());   
395               
396                return code;
397        }       
398       
399        public CodeStore visitLeave(StructDefBodyNode node, List<CodeStore> childResults) {
400                CodeStore code = new CodeStore();
401               
402                for (CodeStore child: childResults.subList(0, 1)) {
403                        code.addAll(child,1);
404                }
405                for (CodeStore child: childResults.subList(1, childResults.size())) {
406                        code.addAll(child,0);
407                }                       
408                return code;
409        }
410       
411        public CodeStore visitLeave(StructMemberNode node, List<CodeStore> childResults) { // a line of code
412                CodeStore code = new CodeStore();
413                CodeStore type = childResults.get(0);
414                CodeStore memberName = childResults.get(1);
415                code.addFormattedLine("%s %s;", type.getResultVarName(), memberName.getResultVarName());               
416                return code;
417        }
418                 
419        public CodeStore visitLeave(BitBlockTypeNode node, List<CodeStore> childResults) { 
420                CodeStore code = new CodeStore();
421                code.setResultVarName(Accessors.bitBlockLexeme(node));
422                return code;
423        }               
424 
425        public CodeStore visitLeave(BitFieldTypeNode node, List<CodeStore> childResults) { 
426                CodeStore code = new CodeStore();
427                code.setResultVarName(Accessors.bitFieldLexeme(node)); 
428                return code;
429        }               
430       
431        public CodeStore visitLeave(FieldWidthNode node, List<CodeStore> childResults) { 
432                CodeStore code = new CodeStore();
433                code.setResultVarName(Accessors.fieldWidthLexeme(node));               
434                return code;
435        }       
436
437        public CodeStore visitLeave(VoidTypeNode node, List<CodeStore> childResults) { 
438                CodeStore code = new CodeStore();
439                code.setResultVarName(Accessors.voidLexeme(node));
440                return code;
441        }               
442
443        public CodeStore visitLeave(BoolTypeNode node, List<CodeStore> childResults) { 
444                CodeStore code = new CodeStore();
445                code.setResultVarName(Accessors.boolLexeme(node));
446                return code;
447        }               
448               
449        public CodeStore visitLeave(CompoundIdentifierNode node, List<CodeStore> childResults) { 
450                CodeStore code = new CodeStore();
451                Iterator<CodeStore> iter = childResults.iterator();
452                code.setResultVarName(UnparserUtil.makeDelimitedList(iter, "."));
453                return code;
454        }
455       
456        public CodeStore visitLeave(IdentifierNode node, List<CodeStore> childResults) {               
457                CodeStore code = new CodeStore();
458                code.setResultVarName(Accessors.name(node));           
459                return code;
460        }
461
462}
Note: See TracBrowser for help on using the repository browser.