source: proto/pablo/src/compiler/ast/Accessors.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: 10.9 KB
Line 
1package compiler.ast;
2
3import ast.*;
4
5import java.util.ArrayList;
6import java.util.List;
7
8public class Accessors {
9
10        ////////////////////////////////////////////////////////////////////////////
11        //
12        // Narrowest node type returned whenever possible. ASTNode type otherwise.
13        //
14        // WARNING: Add addition methods as needed. Do not hard code child index
15        //                      values in general code.
16        //
17        ////////////////////////////////////////////////////////////////////////////
18
19        ////////////////////////////////////////////////////////////////////////////
20        // Program (global)
21        ////////////////////////////////////////////////////////////////////////////
22        public static List<StructTypeNode> structTypeDecls(ProgramNode node) {
23               
24                List<StructTypeNode> structTypeDecls = new ArrayList<StructTypeNode>();
25               
26                for(ASTNode child: node.getChildren()) {
27                        if (child instanceof TypeDeclNode) {
28                                ASTNode type = child.child(0);
29                                if(type instanceof StructTypeNode) {
30                                        structTypeDecls.add((StructTypeNode)type);
31                                }
32                        }
33                }
34               
35                return structTypeDecls;
36        }
37
38        public static List<FuncDefNode> funcDefs(ProgramNode node) {
39               
40                assert node instanceof ProgramNode;
41                List<FuncDefNode> funcDefs = new ArrayList<FuncDefNode>();
42               
43                for(ASTNode child: node.getChildren()) {
44                        if (child instanceof FuncDefNode) {
45                                funcDefs.add((FuncDefNode)child);
46                        }
47                }
48                return funcDefs;
49        }
50               
51        ////////////////////////////////////////////////////////////////////////////
52        // Terminals
53        ////////////////////////////////////////////////////////////////////////////
54        public static boolean isTerminal(ASTNode node) {
55                return 0 == node.nChildren();
56        }
57               
58        ////////////////////////////////////////////////////////////////////////////
59        // Type Decls
60        ////////////////////////////////////////////////////////////////////////////                           
61        public static boolean hasDeclList(TypeDeclNode node) {
62
63                if (node.nChildren() > 1) {
64                        ASTNode child = node.child(1);
65                        assert child instanceof DeclListNode;
66                        return true;
67                }
68                return false;
69        }
70               
71        ////////////////////////////////////////////////////////////////////////////
72        // Assign Stmts
73        ////////////////////////////////////////////////////////////////////////////                           
74        public static ASTNode lhs(AssignNode node) {
75                return node.child(0);
76        }       
77       
78        public static ASTNode rhs(AssignNode node) {
79                return node.child(1);
80        }       
81
82        public static String assignOperator(AssignNode node) {
83                return node.getToken().getLexeme();
84        }
85       
86        ////////////////////////////////////////////////////////////////////////////
87        // Func Invocation Stmts
88        ////////////////////////////////////////////////////////////////////////////                           
89
90        public static String assignOperator(FuncCallNode node) {
91                return node.getToken().getLexeme();
92        }       
93       
94        ////////////////////////////////////////////////////////////////////////////
95        // Local Var Decl Stmts
96        ////////////////////////////////////////////////////////////////////////////
97       
98        public static ASTNode lhs(LocalVarDeclNode node) {
99                return node.child(1);
100        }       
101       
102        public static ASTNode rhs(LocalVarDeclNode node) {
103       
104                return node.child(2);
105        }               
106       
107        public static String assignOperator(LocalVarDeclNode node) {
108                return node.getToken().getLexeme();
109        }       
110       
111        public static boolean hasInitializationAssign(LocalVarDeclNode node) {
112
113                if (node.nChildren() > 2) {
114                        return true;
115                }
116                return false;
117        }
118
119        ////////////////////////////////////////////////////////////////////////////
120        // Unary Operators
121        ////////////////////////////////////////////////////////////////////////////                   
122        public static ASTNode operand(UnaryOperatorNode node) {
123                return node.child(0);
124        }
125
126        public static String operator(UnaryOperatorNode node) {
127                return node.getToken().getLexeme();
128        }
129       
130        ////////////////////////////////////////////////////////////////////////////
131        // Binary Operators
132        ////////////////////////////////////////////////////////////////////////////           
133        public static ASTNode lhs(BinaryOperatorNode node) {
134                return node.child(0);
135        }               
136
137        public static ASTNode rhs(BinaryOperatorNode node) {
138                return node.child(1);
139        }
140       
141        public static String operator(BinaryOperatorNode node) {
142                return node.getToken().getLexeme();
143        }               
144       
145        ////////////////////////////////////////////////////////////////////////////
146        // Integer Constant
147        ////////////////////////////////////////////////////////////////////////////           
148        public static String integerConstant(IntegerConstantNode node) {
149                return node.getToken().getLexeme();
150        }                       
151
152        ////////////////////////////////////////////////////////////////////////////
153        // String Constant
154        ////////////////////////////////////////////////////////////////////////////           
155        public static String stringConstant(StringConstantNode node) {
156                return node.getToken().getLexeme();
157        }                       
158       
159        ////////////////////////////////////////////////////////////////////////////
160        // IfStmtNode helpers
161        ////////////////////////////////////////////////////////////////////////////   
162        public static ASTNode ifTest(IfStmtNode node) {
163                return (ASTNode) node.child(0);
164        }
165
166        public static BlockStmtNode ifBlockStmt(IfStmtNode node) {
167                return (BlockStmtNode) node.child(1);
168        }       
169       
170        public static boolean hasElseBlockStmt(IfStmtNode node) {
171                return node.nChildren() > 2;
172        }
173       
174        public static BlockStmtNode elseBlockStmt(IfStmtNode node) {
175                return (BlockStmtNode) node.child(2);
176        }
177
178        ////////////////////////////////////////////////////////////////////////////
179        // WhileStmtNode helpers
180        ////////////////////////////////////////////////////////////////////////////           
181        public static ASTNode whileCondition(WhileStmtNode node) {
182                return node.child(0);
183        }       
184               
185        ////////////////////////////////////////////////////////////////////////////
186        // FuncDefinitionNode helpers
187        ////////////////////////////////////////////////////////////////////////////
188        public static IdentifierNode funcIdentifier(FuncDefNode node) {
189                return (IdentifierNode) node.child(1);
190        }
191       
192        public static String funcName(FuncDefNode node) {
193                return Accessors.name(node.child(1));
194        }
195       
196        public static boolean hasParameters(FuncDefNode node) {
197                ASTNode child2 = node.child(2);
198               
199                if ((node.nChildren()) > 2 && (child2 instanceof ParameterListNode)) {
200                        return true;
201                }
202                return false;
203        }
204       
205        public static BlockStmtNode blockStmtNode(FuncDefNode node) {
206                int blockStmtNodeIndex;
207               
208                if(Accessors.hasParameters(node)) {
209                        blockStmtNodeIndex = 3;
210                } else {
211                        blockStmtNodeIndex = 2;
212                }
213               
214                ASTNode child = node.child(blockStmtNodeIndex);
215                assert child instanceof BlockStmtNode;
216        return (BlockStmtNode) child;
217        }       
218       
219        ////////////////////////////////////////////////////////////////////////////
220        // WhileStmt helpers
221        ////////////////////////////////////////////////////////////////////////////
222        public static ASTNode whileTest(WhileStmtNode node) {
223                return node.child(0);
224        }
225       
226        ////////////////////////////////////////////////////////////////////////////
227        // FuncCallNode helpers
228        ////////////////////////////////////////////////////////////////////////////
229        public static ASTNode funcCallIdentifier(FuncCallNode node) {
230                return node.child(0);
231        }
232
233        public static ASTNode funcCallArgsListNode(FuncCallNode node) {
234                return node.child(1);
235        }
236       
237        public static int funcCallArgCount(FuncCallNode node) {
238                ASTNode argList = Accessors.funcCallArgsListNode(node);
239                if (argList == null) {
240                        return 0;
241                }
242                return argList.nChildren();
243        }
244       
245        public static ASTNode funcCallArg(FuncCallNode node, int index) {
246               
247                if((index + 1) > Accessors.funcCallArgsListNode(node).getChildren().size()) {
248                        throw new RuntimeException("Func invocation Arg out of range.");
249                }
250                return Accessors.funcCallArgsListNode(node).child(index);
251        }
252       
253        public static List<ASTNode> funcCallArgsList(FuncCallNode node) {
254                return Accessors.funcCallArgsListNode(node).getChildren();
255        }
256               
257    public static String funcCallName(ASTNode node) {
258        String name = new String();
259        if(node instanceof IdentifierNode) {
260            name = Accessors.name(node);
261        }
262        else if (node instanceof CompoundIdentifierNode) {
263            ASTNode pckage = node.child(0);
264            ASTNode member = node.child(1);
265            name = Accessors.name(pckage);
266            name += ".";
267            name += Accessors.name(member); 
268        }
269        return name;
270    }   
271       
272        ////////////////////////////////////////////////////////////////////////////
273        // IdentifierNode helper
274        ////////////////////////////////////////////////////////////////////////////
275        public static String name(ASTNode node) {
276                assert node instanceof IdentifierNode;
277                return node.getToken().getLexeme();
278        }
279
280        ////////////////////////////////////////////////////////////////////////////
281        // StructTypeNode helper
282        ////////////////////////////////////////////////////////////////////////////
283        public static String structName(StructTypeNode node) {
284        String name = new String(); 
285        name = Accessors.name(node.child(0));
286        return name;
287        }
288
289        public static StructTypeBodyNode structBody(StructTypeNode node) {
290                ASTNode child = node.child(1);
291                assert child instanceof StructTypeBodyNode;
292        return (StructTypeBodyNode) child;
293        }       
294       
295        public static boolean hasStructBody(StructTypeNode node) {
296                if (node.nChildren() > 1) {
297                        ASTNode child = node.child(1);
298                        assert child instanceof StructTypeBodyNode;
299                        return true;
300                }
301                return false;
302        }       
303       
304        ////////////////////////////////////////////////////////////////////////////
305        // StructMemberNode helper
306        ////////////////////////////////////////////////////////////////////////////
307        public static String structMemberName(StructMemberNode node) {
308        return Accessors.name(node.child(1));
309        }       
310                       
311        ////////////////////////////////////////////////////////////////////////////
312        // StructMemberNode helpers
313        ////////////////////////////////////////////////////////////////////////////
314        public static String streamTypeName(StreamTypeNode node) {
315                return Accessors.name(node);
316        }       
317
318        ////////////////////////////////////////////////////////////////////////////
319        // StructMemberNode helpers
320        ////////////////////////////////////////////////////////////////////////////
321        public static boolean hasFieldWidth(StreamTypeNode node) {             
322                if(1 == node.nChildren()) {
323                        assert node.child(0) instanceof FieldWidthNode;
324                        return true;
325                }
326                return false;
327        }
328
329        ////////////////////////////////////////////////////////////////////////////
330        // Stream Type helpers
331        ////////////////////////////////////////////////////////////////////////////
332        public static String fieldWidthValue(FieldWidthNode node) {             
333                return node.getToken().getLexeme();
334        }       
335
336        ////////////////////////////////////////////////////////////////////////////
337        // Void Type
338        ////////////////////////////////////////////////////////////////////////////   
339        public static String voidValue(VoidNode node) {         
340                return node.getToken().getLexeme();
341        }       
342       
343}
Note: See TracBrowser for help on using the repository browser.