001: /* Generated By:JJTree: Do not edit this line. .\JJTSyntaxTreeBuilderState.java */
002:
003: package org.openrdf.query.parser.sparql.ast;
004:
005: class JJTSyntaxTreeBuilderState {
006:
007: private java.util.Stack nodes;
008:
009: private java.util.Stack marks;
010:
011: private int sp; // number of nodes on stack
012:
013: private int mk; // current mark
014:
015: private boolean node_created;
016:
017: JJTSyntaxTreeBuilderState() {
018: nodes = new java.util.Stack();
019: marks = new java.util.Stack();
020: sp = 0;
021: mk = 0;
022: }
023:
024: /*
025: * Determines whether the current node was actually closed and pushed. This
026: * should only be called in the final user action of a node scope.
027: */
028: boolean nodeCreated() {
029: return node_created;
030: }
031:
032: /*
033: * Call this to reinitialize the node stack. It is called automatically by
034: * the parser's ReInit() method.
035: */
036: void reset() {
037: nodes.removeAllElements();
038: marks.removeAllElements();
039: sp = 0;
040: mk = 0;
041: }
042:
043: /*
044: * Returns the root node of the AST. It only makes sense to call this after a
045: * successful parse.
046: */
047: Node rootNode() {
048: return (Node) nodes.elementAt(0);
049: }
050:
051: /* Pushes a node on to the stack. */
052: void pushNode(Node n) {
053: nodes.push(n);
054: ++sp;
055: }
056:
057: /*
058: * Returns the node on the top of the stack, and remove it from the stack.
059: */
060: Node popNode() {
061: if (--sp < mk) {
062: mk = ((Integer) marks.pop()).intValue();
063: }
064: return (Node) nodes.pop();
065: }
066:
067: /* Returns the node currently on the top of the stack. */
068: Node peekNode() {
069: return (Node) nodes.peek();
070: }
071:
072: /*
073: * Returns the number of children on the stack in the current node scope.
074: */
075: int nodeArity() {
076: return sp - mk;
077: }
078:
079: void clearNodeScope(Node n) {
080: while (sp > mk) {
081: popNode();
082: }
083: mk = ((Integer) marks.pop()).intValue();
084: }
085:
086: void openNodeScope(Node n) {
087: marks.push(new Integer(mk));
088: mk = sp;
089: n.jjtOpen();
090: }
091:
092: /*
093: * A definite node is constructed from a specified number of children. That
094: * number of nodes are popped from the stack and made the children of the
095: * definite node. Then the definite node is pushed on to the stack.
096: */
097: void closeNodeScope(Node n, int num) {
098: mk = ((Integer) marks.pop()).intValue();
099: while (num-- > 0) {
100: Node c = popNode();
101: c.jjtSetParent(n);
102: n.jjtAddChild(c, num);
103: }
104: n.jjtClose();
105: pushNode(n);
106: node_created = true;
107: }
108:
109: /*
110: * A conditional node is constructed if its condition is true. All the nodes
111: * that have been pushed since the node was opened are made children of the
112: * the conditional node, which is then pushed on to the stack. If the
113: * condition is false the node is not constructed and they are left on the
114: * stack.
115: */
116: void closeNodeScope(Node n, boolean condition) {
117: if (condition) {
118: int a = nodeArity();
119: mk = ((Integer) marks.pop()).intValue();
120: while (a-- > 0) {
121: Node c = popNode();
122: c.jjtSetParent(n);
123: n.jjtAddChild(c, a);
124: }
125: n.jjtClose();
126: pushNode(n);
127: node_created = true;
128: } else {
129: mk = ((Integer) marks.pop()).intValue();
130: node_created = false;
131: }
132: }
133: }
|