source: proto/pablo/src/compiler/codeGenerator/CodeGenerator.java @ 2710

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

General refactoring.

File size: 4.5 KB
Line 
1package compiler.codeGenerator;
2
3import java.util.List;
4
5import compiler.ast.Accessors;
6import compiler.ast.Generators;
7import compiler.backend.visitors.*;
8import compiler.backend.visitors.helpers.CodeStore;
9import compiler.backend.visitors.helpers.UnparserUtil;
10import compiler.lang.carryset.CarrySet2Lang;
11import compiler.lang.pablo.Builtins2Lang;
12
13import ast.*;
14
15public class CodeGenerator {
16
17        //////////////////////////////////////////////////////////////
18        // static interface             
19        /*
20        public static String makeStreamFuncDecls(ProgramNode blockAST, ProgramNode finalBlockAST, Unparser unparser, int indent) {
21                StringBuilder builder = new StringBuilder();
22                List<FuncDefNode> funcDefs = Accessors.funcDefs((ProgramNode) node);
23               
24                for(FuncDefNode funcDef: funcDefs) {
25                        builder.append(makeStreamFuncDecl(funcDef, unparser, indent));
26                }       
27               
28                return builder.toString();
29        }       
30        */
31        /*
32        struct @name {
33               
34                @name() {}
35               
36                IDISA_INLINE void do_block(@args) {
37                        @do_block
38                }
39               
40                IDISA_INLINE void do_final_block(@args) {
41                        @do_final_block
42                }
43               
44                IDISA_INLINE void do_segment(@args, int segment_blocks) {
45                       
46                }
47               
48                CarryArray<@carry_count, @carry_n_count> carryQ;
49        };
50        */
51        /*
52        public static String makeStreamFuncDecl(FuncDefNode node, Unparser unparser, int indent) {
53               
54                String funcName = Accessors.funcName(node);
55               
56
57               
58                String parameters = Accessors.
59
60               
61                return unparser.getCode(node, indent);
62        }
63        */
64
65        public static String makeStructDecls(ProgramNode node, Unparser unparser, int indent) {
66                StringBuilder builder = new StringBuilder();
67                List<StructTypeNode> structDecls = Accessors.structTypeDecls(node);
68                for(StructTypeNode structDecl: structDecls) {
69                        builder.append(makeStructDecl(structDecl, unparser, indent));
70                }       
71                return builder.toString();
72        }       
73       
74        public static String makeStructDecl(StructTypeNode node, Unparser unparser, int indent) {
75                return unparser.getCode(node, indent);
76        }
77       
78        /*
79        public static String makeStructDefs(ProgramNode node, Unparser unparser) {
80                return unparser.getStructDefs(node, 0);
81        }
82        */
83       
84        //////////////////////////////////////////////////////////////
85        //
86        /*
87        public static String makeStructDefs(ProgramNode node, int indent) {
88                StringBuilder builder = new StringBuilder();
89                List<StructTypeNode> structDecls = Accessors.structTypeDecls(node);
90                for(StructTypeNode structDecl: structDecls) {
91                        builder.append(makeStructDef(structDecl, indent));     
92                }
93                return builder.toString();
94        }
95       
96        public static String makeStructDef(StructTypeNode node, int indent) {
97                StringBuilder builder = new StringBuilder();
98               
99                String name = Accessors.structName(node);
100                CodeStore.addIndentation(builder, indent);
101                builder.append(Generators.capitalize(name));    // TODO -       hack
102                builder.append(" ");                                                    //              replace capitalised struct type name and
103                builder.append(Generators.unCapitalize(name));  //                      lower case instance name convention with a 'main' method         
104                builder.append(";");
105                builder.append(CodeStore.NEWLINE);
106                               
107                return builder.toString();
108        }
109       
110        public static String makeFuncDefs(ProgramNode node, int indent) {
111                StringBuilder builder = new StringBuilder();
112                List<FuncDefNode> funcDefs = Accessors.funcDefs(node);
113                for(FuncDefNode funcDef: funcDefs) {
114                        builder.append(makeFuncDef(funcDef, indent));   
115                }       
116               
117                return builder.toString();
118        }
119       
120        public static String makeFuncDef(FuncDefNode node, int indent) {
121                StringBuilder builder = new StringBuilder();
122               
123                String name = Accessors.funcName(node);
124                CodeStore.addIndentation(builder, indent);
125                builder.append(Generators.capitalize(name));    // TODO - hack
126                builder.append(" ");
127                builder.append(Generators.unCapitalize(name)); 
128                builder.append(";");
129                builder.append(CodeStore.NEWLINE);
130               
131                return builder.toString();
132        }
133       
134        /*
135        public String makeFuncBodies(ProgramNode node, int indent) {
136                StringBuilder builder = new StringBuilder();
137                List<FuncDefNode> funcDefs = Accessors.funcDefs(node);
138                for(FuncDefNode funcDef: funcDefs) {
139                        String name = Accessors.funcName(funcDef);
140                        CodeStore.addIndentation(builder, indent);
141                        builder.append(Generators.unCapitalize(name));  // TODO - hack
142                        builder.append(".doBlock();");
143                }
144                return null;
145        }
146       
147        public String makeFuncBody(FuncDefNode node, indent) {
148               
149        }
150        */
151       
152        /*
153        public static String makeStreamStructDecls(ASTNode root, Unparser unparser) {
154                CodeGenerator generator = new CodeGenerator(root, unparser);           
155                return generator.makeStreamStructDecls();
156        }
157        */             
158       
159        /*
160        public static String makeStreamFuncDefs(ASTNode root, Unparser unparser) {
161                CodeGenerator generator = new CodeGenerator(root, unparser);           
162                return generator.makeStreamFuncDefs();
163        }
164        */     
165       
166}               
167
Note: See TracBrowser for help on using the repository browser.