View Javadoc

1   /* Generated By:JJTree: Do not edit this line. JJTExpressionParserState.java */
2   
3   package org.codehaus.aspectwerkz.expression.ast;
4   
5   class JJTExpressionParserState {
6       private java.util.Stack nodes;
7   
8       private java.util.Stack marks;
9   
10      private int sp; // number of nodes on stack
11  
12      private int mk; // current mark
13  
14      private boolean node_created;
15  
16      JJTExpressionParserState() {
17          nodes = new java.util.Stack();
18          marks = new java.util.Stack();
19          sp = 0;
20          mk = 0;
21      }
22  
23      /*
24       * Determines whether the current node was actually closed and pushed. This should only be called in the final user
25       * action of a node scope.
26       */
27      boolean nodeCreated() {
28          return node_created;
29      }
30  
31      /*
32       * Call this to reinitialize the node stack. It is called automatically by the parser's ReInit() method.
33       */
34      void reset() {
35          nodes.removeAllElements();
36          marks.removeAllElements();
37          sp = 0;
38          mk = 0;
39      }
40  
41      /*
42       * Returns the root node of the AST. It only makes sense to call this after a successful parse.
43       */
44      Node rootNode() {
45          return (Node) nodes.elementAt(0);
46      }
47  
48      /* Pushes a node on to the stack. */
49      void pushNode(Node n) {
50          nodes.push(n);
51          ++sp;
52      }
53  
54      /*
55       * Returns the node on the top of the stack, and remove it from the stack.
56       */
57      Node popNode() {
58          if (--sp < mk) {
59              mk = ((Integer) marks.pop()).intValue();
60          }
61          return (Node) nodes.pop();
62      }
63  
64      /* Returns the node currently on the top of the stack. */
65      Node peekNode() {
66          return (Node) nodes.peek();
67      }
68  
69      /*
70       * Returns the number of children on the stack in the current node scope.
71       */
72      int nodeArity() {
73          return sp - mk;
74      }
75  
76      void clearNodeScope(Node n) {
77          while (sp > mk) {
78              popNode();
79          }
80          mk = ((Integer) marks.pop()).intValue();
81      }
82  
83      void openNodeScope(Node n) {
84          marks.push(new Integer(mk));
85          mk = sp;
86          n.jjtOpen();
87      }
88  
89      /*
90       * A definite node is constructed from a specified number of children. That number of nodes are popped from the
91       * stack and made the children of the definite node. Then the definite node is pushed on to the stack.
92       */
93      void closeNodeScope(Node n, int num) {
94          mk = ((Integer) marks.pop()).intValue();
95          while (num-- > 0) {
96              Node c = popNode();
97              c.jjtSetParent(n);
98              n.jjtAddChild(c, num);
99          }
100         n.jjtClose();
101         pushNode(n);
102         node_created = true;
103     }
104 
105     /*
106      * A conditional node is constructed if its condition is true. All the nodes that have been pushed since the node
107      * was opened are made children of the the conditional node, which is then pushed on to the stack. If the condition
108      * is false the node is not constructed and they are left on the stack.
109      */
110     void closeNodeScope(Node n, boolean condition) {
111         if (condition) {
112             int a = nodeArity();
113             mk = ((Integer) marks.pop()).intValue();
114             while (a-- > 0) {
115                 Node c = popNode();
116                 c.jjtSetParent(n);
117                 n.jjtAddChild(c, a);
118             }
119             n.jjtClose();
120             pushNode(n);
121             node_created = true;
122         } else {
123             mk = ((Integer) marks.pop()).intValue();
124             node_created = false;
125         }
126     }
127 }