/// \file /// Implementation of token/tree streams that are used by the /// tree re-write rules to manipulate the tokens and trees produced /// by rules that are subject to rewrite directives. /// // [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 // Static support function forward declarations for the stream types. // static void reset (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); static void add (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * el, void (ANTLR3_CDECL *freePtr)(void *)); static void * next (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); static pANTLR3_BASE_TREE nextTree (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); static void * nextToken (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); static void * _next (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); static void * dupTok (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * el); static void * dupTree (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * el); static void * dupTreeNode (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * el); static pANTLR3_BASE_TREE toTree (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * element); static pANTLR3_BASE_TREE toTreeNode (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * element); static ANTLR3_BOOLEAN hasNext (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); static pANTLR3_BASE_TREE nextNode (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); static pANTLR3_BASE_TREE nextNodeNode (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); static pANTLR3_BASE_TREE nextNodeToken (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); static ANTLR3_UINT32 size (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); static void * getDescription (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); static void freeRS (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); static void expungeRS (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); // Place a now unused rewrite stream back on the rewrite stream pool // so we can reuse it if we need to. // static void freeRS (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) { // Before placing the stream back in the pool, we // need to clear any vector it has. This is so any // free pointers that are associated with the // entires are called. // if (stream->elements != NULL) { // Factory generated vectors can be returned to the // vector factory for later reuse. // if (stream->elements->factoryMade == ANTLR3_TRUE) { pANTLR3_VECTOR_FACTORY factory = ((pANTLR3_COMMON_TREE_ADAPTOR)(stream->adaptor->super))->arboretum->vFactory; factory->returnVector(factory, stream->elements); stream->elements = NULL; } else { // Other vectors we clear and allow to be reused if they come off the // rewrite stream free stack and are reused. // stream->elements->clear(stream->elements); stream->freeElements = ANTLR3_TRUE; } } else { stream->freeElements = ANTLR3_FALSE; // Just in case } // Add the stream into the recognizer stream stack vector // adding the stream memory free routine so that // it is thrown away when the stack vector is destroyed // stream->rec->state->rStreams->add(stream->rec->state->rStreams, stream, (void(*)(void *))expungeRS); } /** Do special nilNode reuse detection for node streams. */ static void freeNodeRS(pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) { pANTLR3_BASE_TREE tree; // Before placing the stream back in the pool, we // need to clear any vector it has. This is so any // free pointers that are associated with the // entires are called. However, if this particular function is called // then we know that the entries in the stream are definately // tree nodes. Hence we check to see if any of them were nilNodes as // if they were, we can reuse them. // if (stream->elements != NULL) { // We have some elements to traverse // ANTLR3_UINT32 i; for (i = 1; i<= stream->elements->count; i++) { tree = (pANTLR3_BASE_TREE)(stream->elements->elements[i-1].element); if (tree != NULL && tree->isNilNode(tree)) { // Had to remove this for now, check is not comprehensive enough // tree->reuse(tree); } } // Factory generated vectors can be returned to the // vector factory for later reuse. // if (stream->elements->factoryMade == ANTLR3_TRUE) { pANTLR3_VECTOR_FACTORY factory = ((pANTLR3_COMMON_TREE_ADAPTOR)(stream->adaptor->super))->arboretum->vFactory; factory->returnVector(factory, stream->elements); stream->elements = NULL; } else { stream->elements->clear(stream->elements); stream->freeElements = ANTLR3_TRUE; } } else { if (stream->singleElement != NULL) { tree = (pANTLR3_BASE_TREE)(stream->singleElement); if (tree->isNilNode(tree)) { // Had to remove this for now, check is not comprehensive enough // tree->reuse(tree); } } stream->singleElement = NULL; stream->freeElements = ANTLR3_FALSE; // Just in case } // Add the stream into the recognizer stream stack vector // adding the stream memory free routine so that // it is thrown away when the stack vector is destroyed // stream->rec->state->rStreams->add(stream->rec->state->rStreams, stream, (void(*)(void *))expungeRS); } static void expungeRS(pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) { if (stream->freeElements == ANTLR3_TRUE && stream->elements != NULL) { stream->elements->free(stream->elements); } ANTLR3_FREE(stream); } // Functions for creating streams // static pANTLR3_REWRITE_RULE_ELEMENT_STREAM antlr3RewriteRuleElementStreamNewAE(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description) { pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream; // First - do we already have a rewrite stream that was returned // to the pool? If we do, then we will just reuse it by resetting // the generic interface. // if (rec->state->rStreams->count > 0) { // Remove the entry from the vector. We do not // cause it to be freed by using remove. // stream = (pANTLR3_REWRITE_RULE_ELEMENT_STREAM)rec->state->rStreams->remove(rec->state->rStreams, rec->state->rStreams->count - 1); // We found a stream we can reuse. // If the stream had a vector, then it will have been cleared // when the freeRS was called that put it in this stack // } else { // Ok, we need to allocate a new one as there were none on the stack. // First job is to create the memory we need. // stream = (pANTLR3_REWRITE_RULE_ELEMENT_STREAM) ANTLR3_MALLOC((size_t)(sizeof(ANTLR3_REWRITE_RULE_ELEMENT_STREAM))); if (stream == NULL) { return NULL; } stream->elements = NULL; stream->freeElements = ANTLR3_FALSE; } // Populate the generic interface // stream->rec = rec; stream->reset = reset; stream->add = add; stream->next = next; stream->nextTree = nextTree; stream->nextNode = nextNode; stream->nextToken = nextToken; stream->_next = _next; stream->hasNext = hasNext; stream->size = size; stream->getDescription = getDescription; stream->toTree = toTree; stream->free = freeRS; stream->singleElement = NULL; // Reset the stream to empty. // stream->cursor = 0; stream->dirty = ANTLR3_FALSE; // Install the description // stream->elementDescription = description; // Install the adaptor // stream->adaptor = adaptor; return stream; } static pANTLR3_REWRITE_RULE_ELEMENT_STREAM antlr3RewriteRuleElementStreamNewAEE(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, void * oneElement) { pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream; // First job is to create the memory we need. // stream = antlr3RewriteRuleElementStreamNewAE(adaptor, rec, description); if (stream == NULL) { return NULL; } // Stream seems good so we need to add the supplied element // if (oneElement != NULL) { stream->add(stream, oneElement, NULL); } return stream; } static pANTLR3_REWRITE_RULE_ELEMENT_STREAM antlr3RewriteRuleElementStreamNewAEV(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, pANTLR3_VECTOR vector) { pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream; // First job is to create the memory we need. // stream = antlr3RewriteRuleElementStreamNewAE(adaptor, rec, description); if (stream == NULL) { return stream; } // Stream seems good so we need to install the vector we were // given. We assume that someone else is going to free the // vector. // if (stream->elements != NULL && stream->elements->factoryMade == ANTLR3_FALSE && stream->freeElements == ANTLR3_TRUE ) { stream->elements->free(stream->elements); } stream->elements = vector; stream->freeElements = ANTLR3_FALSE; return stream; } // Token rewrite stream ... // ANTLR3_API pANTLR3_REWRITE_RULE_TOKEN_STREAM antlr3RewriteRuleTOKENStreamNewAE(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description) { pANTLR3_REWRITE_RULE_TOKEN_STREAM stream; // First job is to create the memory we need. // stream = antlr3RewriteRuleElementStreamNewAE(adaptor, rec, description); if (stream == NULL) { return stream; } // Install the token based overrides // stream->dup = dupTok; stream->nextNode = nextNodeToken; // No nextNode implementation for a token rewrite stream // return stream; } ANTLR3_API pANTLR3_REWRITE_RULE_TOKEN_STREAM antlr3RewriteRuleTOKENStreamNewAEE(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, void * oneElement) { pANTLR3_REWRITE_RULE_TOKEN_STREAM stream; // First job is to create the memory we need. // stream = antlr3RewriteRuleElementStreamNewAEE(adaptor, rec, description, oneElement); // Install the token based overrides // stream->dup = dupTok; stream->nextNode = nextNodeToken; // No nextNode implementation for a token rewrite stream // return stream; } ANTLR3_API pANTLR3_REWRITE_RULE_TOKEN_STREAM antlr3RewriteRuleTOKENStreamNewAEV(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, pANTLR3_VECTOR vector) { pANTLR3_REWRITE_RULE_TOKEN_STREAM stream; // First job is to create the memory we need. // stream = antlr3RewriteRuleElementStreamNewAEV(adaptor, rec, description, vector); // Install the token based overrides // stream->dup = dupTok; stream->nextNode = nextNodeToken; // No nextNode implementation for a token rewrite stream // return stream; } // Subtree rewrite stream // ANTLR3_API pANTLR3_REWRITE_RULE_SUBTREE_STREAM antlr3RewriteRuleSubtreeStreamNewAE(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description) { pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream; // First job is to create the memory we need. // stream = antlr3RewriteRuleElementStreamNewAE(adaptor, rec, description); if (stream == NULL) { return stream; } // Install the subtree based overrides // stream->dup = dupTree; stream->nextNode = nextNode; stream->free = freeNodeRS; return stream; } ANTLR3_API pANTLR3_REWRITE_RULE_SUBTREE_STREAM antlr3RewriteRuleSubtreeStreamNewAEE(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, void * oneElement) { pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream; // First job is to create the memory we need. // stream = antlr3RewriteRuleElementStreamNewAEE(adaptor, rec, description, oneElement); if (stream == NULL) { return stream; } // Install the subtree based overrides // stream->dup = dupTree; stream->nextNode = nextNode; stream->free = freeNodeRS; return stream; } ANTLR3_API pANTLR3_REWRITE_RULE_SUBTREE_STREAM antlr3RewriteRuleSubtreeStreamNewAEV(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, pANTLR3_VECTOR vector) { pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream; // First job is to create the memory we need. // stream = antlr3RewriteRuleElementStreamNewAEV(adaptor, rec, description, vector); if (stream == NULL) { return NULL; } // Install the subtree based overrides // stream->dup = dupTree; stream->nextNode = nextNode; stream->free = freeNodeRS; return stream; } // Node rewrite stream ... // ANTLR3_API pANTLR3_REWRITE_RULE_NODE_STREAM antlr3RewriteRuleNODEStreamNewAE(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description) { pANTLR3_REWRITE_RULE_NODE_STREAM stream; // First job is to create the memory we need. // stream = antlr3RewriteRuleElementStreamNewAE(adaptor, rec, description); if (stream == NULL) { return stream; } // Install the node based overrides // stream->dup = dupTreeNode; stream->toTree = toTreeNode; stream->nextNode = nextNodeNode; stream->free = freeNodeRS; return stream; } ANTLR3_API pANTLR3_REWRITE_RULE_NODE_STREAM antlr3RewriteRuleNODEStreamNewAEE(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, void * oneElement) { pANTLR3_REWRITE_RULE_NODE_STREAM stream; // First job is to create the memory we need. // stream = antlr3RewriteRuleElementStreamNewAEE(adaptor, rec, description, oneElement); // Install the node based overrides // stream->dup = dupTreeNode; stream->toTree = toTreeNode; stream->nextNode = nextNodeNode; stream->free = freeNodeRS; return stream; } ANTLR3_API pANTLR3_REWRITE_RULE_NODE_STREAM antlr3RewriteRuleNODEStreamNewAEV(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, pANTLR3_VECTOR vector) { pANTLR3_REWRITE_RULE_NODE_STREAM stream; // First job is to create the memory we need. // stream = antlr3RewriteRuleElementStreamNewAEV(adaptor, rec, description, vector); // Install the Node based overrides // stream->dup = dupTreeNode; stream->toTree = toTreeNode; stream->nextNode = nextNodeNode; stream->free = freeNodeRS; return stream; } //---------------------------------------------------------------------- // Static support functions /// Reset the condition of this stream so that it appears we have /// not consumed any of its elements. Elements themselves are untouched. /// static void reset (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) { stream->dirty = ANTLR3_TRUE; stream->cursor = 0; } // Add a new pANTLR3_BASE_TREE to this stream // static void add (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * el, void (ANTLR3_CDECL *freePtr)(void *)) { if (el== NULL) { return; } // As we may be reusing a stream, we may already have allocated // a rewrite stream vector. If we have then is will be empty if // we have either zero or just one element in the rewrite stream // if (stream->elements != NULL && stream->elements->count > 0) { // We already have >1 entries in the stream. So we can just add this new element to the existing // collection. // stream->elements->add(stream->elements, el, freePtr); return; } if (stream->singleElement == NULL) { stream->singleElement = el; return; } // If we got here then we had only the one element so far // and we must now create a vector to hold a collection of them // if (stream->elements == NULL) { pANTLR3_VECTOR_FACTORY factory = ((pANTLR3_COMMON_TREE_ADAPTOR)(stream->adaptor->super))->arboretum->vFactory; stream->elements = factory->newVector(factory); stream->freeElements = ANTLR3_TRUE; // We 'ummed it, so we play it son. } stream->elements->add (stream->elements, stream->singleElement, freePtr); stream->elements->add (stream->elements, el, freePtr); stream->singleElement = NULL; return; } /// Return the next element in the stream. If out of elements, throw /// an exception unless size()==1. If size is 1, then return elements[0]. /// Return a duplicate node/subtree if stream is out of elements and /// size==1. If we've already used the element, dup (dirty bit set). /// static pANTLR3_BASE_TREE nextTree(pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) { ANTLR3_UINT32 n; void * el; n = stream->size(stream); if ( stream->dirty || (stream->cursor >=n && n==1) ) { // if out of elements and size is 1, dup // el = stream->_next(stream); return (pANTLR3_BASE_TREE)stream->dup(stream, el); } // test size above then fetch // el = stream->_next(stream); return (pANTLR3_BASE_TREE)el; } /// Return the next element for a caller that wants just the token /// static void * nextToken (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) { return stream->_next(stream); } /// Return the next element in the stream. If out of elements, throw /// an exception unless size()==1. If size is 1, then return elements[0]. /// static void * next (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) { ANTLR3_UINT32 s; s = stream->size(stream); if (stream->cursor >= s && s == 1) { pANTLR3_BASE_TREE el; el = (pANTLR3_BASE_TREE)stream->_next(stream); return stream->dup(stream, el); } return stream->_next(stream); } /// Do the work of getting the next element, making sure that it's /// a tree node or subtree. Deal with the optimization of single- /// element list versus list of size > 1. Throw an exception (or something similar) /// if the stream is empty or we're out of elements and size>1. /// You can override in a 'subclass' if necessary. /// static void * _next (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) { ANTLR3_UINT32 n; pANTLR3_BASE_TREE t; n = stream->size(stream); if (n == 0) { // This means that the stream is empty // return NULL; // Caller must cope with this } // Traversed all the available elements already? // if (stream->cursor >= n) { if (n == 1) { // Special case when size is single element, it will just dup a lot // return stream->toTree(stream, stream->singleElement); } // Out of elements and the size is not 1, so we cannot assume // that we just duplicate the entry n times (such as ID ent+ -> ^(ID ent)+) // This means we ran out of elements earlier than was expected. // return NULL; // Caller must cope with this } // Elements available either for duping or just available // if (stream->singleElement != NULL) { stream->cursor++; // Cursor advances even for single element as this tells us to dup() return stream->toTree(stream, stream->singleElement); } // More than just a single element so we extract it from the // vector. // t = stream->toTree(stream, stream->elements->get(stream->elements, stream->cursor)); stream->cursor++; return t; } #ifdef ANTLR3_WINDOWS #pragma warning(push) #pragma warning(disable : 4100) #endif /// When constructing trees, sometimes we need to dup a token or AST /// subtree. Dup'ing a token means just creating another AST node /// around it. For trees, you must call the adaptor.dupTree(). /// static void * dupTok (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * el) { ANTLR3_FPRINTF(stderr, "dup() cannot be called on a token rewrite stream!!"); return NULL; } #ifdef ANTLR3_WINDOWS #pragma warning(pop) #endif /// When constructing trees, sometimes we need to dup a token or AST /// subtree. Dup'ing a token means just creating another AST node /// around it. For trees, you must call the adaptor.dupTree(). /// static void * dupTree (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * element) { return stream->adaptor->dupNode(stream->adaptor, (pANTLR3_BASE_TREE)element); } #ifdef ANTLR3_WINDOWS #pragma warning(push) #pragma warning(disable : 4100) #endif /// When constructing trees, sometimes we need to dup a token or AST /// subtree. Dup'ing a token means just creating another AST node /// around it. For trees, you must call the adaptor.dupTree(). /// static void * dupTreeNode (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * element) { ANTLR3_FPRINTF(stderr, "dup() cannot be called on a node rewrite stream!!!"); return NULL; } /// We don;t explicitly convert to a tree unless the call goes to /// nextTree, which means rewrites are heterogeneous /// static pANTLR3_BASE_TREE toTree (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * element) { return (pANTLR3_BASE_TREE)element; } #ifdef ANTLR3_WINDOWS #pragma warning(pop) #endif /// Ensure stream emits trees; tokens must be converted to AST nodes. /// AST nodes can be passed through unmolested. /// #ifdef ANTLR3_WINDOWS #pragma warning(push) #pragma warning(disable : 4100) #endif static pANTLR3_BASE_TREE toTreeNode (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * element) { return (pANTLR3_BASE_TREE)stream->adaptor->dupNode(stream->adaptor, (pANTLR3_BASE_TREE)element); } #ifdef ANTLR3_WINDOWS #pragma warning(pop) #endif /// Returns ANTLR3_TRUE if there is a next element available /// static ANTLR3_BOOLEAN hasNext (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) { if ( (stream->singleElement != NULL && stream->cursor < 1) || (stream->elements != NULL && stream->cursor < stream->elements->size(stream->elements))) { return ANTLR3_TRUE; } else { return ANTLR3_FALSE; } } /// Get the next token from the list and create a node for it /// This is the implementation for token streams. /// static pANTLR3_BASE_TREE nextNodeToken(pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) { return (pANTLR3_BASE_TREE)stream->adaptor->create(stream->adaptor, (pANTLR3_COMMON_TOKEN)stream->_next(stream)); } static pANTLR3_BASE_TREE nextNodeNode(pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) { return (pANTLR3_BASE_TREE)stream->_next(stream); } /// Treat next element as a single node even if it's a subtree. /// This is used instead of next() when the result has to be a /// tree root node. Also prevents us from duplicating recently-added /// children; e.g., ^(type ID)+ adds ID to type and then 2nd iteration /// must dup the type node, but ID has been added. /// /// Referencing to a rule result twice is ok; dup entire tree as /// we can't be adding trees; e.g., expr expr. /// static pANTLR3_BASE_TREE nextNode (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) { ANTLR3_UINT32 n; pANTLR3_BASE_TREE el = (pANTLR3_BASE_TREE)stream->_next(stream); n = stream->size(stream); if (stream->dirty == ANTLR3_TRUE || (stream->cursor > n && n == 1)) { // We are out of elements and the size is 1, which means we just // dup the node that we have // return (pANTLR3_BASE_TREE)stream->adaptor->dupNode(stream->adaptor, el); } // We were not out of nodes, so the one we received is the one to return // return el; } /// Number of elements available in the stream /// static ANTLR3_UINT32 size (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) { ANTLR3_UINT32 n = 0; /// Should be a count of one if singleElement is set. I copied this /// logic from the java implementation, which I suspect is just guarding /// against someone setting singleElement and forgetting to NULL it out /// if (stream->singleElement != NULL) { n = 1; } else { if (stream->elements != NULL) { return (ANTLR3_UINT32)(stream->elements->count); } } return n; } /// Returns the description string if there is one available (check for NULL). /// static void * getDescription (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) { if (stream->elementDescription == NULL) { stream->elementDescription = (void*)""; } return stream->elementDescription; }