source: proto/pabloj/trunk/src/compilers/pabloB/ast/Accessors.java @ 2952

Last change on this file since 2952 was 2952, checked in by ksherdy, 5 years ago

Restructed PabloJ compile to provide clear separation between PabloS and PabloB.

File size: 9.6 KB
Line 
1/*
2 * PabloB AST accessors and helpers.
3 *
4 * @author <ksherdy at sfu dot ca>
5 */
6
7package compilers.pabloB.ast;
8
9import java.util.ArrayList;
10import java.util.List;
11
12import compilers.pabloB.ast.Accessors;
13
14import pabloB.ast.*;
15
16public class Accessors {
17
18        ////////////////////////////////////////////////////////////////////////////
19        //
20        // Narrowest node type returned whenever possible. ASTNode type otherwise.
21        //
22        // WARNING: Add addition methods as needed. Do not hard code child index
23        //                      values in general code.
24        //
25        ////////////////////////////////////////////////////////////////////////////
26
27        ////////////////////////////////////////////////////////////////////////////
28        // Program
29        ////////////////////////////////////////////////////////////////////////////
30               
31        public static List<KernelDefNode> kernelDefNodes(ProgramNode node) {
32                List<KernelDefNode> list = new ArrayList<KernelDefNode>();
33                for(ASTNode child : node.getChildren()) {
34                        if (child instanceof KernelDefNode) {
35                                list.add((KernelDefNode) child);
36                        }
37                }
38                return list;
39        }
40       
41        public static List<StructTypeNode> structTypeDeclNodes(ProgramNode node) {
42                List<StructTypeNode> list = new ArrayList<StructTypeNode>();
43                for(ASTNode child: node.getChildren()) {
44                        if (child instanceof TypeDeclNode) {
45                                ASTNode type = child.child(0);
46                                if(type instanceof StructTypeNode) {
47                                        list.add((StructTypeNode)type);
48                                }
49                        }
50                }
51                return list;
52        }
53       
54        ////////////////////////////////////////////////////////////////////////////
55        // Kernel Definition
56        ////////////////////////////////////////////////////////////////////////////
57       
58        ////////////////////////////////////////////////////////////////////////////
59        // Initialization
60        ////////////////////////////////////////////////////////////////////////////           
61        public static String integerConstantLexeme(StateSizeNode node) {
62                return node.child(0).getToken().getLexeme();
63        }                               
64       
65        ////////////////////////////////////////////////////////////////////////////
66        // Kernel Definition
67        ////////////////////////////////////////////////////////////////////////////                   
68        public static FuncDefNode funcDefNode(KernelDefNode node) {
69                return (FuncDefNode) node.child(1);
70        }
71       
72        public static boolean hasOptFuncDef(KernelDefNode node) {
73                if(node.nChildren() > 1 && (node.child(2) instanceof FuncDefNode)) {
74                        return true;
75                }
76                return false;
77        }       
78       
79        public static FuncDefNode optFuncDefNode(KernelDefNode node) {
80                assert hasOptFuncDef(node);
81                return (FuncDefNode) node.child(2);
82        }
83       
84        public static String kernelName(KernelDefNode node) {
85                return Accessors.name(node.child(0));
86        }
87
88        ////////////////////////////////////////////////////////////////////////////
89        // Kernel Definition
90        ////////////////////////////////////////////////////////////////////////////
91        public static InitBlockNode initBlockNode(InitDefNode node) {
92                return (InitBlockNode) node.child(0);
93        }
94       
95        ////////////////////////////////////////////////////////////////////////////
96        // Function Definition
97        ////////////////////////////////////////////////////////////////////////////
98        public static IdentifierNode funcIdentifier(FuncDefNode node) {
99                return (IdentifierNode) node.child(1);
100        }
101       
102        public static String funcName(FuncDefNode node) {
103                return Accessors.name(node.child(1));
104        }
105
106        public static boolean hasParameters(FuncDefNode node) {
107                ASTNode child2 = node.child(2);
108               
109                if ((node.nChildren()) > 2 && (child2 instanceof ParameterListNode)) {
110                        return true;
111                }
112                return false;
113        }       
114               
115        public static BlockStmtNode blockStmtNode(FuncDefNode node) {
116                int blockStmtNodeIndex;
117               
118                if(Accessors.hasParameters(node)) {
119                        blockStmtNodeIndex = 3;
120                } else {
121                        blockStmtNodeIndex = 2;
122                }
123               
124                ASTNode child = node.child(blockStmtNodeIndex);
125                assert child instanceof BlockStmtNode;
126        return (BlockStmtNode) child;
127        }       
128       
129        ////////////////////////////////////////////////////////////////////////////
130        // Local Var Decl Statements
131        ////////////////////////////////////////////////////////////////////////////
132       
133        public static ASTNode lhs(LocalVarDeclNode node) {
134                return node.child(1);
135        }       
136       
137        public static ASTNode rhs(LocalVarDeclNode node) {
138       
139                return node.child(2);
140        }               
141       
142        public static String assignOperatorLexeme(LocalVarDeclNode node) {
143                return node.getToken().getLexeme();
144        }       
145       
146        public static boolean hasInitializationAssign(LocalVarDeclNode node) {
147
148                if (node.nChildren() > 2) {
149                        return true;
150                }
151                return false;
152        }       
153       
154        ////////////////////////////////////////////////////////////////////////////
155        // Assign Statements
156        ////////////////////////////////////////////////////////////////////////////                           
157        public static ASTNode lhs(AssignNode node) {
158                return node.child(0);
159        }       
160       
161        public static ASTNode rhs(AssignNode node) {
162                return node.child(1);
163        }       
164
165        public static String assignOperatorLexeme(AssignNode node) {
166                return node.getToken().getLexeme();
167        }
168               
169        ////////////////////////////////////////////////////////////////////////////
170        // Integer Constant
171        ////////////////////////////////////////////////////////////////////////////           
172        public static String integerConstantLexeme(IntegerConstantNode node) {
173                return node.getToken().getLexeme();
174        }                       
175
176        ////////////////////////////////////////////////////////////////////////////
177        // Integer Constant
178        ////////////////////////////////////////////////////////////////////////////           
179        public static String streamConstantLexeme(StreamConstantNode node) {
180                return node.getToken().getLexeme();
181        }               
182       
183        ////////////////////////////////////////////////////////////////////////////
184        // String Constant
185        ////////////////////////////////////////////////////////////////////////////           
186        public static String stringConstantLexeme(StringConstantNode node) {
187                return node.getToken().getLexeme();
188        }               
189       
190        ////////////////////////////////////////////////////////////////////////////
191        // IfStmtNode
192        ////////////////////////////////////////////////////////////////////////////   
193        public static ASTNode ifTest(IfStmtNode node) {
194                return (ASTNode) node.child(0);
195        }
196
197        public static BlockStmtNode ifBlockStmt(IfStmtNode node) {
198                return (BlockStmtNode) node.child(1);
199        }       
200       
201        public static boolean hasElseBlockStmt(IfStmtNode node) {
202                return node.nChildren() > 2;
203        }
204       
205        public static BlockStmtNode elseBlockStmt(IfStmtNode node) {
206                return (BlockStmtNode) node.child(2);
207        }       
208       
209        ////////////////////////////////////////////////////////////////////////////
210        // IdentifierNode
211        ////////////////////////////////////////////////////////////////////////////
212        public static String name(ASTNode node) {
213                assert node instanceof IdentifierNode;
214                return node.getToken().getLexeme();
215        }
216
217        public static String stateName(ASTNode node) {
218                assert node instanceof StateIdentifierNode;
219                return node.getToken().getLexeme();
220        }
221       
222        ////////////////////////////////////////////////////////////////////////////
223        // Unary Operators
224        ////////////////////////////////////////////////////////////////////////////                   
225        public static ASTNode operand(UnaryOperatorNode node) {
226                return node.child(0);
227        }
228
229        public static String operatorLexeme(UnaryOperatorNode node) {
230                return node.getToken().getLexeme();
231        }
232       
233        ////////////////////////////////////////////////////////////////////////////
234        // Binary Operators
235        ////////////////////////////////////////////////////////////////////////////           
236        public static ASTNode lhs(BinaryOperatorNode node) {
237                return node.child(0);
238        }               
239
240        public static ASTNode rhs(BinaryOperatorNode node) {
241                return node.child(1);
242        }
243       
244        public static String operatorLexeme(BinaryOperatorNode node) {
245                return node.getToken().getLexeme();
246        }               
247
248        ////////////////////////////////////////////////////////////////////////////
249        // Terminals
250        ////////////////////////////////////////////////////////////////////////////
251        public static boolean isTerminal(ASTNode node) {
252                return 0 == node.nChildren();
253        }       
254       
255
256        ////////////////////////////////////////////////////////////////////////////
257        // StructTypeNode
258        ////////////////////////////////////////////////////////////////////////////
259        public static String structName(StructTypeNode node) {
260        String name = new String(); 
261        name = Accessors.name(node.child(0));
262        return name;
263        }
264
265        public static StructTypeBodyNode structBody(StructTypeNode node) {
266                ASTNode child = node.child(1);
267                assert child instanceof StructTypeBodyNode;
268        return (StructTypeBodyNode) child;
269        }       
270       
271        public static boolean hasStructBody(StructTypeNode node) {
272                if (node.nChildren() > 1) {
273                        ASTNode child = node.child(1);
274                        assert child instanceof StructTypeBodyNode;
275                        return true;
276                }
277                return false;
278        }               
279
280        ////////////////////////////////////////////////////////////////////////////
281        // Stream Type
282        ////////////////////////////////////////////////////////////////////////////
283        public static String fieldWidthLexeme(FieldWidthNode node) {           
284                return node.child(0).getToken().getLexeme();
285        }       
286
287        ////////////////////////////////////////////////////////////////////////////
288        // Void Type
289        ////////////////////////////////////////////////////////////////////////////   
290        public static String voidLexeme(VoidNode node) {               
291                return node.getToken().getLexeme();
292        }       
293       
294        ////////////////////////////////////////////////////////////////////////////
295        // FuncCallNode
296        ////////////////////////////////////////////////////////////////////////////
297        public static ASTNode funcCallIdentifier(FuncCallNode node) {
298                return node.child(0);
299        }
300
301        public static ASTNode funcCallArgsListNode(FuncCallNode node) {
302                return node.child(1);
303        }       
304
305}
Note: See TracBrowser for help on using the repository browser.