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

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

Updated toolchain for filter definitions.

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