| /// \file |
| /// Definition of the ANTLR3 common tree node stream. |
| /// |
| |
| #ifndef _ANTLR3_COMMON_TREE_NODE_STREAM__H |
| #define _ANTLR3_COMMON_TREE_NODE_STREAM__H |
| |
| // [The "BSD licence"] |
| // Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC |
| // http://www.temporal-wave.com |
| // http://www.linkedin.com/in/jimidle |
| // |
| // All rights reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions |
| // are met: |
| // 1. Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // 2. Redistributions in binary form must reproduce the above copyright |
| // notice, this list of conditions and the following disclaimer in the |
| // documentation and/or other materials provided with the distribution. |
| // 3. The name of the author may not be used to endorse or promote products |
| // derived from this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| #include <antlr3defs.h> |
| #include <antlr3commontreeadaptor.h> |
| #include <antlr3commontree.h> |
| #include <antlr3collections.h> |
| #include <antlr3intstream.h> |
| #include <antlr3string.h> |
| |
| /// Token buffer initial size settings ( will auto increase) |
| /// |
| #define DEFAULT_INITIAL_BUFFER_SIZE 100 |
| #define INITIAL_CALL_STACK_SIZE 10 |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| typedef struct ANTLR3_TREE_NODE_STREAM_struct |
| { |
| /// Any interface that implements this interface (is a |
| /// super structure containing this structure), may store the pointer |
| /// to itself here in the super pointer, which is not used by |
| /// the tree node stream. This will point to an implementation |
| /// of ANTLR3_COMMON_TREE_NODE_STREAM in this case. |
| /// |
| pANTLR3_COMMON_TREE_NODE_STREAM ctns; |
| |
| /// All input streams implement the ANTLR3_INT_STREAM interface... |
| /// |
| pANTLR3_INT_STREAM istream; |
| |
| /// Get tree node at current input pointer + i ahead where i=1 is next node. |
| /// i<0 indicates nodes in the past. So LT(-1) is previous node, but |
| /// implementations are not required to provide results for k < -1. |
| /// LT(0) is undefined. For i>=n, return null. |
| /// Return NULL for LT(0) and any index that results in an absolute address |
| /// that is negative (beyond the start of the list). |
| /// |
| /// This is analogous to the LT() method of the TokenStream, but this |
| /// returns a tree node instead of a token. Makes code gen identical |
| /// for both parser and tree grammars. :) |
| /// |
| pANTLR3_BASE_TREE (*_LT) (struct ANTLR3_TREE_NODE_STREAM_struct * tns, ANTLR3_INT32 k); |
| |
| /// Where is this stream pulling nodes from? This is not the name, but |
| /// the object that provides node objects. |
| /// |
| pANTLR3_BASE_TREE (*getTreeSource) (struct ANTLR3_TREE_NODE_STREAM_struct * tns); |
| |
| /// What adaptor can tell me how to interpret/navigate nodes and |
| /// trees. E.g., get text of a node. |
| /// |
| pANTLR3_BASE_TREE_ADAPTOR (*getTreeAdaptor) (struct ANTLR3_TREE_NODE_STREAM_struct * tns); |
| |
| /// As we flatten the tree, we use UP, DOWN nodes to represent |
| /// the tree structure. When debugging we need unique nodes |
| /// so we have to instantiate new ones. When doing normal tree |
| /// parsing, it's slow and a waste of memory to create unique |
| /// navigation nodes. Default should be false; |
| /// |
| void (*setUniqueNavigationNodes) (struct ANTLR3_TREE_NODE_STREAM_struct * tns, ANTLR3_BOOLEAN uniqueNavigationNodes); |
| |
| pANTLR3_STRING (*toString) (struct ANTLR3_TREE_NODE_STREAM_struct * tns); |
| |
| /// Return the text of all nodes from start to stop, inclusive. |
| /// If the stream does not buffer all the nodes then it can still |
| /// walk recursively from start until stop. You can always return |
| /// null or "" too, but users should not access $ruleLabel.text in |
| /// an action of course in that case. |
| /// |
| pANTLR3_STRING (*toStringSS) (struct ANTLR3_TREE_NODE_STREAM_struct * tns, pANTLR3_BASE_TREE start, pANTLR3_BASE_TREE stop); |
| |
| /// Return the text of all nodes from start to stop, inclusive, into the |
| /// supplied buffer. |
| /// If the stream does not buffer all the nodes then it can still |
| /// walk recursively from start until stop. You can always return |
| /// null or "" too, but users should not access $ruleLabel.text in |
| /// an action of course in that case. |
| /// |
| void (*toStringWork) (struct ANTLR3_TREE_NODE_STREAM_struct * tns, pANTLR3_BASE_TREE start, pANTLR3_BASE_TREE stop, pANTLR3_STRING buf); |
| |
| /// Release up any and all space the the interface allocate, including for this structure. |
| /// |
| void (*free) (struct ANTLR3_TREE_NODE_STREAM_struct * tns); |
| |
| /// Get a tree node at an absolute index i; 0..n-1. |
| /// If you don't want to buffer up nodes, then this method makes no |
| /// sense for you. |
| /// |
| pANTLR3_BASE_TREE (*get) (struct ANTLR3_TREE_NODE_STREAM_struct * tns, ANTLR3_INT32 i); |
| |
| // REWRITING TREES (used by tree parser) |
| |
| /// Replace from start to stop child index of parent with t, which might |
| /// be a list. Number of children may be different |
| /// after this call. The stream is notified because it is walking the |
| /// tree and might need to know you are monkeying with the underlying |
| /// tree. Also, it might be able to modify the node stream to avoid |
| /// restreaming for future phases. |
| /// |
| /// If parent is null, don't do anything; must be at root of overall tree. |
| /// Can't replace whatever points to the parent externally. Do nothing. |
| /// |
| void (*replaceChildren) (struct ANTLR3_TREE_NODE_STREAM_struct * tns, pANTLR3_BASE_TREE parent, ANTLR3_INT32 startChildIndex, ANTLR3_INT32 stopChildIndex, pANTLR3_BASE_TREE t); |
| |
| } |
| ANTLR3_TREE_NODE_STREAM; |
| |
| typedef struct ANTLR3_COMMON_TREE_NODE_STREAM_struct |
| { |
| /// Any interface that implements this interface (is a |
| /// super structure containing this structure), may store the pointer |
| /// to itself here in the super pointer, which is not used by |
| /// the common tree node stream. |
| /// |
| void * super; |
| |
| /// Pointer to the tree node stream interface |
| /// |
| pANTLR3_TREE_NODE_STREAM tnstream; |
| |
| /// String factory for use by anything that wishes to create strings |
| /// such as a tree representation or some copy of the text etc. |
| /// |
| pANTLR3_STRING_FACTORY stringFactory; |
| |
| /// Dummy tree node that indicates a descent into a child |
| /// tree. Initialized by a call to create a new interface. |
| /// |
| ANTLR3_COMMON_TREE DOWN; |
| |
| /// Dummy tree node that indicates a descent up to a parent |
| /// tree. Initialized by a call to create a new interface. |
| /// |
| ANTLR3_COMMON_TREE UP; |
| |
| /// Dummy tree node that indicates the termination point of the |
| /// tree. Initialized by a call to create a new interface. |
| /// |
| ANTLR3_COMMON_TREE EOF_NODE; |
| |
| /// Dummy node that is returned if we need to indicate an invalid node |
| /// for any reason. |
| /// |
| ANTLR3_COMMON_TREE INVALID_NODE; |
| |
| /// The complete mapping from stream index to tree node. |
| /// This buffer includes pointers to DOWN, UP, and EOF nodes. |
| /// It is built upon ctor invocation. The elements are type |
| /// Object as we don't what the trees look like. |
| /// |
| /// Load upon first need of the buffer so we can set token types |
| /// of interest for reverseIndexing. Slows us down a wee bit to |
| /// do all of the if p==-1 testing everywhere though, though in C |
| /// you won't really be able to measure this. |
| /// |
| /// Must be freed when the tree node stream is torn down. |
| /// |
| pANTLR3_VECTOR nodes; |
| |
| /// If set to ANTLR3_TRUE then the navigation nodes UP, DOWN are |
| /// duplicated rather than reused within the tree. |
| /// |
| ANTLR3_BOOLEAN uniqueNavigationNodes; |
| |
| /// Which tree are we navigating ? |
| /// |
| pANTLR3_BASE_TREE root; |
| |
| /// Pointer to tree adaptor interface that manipulates/builds |
| /// the tree. |
| /// |
| pANTLR3_BASE_TREE_ADAPTOR adaptor; |
| |
| /// As we walk down the nodes, we must track parent nodes so we know |
| /// where to go after walking the last child of a node. When visiting |
| /// a child, push current node and current index (current index |
| /// is first stored in the tree node structure to avoid two stacks. |
| /// |
| pANTLR3_STACK nodeStack; |
| |
| /// The current index into the nodes vector of the current tree |
| /// we are parsing and possibly rewriting. |
| /// |
| ANTLR3_INT32 p; |
| |
| /// Which node are we currently visiting? |
| /// |
| pANTLR3_BASE_TREE currentNode; |
| |
| /// Which node did we last visit? Used for LT(-1) |
| /// |
| pANTLR3_BASE_TREE previousNode; |
| |
| /// Which child are we currently visiting? If -1 we have not visited |
| /// this node yet; next consume() request will set currentIndex to 0. |
| /// |
| ANTLR3_INT32 currentChildIndex; |
| |
| /// What node index did we just consume? i=0..n-1 for n node trees. |
| /// IntStream.next is hence 1 + this value. Size will be same. |
| /// |
| ANTLR3_MARKER absoluteNodeIndex; |
| |
| /// Buffer tree node stream for use with LT(i). This list grows |
| /// to fit new lookahead depths, but consume() wraps like a circular |
| /// buffer. |
| /// |
| pANTLR3_BASE_TREE * lookAhead; |
| |
| /// Number of elements available in the lookahead buffer at any point in |
| /// time. This is the current size of the array. |
| /// |
| ANTLR3_UINT32 lookAheadLength; |
| |
| /// lookAhead[head] is the first symbol of lookahead, LT(1). |
| /// |
| ANTLR3_UINT32 head; |
| |
| /// Add new lookahead at lookahead[tail]. tail wraps around at the |
| /// end of the lookahead buffer so tail could be less than head. |
| /// |
| ANTLR3_UINT32 tail; |
| |
| /// Calls to mark() may be nested so we have to track a stack of |
| /// them. The marker is an index into this stack. Index 0 is |
| /// the first marker. This is a List<TreeWalkState> |
| /// |
| pANTLR3_VECTOR markers; |
| |
| // INTERFACE |
| // |
| void (*fill) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns, ANTLR3_INT32 k); |
| |
| void (*addLookahead) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns, pANTLR3_BASE_TREE node); |
| |
| ANTLR3_BOOLEAN (*hasNext) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); |
| |
| pANTLR3_BASE_TREE (*next) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); |
| |
| pANTLR3_BASE_TREE (*handleRootnode) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); |
| |
| pANTLR3_BASE_TREE (*visitChild) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns, ANTLR3_UINT32 child); |
| |
| void (*addNavigationNode) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns, ANTLR3_UINT32 ttype); |
| |
| pANTLR3_BASE_TREE (*newDownNode) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); |
| |
| pANTLR3_BASE_TREE (*newUpNode) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); |
| |
| void (*walkBackToMostRecentNodeWithUnvisitedChildren) |
| (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); |
| |
| ANTLR3_BOOLEAN (*hasUniqueNavigationNodes) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); |
| |
| ANTLR3_UINT32 (*getLookaheadSize) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); |
| |
| void (*push) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns, ANTLR3_INT32 index); |
| |
| ANTLR3_INT32 (*pop) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); |
| |
| void (*reset) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); |
| |
| void (*free) (struct ANTLR3_COMMON_TREE_NODE_STREAM_struct * ctns); |
| |
| /// Indicates whether this node stream was derived from a prior |
| /// node stream to be used by a rewriting tree parser for instance. |
| /// If this flag is set to ANTLR3_TRUE, then when this stream is |
| /// closed it will not free the root tree as this tree always |
| /// belongs to the origniating node stream. |
| /// |
| ANTLR3_BOOLEAN isRewriter; |
| |
| } |
| ANTLR3_COMMON_TREE_NODE_STREAM; |
| |
| /** This structure is used to save the state information in the treenodestream |
| * when walking ahead with cyclic DFA or for syntactic predicates, |
| * we need to record the state of the tree node stream. This |
| * class wraps up the current state of the CommonTreeNodeStream. |
| * Calling mark() will push another of these on the markers stack. |
| */ |
| typedef struct ANTLR3_TREE_WALK_STATE_struct |
| { |
| ANTLR3_UINT32 currentChildIndex; |
| ANTLR3_MARKER absoluteNodeIndex; |
| pANTLR3_BASE_TREE currentNode; |
| pANTLR3_BASE_TREE previousNode; |
| ANTLR3_UINT32 nodeStackSize; |
| pANTLR3_BASE_TREE * lookAhead; |
| ANTLR3_UINT32 lookAheadLength; |
| ANTLR3_UINT32 tail; |
| ANTLR3_UINT32 head; |
| } |
| ANTLR3_TREE_WALK_STATE; |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif |