source: proto/s2k/trunk/framework/src/toolchain/b2k/ast/Accessors.java @ 3778

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

Minors updates to b2k grammar.

File size: 16.6 KB
Line 
1/*
2 * b2k AST accessors and helpers.
3 *
4 * @author <ksherdy at sfu dot ca>
5 */
6
7package toolchain.b2k.ast;
8
9import java.util.ArrayList;
10import java.util.List;
11
12import b2k.ast.*;
13
14public class Accessors {
15
16        ////////////////////////////////////////////////////////////////////////////
17        // Program
18        ////////////////////////////////////////////////////////////////////////////
19        public static List<StructDefNode> structDeclNodes(ProgramNode node) {
20               
21                List<StructDefNode> structTypeDecls = new ArrayList<StructDefNode>();
22               
23                for(ASTNode child: node.getChildren()) {
24                        if(child instanceof StructDefNode) {
25                                structTypeDecls.add((StructDefNode)child);
26                        }
27                }
28               
29                return structTypeDecls;
30        }
31               
32        public static List<KernelDefNode> kernelDefNodes(ProgramNode node) {
33                List<KernelDefNode> list = new ArrayList<KernelDefNode>();
34                for(ASTNode child : node.getChildren()) {
35                        if (child instanceof KernelDefNode) {
36                                list.add((KernelDefNode) child);
37                        }
38                }
39                return list;
40        }
41       
42        ////////////////////////////////////////////////////////////////////////////
43        // Kernel
44        ////////////////////////////////////////////////////////////////////////////
45               
46        ////////////////////////////////////////////////////////////////////////////
47        // Initialization
48        ////////////////////////////////////////////////////////////////////////////
49                       
50        public static KernelFuncDefNode kernelFuncDefNode(KernelDefNode node) {
51                return (KernelFuncDefNode) node.child(1);
52        }
53       
54        public static boolean hasFinalBlockFuncDef(KernelDefNode node) {
55                if(node.nChildren() > 3 && (node.child(3) instanceof KernelFuncDefNode)) {
56                        return true;
57                }
58                return false;
59        }       
60       
61        public static KernelFuncDefNode finalBlockKernelFuncDefNode(KernelDefNode node) {
62                assert hasFinalBlockFuncDef(node);
63                return (KernelFuncDefNode) node.child(2);
64        }
65       
66        public static ASTNode nameNode(KernelDefNode node) {
67            return node.child(0);
68        }
69       
70    public static KernelFuncDefNode funcDefForName(ASTNode node, String name) {
71
72        if(node instanceof KernelFuncDefNode) {
73            if(name(node).equals(name)) {
74                return (KernelFuncDefNode)node;
75            }
76        }
77
78        KernelFuncDefNode result = null;
79
80        for(ASTNode child : node.getChildren()) {
81            result = funcDefForName(child, name);
82            if (result != null) {
83                return result;
84            }
85        }
86       
87        return null; 
88    }
89
90        ////////////////////////////////////////////////////////////////////////////
91        // Kernel Definition
92        ////////////////////////////////////////////////////////////////////////////
93       
94        ////////////////////////////////////////////////////////////////////////////
95        // Function Definition
96        ////////////////////////////////////////////////////////////////////////////
97        public static IdentifierNode funcIdentifier(KernelFuncDefNode node) {
98                return (IdentifierNode) node.child(0);
99        }
100       
101        public static ASTNode nameNode(KernelFuncDefNode node) {
102            return node.child(0);
103        }
104        public static boolean hasParameters(KernelFuncDefNode node) {
105            return ((node.child(1) instanceof KernelParameterListNode) && (node.child(1).nChildren() > 1));
106        }
107        public static KernelParameterListNode parameterListNode(KernelFuncDefNode node) {   
108            return (KernelParameterListNode) node.child(1);
109        }
110        public static BlockStmtNode body(KernelFuncDefNode node) {
111            return blockStmtNode(node);
112        }
113        public static BlockStmtNode blockStmtNode(KernelFuncDefNode node) {
114                ASTNode child = node.child(2);         
115                assert child instanceof BlockStmtNode;
116        return (BlockStmtNode) child;
117        }       
118       
119        ////////////////////////////////////////////////////////////////////////////
120        // Var Decl Statements
121        ////////////////////////////////////////////////////////////////////////////
122       
123    public static IdentifierNode identifier(VarDeclNode node) {
124        ASTNode child = node.child(1);
125        assert child instanceof IdentifierNode;
126        return (IdentifierNode)node.child(1);
127    }   
128   
129        public static ASTNode lhs(VarDeclNode node) {
130                return node.child(1);
131        }       
132       
133        public static ASTNode rhs(VarDeclNode node) {
134       
135                return node.child(2);
136        }               
137       
138        public static String assignOperatorLexeme(VarDeclNode node) {
139                return node.getToken().getPrintableLexeme();
140        }       
141       
142       
143        ////////////////////////////////////////////////////////////////////////////
144        // Assign Statements
145        ////////////////////////////////////////////////////////////////////////////                           
146        public static ASTNode lhs(AssignNode node) {
147                return node.child(0);
148        }       
149       
150        public static ASTNode rhs(AssignNode node) {
151                return node.child(1);
152        }       
153
154        public static String assignOperatorLexeme(AssignNode node) {
155                return node.getToken().getPrintableLexeme();
156        }
157       
158        ////////////////////////////////////////////////////////////////////////////
159        // Integer Constant
160        ////////////////////////////////////////////////////////////////////////////           
161        public static String integerConstantLexeme(IntegerConstantNode node) {
162                return node.getToken().getPrintableLexeme();
163        }                       
164
165    public static int intValue(IntegerConstantNode integerConstant) {
166        return Integer.valueOf(integerConstant.getToken().getLexeme());
167    }
168       
169        ////////////////////////////////////////////////////////////////////////////
170        // String Constant
171        ////////////////////////////////////////////////////////////////////////////           
172        public static String stringConstantLexeme(StringConstantNode node) {
173                return node.getToken().getPrintableLexeme();
174        }               
175       
176        ////////////////////////////////////////////////////////////////////////////
177        // IfStmtNode
178        ////////////////////////////////////////////////////////////////////////////   
179        public static ASTNode condition(IfStmtNode node) {
180                return (ASTNode) node.child(0);
181        }
182
183        public static BlockStmtNode ifBlockStmt(IfStmtNode node) {
184                return (BlockStmtNode) node.child(1);
185        }       
186       
187        public static BlockStmtNode elseBlockStmt(IfStmtNode node) {
188                return (BlockStmtNode) node.child(2);
189        }       
190
191        public static BlockStmtNode elseClause(IfStmtNode node) {
192            return (BlockStmtNode) node.child(2);
193        }
194       
195        public static boolean hasElseBlockStmt(IfStmtNode node) {
196            return hasElseClause(node);
197        }   
198
199        public static boolean hasElseClause(IfStmtNode node) {
200            return node.nChildren() > 2;
201        }
202       
203    ////////////////////////////////////////////////////////////////////////////
204    // WhileStmtNode
205    ////////////////////////////////////////////////////////////////////////////
206    public static ASTNode condition(WhileStmtNode node) {
207        return node.child(0);
208    }
209
210    public static BlockStmtNode body(WhileStmtNode node) {
211        return (BlockStmtNode) node.child(1);
212    }   
213       
214    ////////////////////////////////////////////////////////////////////////////
215    // FuncCallNode
216    ////////////////////////////////////////////////////////////////////////////
217   
218    public static ASTNode nameNode(FuncCallNode node) {
219        return node.child(0);
220    }
221    public static ASTNode argsListNode(FuncCallNode node) {
222        return node.child(1);
223    }
224    public static int argCount(FuncCallNode node) {
225        ASTNode argList = Accessors.argsListNode(node);
226        if (argList == null) {
227            return 0;
228        }
229        return argList.nChildren();
230    }
231   
232    public static ASTNode argument(FuncCallNode node, int index) {
233        if((index + 1) > Accessors.argsListNode(node).getChildren().size()) {
234            throw new RuntimeException("Function invocation argument out of range.");
235        }
236        return Accessors.argsListNode(node).child(index);
237    }
238   
239    public static List<ASTNode> argsList(FuncCallNode node) {
240        return Accessors.argsListNode(node).getChildren();
241    }
242    public static String funcCallName(ASTNode node) {
243        String name = new String();
244        if(node instanceof IdentifierNode) {
245            name = Accessors.name((IdentifierNode)node);
246        }
247        else if (node instanceof CompoundIdentifierNode) {
248            ASTNode pckage = node.child(0);
249            ASTNode member = node.child(1);
250            name = Accessors.name((IdentifierNode)pckage);
251            name += ".";
252            name += Accessors.name((IdentifierNode)member); 
253        }
254        else {  // TS: added
255            assert false: "Accessors.funcCallName() called on node of improper type.";
256        }
257        return name;
258    }   
259
260    ////////////////////////////////////////////////////////////////////////////
261    // CompoundIdentifierNode
262    ////////////////////////////////////////////////////////////////////////////
263    private static String name(CompoundIdentifierNode node) {
264       
265        StringBuilder builder = new StringBuilder();
266       
267        for(int i=0;i<node.getChildren().size()-1;i++) {
268            builder.append(node.child(i).getToken().getPrintableLexeme());
269            builder.append(node.getToken().getPrintableLexeme());
270        }
271       
272        builder.append(node.child(node.getChildren().size()-1).getToken().getPrintableLexeme());
273       
274        return builder.toString();
275    }
276
277        ////////////////////////////////////////////////////////////////////////////
278        // Terminals
279        ////////////////////////////////////////////////////////////////////////////
280        public static boolean isTerminal(ASTNode node) {
281                return 0 == node.nChildren();
282        }       
283       
284        ////////////////////////////////////////////////////////////////////////////
285        // StructDeclNode
286        ////////////////////////////////////////////////////////////////////////////
287        public static ASTNode nameNode(StructDefNode node) {
288            return node.child(0);
289        }
290       
291        public static StructDefBodyNode structBody(StructDefNode node) {
292                ASTNode child = node.child(1);
293                assert child instanceof StructDefBodyNode;
294        return (StructDefBodyNode) child;
295        }       
296
297        ////////////////////////////////////////////////////////////////////////////
298        // ParameterNode
299        ////////////////////////////////////////////////////////////////////////////
300        public static ASTNode typeNode(KernelParameterNode node) {
301            return node.child(0);
302        }
303
304        public static ASTNode nameNode(KernelParameterNode node) {
305            return node.child(1);
306        }
307
308//      public static Type declarationType(ParameterNode node) {
309//          ASTNode typeNode = typeNode(node);
310//          return typeNode.getType();
311//      }
312//      public static IdentifierNode variableNode(ParameterNode node) {
313//          return (IdentifierNode)(node.child(1));
314//      }       
315       
316    ////////////////////////////////////////////////////////////////////////////
317    // StructMemberNode
318    ////////////////////////////////////////////////////////////////////////////
319    public static ASTNode typeNode(StructMemberNode node) {
320        return node.child(0);
321    }
322
323    public static ASTNode nameNode(StructMemberNode node) {
324        return (IdentifierNode)(node.child(1));
325    }
326       
327        ////////////////////////////////////////////////////////////////////////////
328        // StructTypeNode
329        ////////////////////////////////////////////////////////////////////////////
330        public static ASTNode nameNode(StructTypeNode node) {
331            return node.child(0);
332        }
333
334        public static String structTypeLexeme(StructTypeNode node) {           
335                return node.getToken().getPrintableLexeme();
336        }       
337               
338        ////////////////////////////////////////////////////////////////////////////
339        // Field Width
340        ////////////////////////////////////////////////////////////////////////////
341        public static String fieldWidthLexeme(FieldWidthNode node) {           
342                return node.child(0).getToken().getPrintableLexeme();
343        }       
344
345        ////////////////////////////////////////////////////////////////////////////
346        // BitField Type
347        ////////////////////////////////////////////////////////////////////////////   
348        public static String bitFieldLexeme(BitFieldTypeNode node) {           
349                return node.getToken().getPrintableLexeme();
350        }       
351
352        ////////////////////////////////////////////////////////////////////////////
353        // BitBlock Type
354        ////////////////////////////////////////////////////////////////////////////   
355        public static String bitBlockLexeme(BitBlockTypeNode node) {           
356                return node.getToken().getPrintableLexeme();
357        }       
358       
359        ////////////////////////////////////////////////////////////////////////////
360        // Void Type
361        ////////////////////////////////////////////////////////////////////////////   
362        public static String voidLexeme(VoidTypeNode node) {           
363                return node.getToken().getPrintableLexeme();
364        }       
365
366        ////////////////////////////////////////////////////////////////////////////
367        // Bool Type
368        ////////////////////////////////////////////////////////////////////////////           
369        public static String boolLexeme(BoolTypeNode node) {           
370                return node.getToken().getPrintableLexeme();
371        }       
372       
373        ////////////////////////////////////////////////////////////////////////////
374        // FuncCallNode
375        ////////////////////////////////////////////////////////////////////////////
376        public static ASTNode funcCallIdentifier(FuncCallNode node) {
377                return node.child(0);
378        }
379
380        public static ASTNode funcCallArgsListNode(FuncCallNode node) {
381                return node.child(1);
382        }       
383
384        ////////////////////////////////////////////////////////////////////////////
385        // IdisaFuncCallNode
386        ////////////////////////////////////////////////////////////////////////////
387       
388        public static IdisaFuncCallArgListNode idisaFuncCallArgListNode(IdisaFuncCallNode node) {
389                return (IdisaFuncCallArgListNode)node.child(2); 
390        }
391       
392        public static String idisaBaseName(String fullyQualifiedName)
393        {               
394                return fullyQualifiedName.split("\\.")[1];
395        }       
396       
397        public static String idisaPackageName(String fullyQualifiedName)
398        {
399                return fullyQualifiedName.split("\\.")[0];
400        }
401
402    public static String name(IdentifierNode node) {
403        return node.getToken().getLexeme();
404    }
405   
406    ////////////////////////////////////////////////////////////////////////////
407    // any node
408    ////////////////////////////////////////////////////////////////////////////
409    public static String name(ASTNode node) {
410        if(node instanceof IdentifierNode) {
411            return name((IdentifierNode) node);
412        } else if(node instanceof CompoundIdentifierNode) {
413            return name((CompoundIdentifierNode) node);
414        } else if(node instanceof FuncCallNode) {
415            return funcCallName(nameNode((FuncCallNode)node)); // special case
416        } else if(node instanceof KernelFuncDefNode) {
417            return name(nameNode((KernelFuncDefNode)node));
418        } else if(node instanceof StructDefNode) {
419            return name(nameNode((StructDefNode)node));
420        } else if(node instanceof StructMemberNode) {
421            return name(nameNode((StructMemberNode)node));
422        } else if(node instanceof StructTypeNode) {
423            return name(nameNode((StructTypeNode)node));
424        } else if(node instanceof KernelDefNode) {
425            return name(nameNode((KernelDefNode)node));
426        } else if(node instanceof KernelParameterNode) {
427            return name(nameNode((KernelParameterNode)node));
428        } 
429        assert false : "Accessors.name(ASTNode node) method not implemented on node class : " + node.getClass();
430        return null;
431    }
432   
433    ////////////////////////////////////////////////////////////////////////////
434    // helpers
435    ////////////////////////////////////////////////////////////////////////////   
436    public static String lexeme(ASTNode node) {
437        return node.getToken().getLexeme();
438    }           
439    public static ASTNode headChild(ASTNode node) {
440        return node.child(0);
441    }
442    public static List<ASTNode> tailChildren(ASTNode compound) {
443        List<ASTNode> children = compound.getChildren();
444        return children.subList(1, children.size());
445    }
446//    public static List<Type> childTypes(ASTNode node) {
447//        List<Type> result = new ArrayList<Type>(node.nChildren());
448//        for(ASTNode child: node.getChildren()) {
449//            result.add(child.getType());
450//        }
451//        return result;
452//    }
453   
454    public static final ASTNode NO_ENCLOSING_NODE = null;
455
456    public static BlockStmtNode getEnclosingBlockStmt(ASTNode node) {
457        BlockStmtNode enclosingBlockStmt = (BlockStmtNode) getEnclosingNodeOfType(node, BlockStmtNode.class);
458        assert enclosingBlockStmt != NO_ENCLOSING_NODE : "getEnclosingBlockStmt(node) has no ancestor of type 'BlockStmtNode'";
459        return enclosingBlockStmt;
460    }
461
462    public static ASTNode getEnclosingNodeOfType(ASTNode node, Class<?> clazz) {
463        ASTNode current = node.getParent();
464        while(current != NO_ENCLOSING_NODE) {
465            if(current.getClass().isAssignableFrom(clazz)) {
466                return current;
467            }
468            current = current.getParent();
469        }
470
471        return NO_ENCLOSING_NODE; 
472    }   
473       
474}
Note: See TracBrowser for help on using the repository browser.