View Javadoc

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