1324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// \file 2324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Implementation of token/tree streams that are used by the 3324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// tree re-write rules to manipulate the tokens and trees produced 4324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// by rules that are subject to rewrite directives. 5324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 6324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 7324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// [The "BSD licence"] 8324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC 9324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// http://www.temporal-wave.com 10324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// http://www.linkedin.com/in/jimidle 11324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 12324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// All rights reserved. 13324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 14324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// Redistribution and use in source and binary forms, with or without 15324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// modification, are permitted provided that the following conditions 16324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// are met: 17324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 1. Redistributions of source code must retain the above copyright 18324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// notice, this list of conditions and the following disclaimer. 19324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 2. Redistributions in binary form must reproduce the above copyright 20324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// notice, this list of conditions and the following disclaimer in the 21324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// documentation and/or other materials provided with the distribution. 22324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 3. The name of the author may not be used to endorse or promote products 23324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// derived from this software without specific prior written permission. 24324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 25324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 26324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 27324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 28324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 29324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 30324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 31324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 32324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 33324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 34324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 35324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 36324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#include <antlr3rewritestreams.h> 37324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 38324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// Static support function forward declarations for the stream types. 39324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 40324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void reset (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); 41324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void add (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * el, void (ANTLR3_CDECL *freePtr)(void *)); 42324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void * next (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); 43324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic pANTLR3_BASE_TREE nextTree (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); 44324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void * nextToken (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); 45324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void * _next (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); 46324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void * dupTok (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * el); 47324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void * dupTree (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * el); 48324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void * dupTreeNode (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * el); 49324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic pANTLR3_BASE_TREE toTree (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * element); 50324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic pANTLR3_BASE_TREE toTreeNode (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * element); 51324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic ANTLR3_BOOLEAN hasNext (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); 52324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic pANTLR3_BASE_TREE nextNode (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); 53324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic pANTLR3_BASE_TREE nextNodeNode (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); 54324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic pANTLR3_BASE_TREE nextNodeToken (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); 55324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic ANTLR3_UINT32 size (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); 56324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void * getDescription (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); 57324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void freeRS (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); 58324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void expungeRS (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream); 59324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 60324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 61324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// Place a now unused rewrite stream back on the rewrite stream pool 62324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// so we can reuse it if we need to. 63324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 64324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void 65324c4644fee44b9898524c09511bd33c3f12e2dfBen GruverfreeRS (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) 66324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 67324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Before placing the stream back in the pool, we 68324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // need to clear any vector it has. This is so any 69324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // free pointers that are associated with the 70324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // entires are called. 71324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 72324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream->elements != NULL) 73324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 74324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Factory generated vectors can be returned to the 75324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // vector factory for later reuse. 76324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 77324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream->elements->factoryMade == ANTLR3_TRUE) 78324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 79324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_VECTOR_FACTORY factory = ((pANTLR3_COMMON_TREE_ADAPTOR)(stream->adaptor->super))->arboretum->vFactory; 80324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver factory->returnVector(factory, stream->elements); 81324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 82324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->elements = NULL; 83324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 84324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver else 85324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 86324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Other vectors we clear and allow to be reused if they come off the 87324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // rewrite stream free stack and are reused. 88324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 89324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->elements->clear(stream->elements); 90324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->freeElements = ANTLR3_TRUE; 91324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 92324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 93324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver else 94324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 95324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->freeElements = ANTLR3_FALSE; // Just in case 96324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 97324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 98324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Add the stream into the recognizer stream stack vector 99324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // adding the stream memory free routine so that 100324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // it is thrown away when the stack vector is destroyed 101324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 102324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->rec->state->rStreams->add(stream->rec->state->rStreams, stream, (void(*)(void *))expungeRS); 103324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 104324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 105324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/** Do special nilNode reuse detection for node streams. 106324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 107324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void 108324c4644fee44b9898524c09511bd33c3f12e2dfBen GruverfreeNodeRS(pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) 109324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 110324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_BASE_TREE tree; 111324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 112324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Before placing the stream back in the pool, we 113324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // need to clear any vector it has. This is so any 114324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // free pointers that are associated with the 115324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // entires are called. However, if this particular function is called 116324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // then we know that the entries in the stream are definately 117324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // tree nodes. Hence we check to see if any of them were nilNodes as 118324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // if they were, we can reuse them. 119324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 120324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream->elements != NULL) 121324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 122324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // We have some elements to traverse 123324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 124324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ANTLR3_UINT32 i; 125324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 126324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver for (i = 1; i<= stream->elements->count; i++) 127324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 128324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver tree = (pANTLR3_BASE_TREE)(stream->elements->elements[i-1].element); 129324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (tree != NULL && tree->isNilNode(tree)) 130324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 131324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Had to remove this for now, check is not comprehensive enough 132324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // tree->reuse(tree); 133324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 134324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 135324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 136324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Factory generated vectors can be returned to the 137324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // vector factory for later reuse. 138324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 139324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream->elements->factoryMade == ANTLR3_TRUE) 140324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 141324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_VECTOR_FACTORY factory = ((pANTLR3_COMMON_TREE_ADAPTOR)(stream->adaptor->super))->arboretum->vFactory; 142324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver factory->returnVector(factory, stream->elements); 143324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 144324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->elements = NULL; 145324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 146324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver else 147324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 148324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->elements->clear(stream->elements); 149324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->freeElements = ANTLR3_TRUE; 150324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 151324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 152324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver else 153324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 154324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream->singleElement != NULL) 155324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 156324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver tree = (pANTLR3_BASE_TREE)(stream->singleElement); 157324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (tree->isNilNode(tree)) 158324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 159324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Had to remove this for now, check is not comprehensive enough 160324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // tree->reuse(tree); 161324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 162324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 163324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->singleElement = NULL; 164324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->freeElements = ANTLR3_FALSE; // Just in case 165324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 166324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 167324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Add the stream into the recognizer stream stack vector 168324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // adding the stream memory free routine so that 169324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // it is thrown away when the stack vector is destroyed 170324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 171324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->rec->state->rStreams->add(stream->rec->state->rStreams, stream, (void(*)(void *))expungeRS); 172324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 173324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void 174324c4644fee44b9898524c09511bd33c3f12e2dfBen GruverexpungeRS(pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) 175324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 176324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 177324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream->freeElements == ANTLR3_TRUE && stream->elements != NULL) 178324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 179324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->elements->free(stream->elements); 180324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 181324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ANTLR3_FREE(stream); 182324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 183324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 184324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// Functions for creating streams 185324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 186324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic pANTLR3_REWRITE_RULE_ELEMENT_STREAM 187324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverantlr3RewriteRuleElementStreamNewAE(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description) 188324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 189324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream; 190324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 191324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // First - do we already have a rewrite stream that was returned 192324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // to the pool? If we do, then we will just reuse it by resetting 193324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // the generic interface. 194324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 195324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (rec->state->rStreams->count > 0) 196324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 197324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Remove the entry from the vector. We do not 198324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // cause it to be freed by using remove. 199324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 200324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream = rec->state->rStreams->remove(rec->state->rStreams, rec->state->rStreams->count - 1); 201324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 202324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // We found a stream we can reuse. 203324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // If the stream had a vector, then it will have been cleared 204324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // when the freeRS was called that put it in this stack 205324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 206324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 207324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver else 208324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 209324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Ok, we need to allocate a new one as there were none on the stack. 210324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // First job is to create the memory we need. 211324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 212324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream = (pANTLR3_REWRITE_RULE_ELEMENT_STREAM) ANTLR3_MALLOC((size_t)(sizeof(ANTLR3_REWRITE_RULE_ELEMENT_STREAM))); 213324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 214324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream == NULL) 215324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 216324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return NULL; 217324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 218324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->elements = NULL; 219324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->freeElements = ANTLR3_FALSE; 220324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 221324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 222324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Populate the generic interface 223324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 224324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->rec = rec; 225324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->reset = reset; 226324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->add = add; 227324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->next = next; 228324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->nextTree = nextTree; 229324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->nextNode = nextNode; 230324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->nextToken = nextToken; 231324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->_next = _next; 232324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->hasNext = hasNext; 233324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->size = size; 234324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->getDescription = getDescription; 235324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->toTree = toTree; 236324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->free = freeRS; 237324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->singleElement = NULL; 238324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 239324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Reset the stream to empty. 240324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 241324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 242324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->cursor = 0; 243324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->dirty = ANTLR3_FALSE; 244324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 245324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Install the description 246324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 247324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->elementDescription = description; 248324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 249324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Install the adaptor 250324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 251324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->adaptor = adaptor; 252324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 253324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream; 254324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 255324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 256324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic pANTLR3_REWRITE_RULE_ELEMENT_STREAM 257324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverantlr3RewriteRuleElementStreamNewAEE(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, void * oneElement) 258324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 259324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream; 260324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 261324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // First job is to create the memory we need. 262324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 263324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream = antlr3RewriteRuleElementStreamNewAE(adaptor, rec, description); 264324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 265324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream == NULL) 266324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 267324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return NULL; 268324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 269324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 270324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Stream seems good so we need to add the supplied element 271324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 272324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (oneElement != NULL) 273324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 274324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->add(stream, oneElement, NULL); 275324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 276324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream; 277324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 278324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 279324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic pANTLR3_REWRITE_RULE_ELEMENT_STREAM 280324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverantlr3RewriteRuleElementStreamNewAEV(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, pANTLR3_VECTOR vector) 281324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 282324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream; 283324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 284324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // First job is to create the memory we need. 285324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 286324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream = antlr3RewriteRuleElementStreamNewAE(adaptor, rec, description); 287324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 288324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream == NULL) 289324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 290324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream; 291324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 292324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 293324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Stream seems good so we need to install the vector we were 294324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // given. We assume that someone else is going to free the 295324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // vector. 296324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 297324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream->elements != NULL && stream->elements->factoryMade == ANTLR3_FALSE && stream->freeElements == ANTLR3_TRUE ) 298324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 299324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->elements->free(stream->elements); 300324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 301324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->elements = vector; 302324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->freeElements = ANTLR3_FALSE; 303324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream; 304324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 305324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 306324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// Token rewrite stream ... 307324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 308324c4644fee44b9898524c09511bd33c3f12e2dfBen GruverANTLR3_API pANTLR3_REWRITE_RULE_TOKEN_STREAM 309324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverantlr3RewriteRuleTOKENStreamNewAE(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description) 310324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 311324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_REWRITE_RULE_TOKEN_STREAM stream; 312324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 313324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // First job is to create the memory we need. 314324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 315324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream = antlr3RewriteRuleElementStreamNewAE(adaptor, rec, description); 316324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 317324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream == NULL) 318324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 319324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream; 320324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 321324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 322324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Install the token based overrides 323324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 324324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->dup = dupTok; 325324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->nextNode = nextNodeToken; 326324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 327324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // No nextNode implementation for a token rewrite stream 328324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 329324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream; 330324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 331324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 332324c4644fee44b9898524c09511bd33c3f12e2dfBen GruverANTLR3_API pANTLR3_REWRITE_RULE_TOKEN_STREAM 333324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverantlr3RewriteRuleTOKENStreamNewAEE(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, void * oneElement) 334324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 335324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_REWRITE_RULE_TOKEN_STREAM stream; 336324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 337324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // First job is to create the memory we need. 338324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 339324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream = antlr3RewriteRuleElementStreamNewAEE(adaptor, rec, description, oneElement); 340324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 341324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Install the token based overrides 342324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 343324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->dup = dupTok; 344324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->nextNode = nextNodeToken; 345324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 346324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // No nextNode implementation for a token rewrite stream 347324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 348324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream; 349324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 350324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 351324c4644fee44b9898524c09511bd33c3f12e2dfBen GruverANTLR3_API pANTLR3_REWRITE_RULE_TOKEN_STREAM 352324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverantlr3RewriteRuleTOKENStreamNewAEV(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, pANTLR3_VECTOR vector) 353324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 354324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_REWRITE_RULE_TOKEN_STREAM stream; 355324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 356324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // First job is to create the memory we need. 357324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 358324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream = antlr3RewriteRuleElementStreamNewAEV(adaptor, rec, description, vector); 359324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 360324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Install the token based overrides 361324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 362324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->dup = dupTok; 363324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->nextNode = nextNodeToken; 364324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 365324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // No nextNode implementation for a token rewrite stream 366324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 367324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream; 368324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 369324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 370324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// Subtree rewrite stream 371324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 372324c4644fee44b9898524c09511bd33c3f12e2dfBen GruverANTLR3_API pANTLR3_REWRITE_RULE_SUBTREE_STREAM 373324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverantlr3RewriteRuleSubtreeStreamNewAE(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description) 374324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 375324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream; 376324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 377324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // First job is to create the memory we need. 378324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 379324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream = antlr3RewriteRuleElementStreamNewAE(adaptor, rec, description); 380324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 381324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream == NULL) 382324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 383324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream; 384324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 385324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 386324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Install the subtree based overrides 387324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 388324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->dup = dupTree; 389324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->nextNode = nextNode; 390324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->free = freeNodeRS; 391324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream; 392324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 393324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 394324c4644fee44b9898524c09511bd33c3f12e2dfBen GruverANTLR3_API pANTLR3_REWRITE_RULE_SUBTREE_STREAM 395324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverantlr3RewriteRuleSubtreeStreamNewAEE(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, void * oneElement) 396324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 397324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream; 398324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 399324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // First job is to create the memory we need. 400324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 401324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream = antlr3RewriteRuleElementStreamNewAEE(adaptor, rec, description, oneElement); 402324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 403324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream == NULL) 404324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 405324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream; 406324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 407324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 408324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Install the subtree based overrides 409324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 410324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->dup = dupTree; 411324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->nextNode = nextNode; 412324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->free = freeNodeRS; 413324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 414324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream; 415324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 416324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 417324c4644fee44b9898524c09511bd33c3f12e2dfBen GruverANTLR3_API pANTLR3_REWRITE_RULE_SUBTREE_STREAM 418324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverantlr3RewriteRuleSubtreeStreamNewAEV(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, pANTLR3_VECTOR vector) 419324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 420324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_REWRITE_RULE_SUBTREE_STREAM stream; 421324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 422324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // First job is to create the memory we need. 423324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 424324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream = antlr3RewriteRuleElementStreamNewAEV(adaptor, rec, description, vector); 425324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 426324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream == NULL) 427324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 428324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return NULL; 429324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 430324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 431324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Install the subtree based overrides 432324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 433324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->dup = dupTree; 434324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->nextNode = nextNode; 435324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->free = freeNodeRS; 436324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 437324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream; 438324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 439324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// Node rewrite stream ... 440324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 441324c4644fee44b9898524c09511bd33c3f12e2dfBen GruverANTLR3_API pANTLR3_REWRITE_RULE_NODE_STREAM 442324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverantlr3RewriteRuleNODEStreamNewAE(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description) 443324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 444324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_REWRITE_RULE_NODE_STREAM stream; 445324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 446324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // First job is to create the memory we need. 447324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 448324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream = antlr3RewriteRuleElementStreamNewAE(adaptor, rec, description); 449324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 450324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream == NULL) 451324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 452324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream; 453324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 454324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 455324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Install the node based overrides 456324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 457324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->dup = dupTreeNode; 458324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->toTree = toTreeNode; 459324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->nextNode = nextNodeNode; 460324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->free = freeNodeRS; 461324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 462324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream; 463324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 464324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 465324c4644fee44b9898524c09511bd33c3f12e2dfBen GruverANTLR3_API pANTLR3_REWRITE_RULE_NODE_STREAM 466324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverantlr3RewriteRuleNODEStreamNewAEE(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, void * oneElement) 467324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 468324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_REWRITE_RULE_NODE_STREAM stream; 469324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 470324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // First job is to create the memory we need. 471324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 472324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream = antlr3RewriteRuleElementStreamNewAEE(adaptor, rec, description, oneElement); 473324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 474324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Install the node based overrides 475324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 476324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->dup = dupTreeNode; 477324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->toTree = toTreeNode; 478324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->nextNode = nextNodeNode; 479324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->free = freeNodeRS; 480324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 481324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream; 482324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 483324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 484324c4644fee44b9898524c09511bd33c3f12e2dfBen GruverANTLR3_API pANTLR3_REWRITE_RULE_NODE_STREAM 485324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverantlr3RewriteRuleNODEStreamNewAEV(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_RECOGNIZER rec, pANTLR3_UINT8 description, pANTLR3_VECTOR vector) 486324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 487324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_REWRITE_RULE_NODE_STREAM stream; 488324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 489324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // First job is to create the memory we need. 490324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 491324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream = antlr3RewriteRuleElementStreamNewAEV(adaptor, rec, description, vector); 492324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 493324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Install the Node based overrides 494324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 495324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->dup = dupTreeNode; 496324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->toTree = toTreeNode; 497324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->nextNode = nextNodeNode; 498324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->free = freeNodeRS; 499324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 500324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream; 501324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 502324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 503324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver//---------------------------------------------------------------------- 504324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// Static support functions 505324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 506324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Reset the condition of this stream so that it appears we have 507324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// not consumed any of its elements. Elements themselves are untouched. 508324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 509324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void 510324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverreset (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) 511324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 512324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->dirty = ANTLR3_TRUE; 513324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->cursor = 0; 514324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 515324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 516324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// Add a new pANTLR3_BASE_TREE to this stream 517324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver// 518324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void 519324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruveradd (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * el, void (ANTLR3_CDECL *freePtr)(void *)) 520324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 521324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (el== NULL) 522324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 523324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return; 524324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 525324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // As we may be reusing a stream, we may already have allocated 526324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // a rewrite stream vector. If we have then is will be empty if 527324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // we have either zero or just one element in the rewrite stream 528324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 529324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream->elements != NULL && stream->elements->count > 0) 530324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 531324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // We already have >1 entries in the stream. So we can just add this new element to the existing 532324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // collection. 533324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 534324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->elements->add(stream->elements, el, freePtr); 535324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return; 536324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 537324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream->singleElement == NULL) 538324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 539324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->singleElement = el; 540324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return; 541324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 542324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 543324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // If we got here then we had only the one element so far 544324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // and we must now create a vector to hold a collection of them 545324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 546324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream->elements == NULL) 547324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 548324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_VECTOR_FACTORY factory = ((pANTLR3_COMMON_TREE_ADAPTOR)(stream->adaptor->super))->arboretum->vFactory; 549324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 550324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 551324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->elements = factory->newVector(factory); 552324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->freeElements = ANTLR3_TRUE; // We 'ummed it, so we play it son. 553324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 554324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 555324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->elements->add (stream->elements, stream->singleElement, freePtr); 556324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->elements->add (stream->elements, el, freePtr); 557324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->singleElement = NULL; 558324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 559324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return; 560324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 561324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 562324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Return the next element in the stream. If out of elements, throw 563324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// an exception unless size()==1. If size is 1, then return elements[0]. 564324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Return a duplicate node/subtree if stream is out of elements and 565324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// size==1. If we've already used the element, dup (dirty bit set). 566324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 567324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic pANTLR3_BASE_TREE 568324c4644fee44b9898524c09511bd33c3f12e2dfBen GruvernextTree(pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) 569324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 570324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ANTLR3_UINT32 n; 571324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver void * el; 572324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 573324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver n = stream->size(stream); 574324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 575324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if ( stream->dirty || (stream->cursor >=n && n==1) ) 576324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 577324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // if out of elements and size is 1, dup 578324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 579324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver el = stream->_next(stream); 580324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream->dup(stream, el); 581324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 582324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 583324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // test size above then fetch 584324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 585324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver el = stream->_next(stream); 586324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return el; 587324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 588324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 589324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Return the next element for a caller that wants just the token 590324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 591324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void * 592324c4644fee44b9898524c09511bd33c3f12e2dfBen GruvernextToken (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) 593324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 594324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream->_next(stream); 595324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 596324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 597324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Return the next element in the stream. If out of elements, throw 598324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// an exception unless size()==1. If size is 1, then return elements[0]. 599324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 600324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void * 601324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruvernext (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) 602324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 603324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ANTLR3_UINT32 s; 604324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 605324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver s = stream->size(stream); 606324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream->cursor >= s && s == 1) 607324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 608324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_BASE_TREE el; 609324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 610324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver el = stream->_next(stream); 611324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 612324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream->dup(stream, el); 613324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 614324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 615324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream->_next(stream); 616324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 617324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 618324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Do the work of getting the next element, making sure that it's 619324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// a tree node or subtree. Deal with the optimization of single- 620324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// element list versus list of size > 1. Throw an exception (or something similar) 621324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// if the stream is empty or we're out of elements and size>1. 622324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// You can override in a 'subclass' if necessary. 623324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 624324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void * 625324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver_next (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) 626324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 627324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ANTLR3_UINT32 n; 628324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_BASE_TREE t; 629324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 630324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver n = stream->size(stream); 631324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 632324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (n == 0) 633324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 634324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // This means that the stream is empty 635324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 636324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return NULL; // Caller must cope with this 637324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 638324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 639324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Traversed all the available elements already? 640324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 641324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream->cursor >= n) 642324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 643324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (n == 1) 644324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 645324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Special case when size is single element, it will just dup a lot 646324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 647324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream->toTree(stream, stream->singleElement); 648324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 649324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 650324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Out of elements and the size is not 1, so we cannot assume 651324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // that we just duplicate the entry n times (such as ID ent+ -> ^(ID ent)+) 652324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // This means we ran out of elements earlier than was expected. 653324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 654324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return NULL; // Caller must cope with this 655324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 656324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 657324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Elements available either for duping or just available 658324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 659324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream->singleElement != NULL) 660324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 661324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->cursor++; // Cursor advances even for single element as this tells us to dup() 662324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream->toTree(stream, stream->singleElement); 663324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 664324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 665324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // More than just a single element so we extract it from the 666324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // vector. 667324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 668324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver t = stream->toTree(stream, stream->elements->get(stream->elements, stream->cursor)); 669324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->cursor++; 670324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return t; 671324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 672324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 673324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#ifdef ANTLR3_WINDOWS 674324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#pragma warning(push) 675324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#pragma warning(disable : 4100) 676324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#endif 677324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// When constructing trees, sometimes we need to dup a token or AST 678324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// subtree. Dup'ing a token means just creating another AST node 679324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// around it. For trees, you must call the adaptor.dupTree(). 680324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 681324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void * 682324c4644fee44b9898524c09511bd33c3f12e2dfBen GruverdupTok (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * el) 683324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 684324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ANTLR3_FPRINTF(stderr, "dup() cannot be called on a token rewrite stream!!"); 685324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return NULL; 686324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 687324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#ifdef ANTLR3_WINDOWS 688324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#pragma warning(pop) 689324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#endif 690324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 691324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// When constructing trees, sometimes we need to dup a token or AST 692324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// subtree. Dup'ing a token means just creating another AST node 693324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// around it. For trees, you must call the adaptor.dupTree(). 694324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 695324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void * 696324c4644fee44b9898524c09511bd33c3f12e2dfBen GruverdupTree (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * element) 697324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 698324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream->adaptor->dupNode(stream->adaptor, (pANTLR3_BASE_TREE)element); 699324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 700324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 701324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#ifdef ANTLR3_WINDOWS 702324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#pragma warning(push) 703324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#pragma warning(disable : 4100) 704324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#endif 705324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// When constructing trees, sometimes we need to dup a token or AST 706324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// subtree. Dup'ing a token means just creating another AST node 707324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// around it. For trees, you must call the adaptor.dupTree(). 708324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 709324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void * 710324c4644fee44b9898524c09511bd33c3f12e2dfBen GruverdupTreeNode (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * element) 711324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 712324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ANTLR3_FPRINTF(stderr, "dup() cannot be called on a node rewrite stream!!!"); 713324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return NULL; 714324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 715324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 716324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 717324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// We don;t explicitly convert to a tree unless the call goes to 718324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// nextTree, which means rewrites are heterogeneous 719324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 720324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic pANTLR3_BASE_TREE 721324c4644fee44b9898524c09511bd33c3f12e2dfBen GruvertoTree (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * element) 722324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 723324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return (pANTLR3_BASE_TREE)element; 724324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 725324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#ifdef ANTLR3_WINDOWS 726324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#pragma warning(pop) 727324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#endif 728324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 729324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Ensure stream emits trees; tokens must be converted to AST nodes. 730324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// AST nodes can be passed through unmolested. 731324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 732324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#ifdef ANTLR3_WINDOWS 733324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#pragma warning(push) 734324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#pragma warning(disable : 4100) 735324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#endif 736324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 737324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic pANTLR3_BASE_TREE 738324c4644fee44b9898524c09511bd33c3f12e2dfBen GruvertoTreeNode (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream, void * element) 739324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 740324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream->adaptor->dupNode(stream->adaptor, (pANTLR3_BASE_TREE)element); 741324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 742324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 743324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#ifdef ANTLR3_WINDOWS 744324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#pragma warning(pop) 745324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver#endif 746324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 747324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Returns ANTLR3_TRUE if there is a next element available 748324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 749324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic ANTLR3_BOOLEAN 750324c4644fee44b9898524c09511bd33c3f12e2dfBen GruverhasNext (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) 751324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 752324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if ( (stream->singleElement != NULL && stream->cursor < 1) 753324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver || (stream->elements != NULL && stream->cursor < stream->elements->size(stream->elements))) 754324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 755324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return ANTLR3_TRUE; 756324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 757324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver else 758324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 759324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return ANTLR3_FALSE; 760324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 761324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 762324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 763324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Get the next token from the list and create a node for it 764324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// This is the implementation for token streams. 765324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 766324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic pANTLR3_BASE_TREE 767324c4644fee44b9898524c09511bd33c3f12e2dfBen GruvernextNodeToken(pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) 768324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 769324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream->adaptor->create(stream->adaptor, stream->_next(stream)); 770324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 771324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 772324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic pANTLR3_BASE_TREE 773324c4644fee44b9898524c09511bd33c3f12e2dfBen GruvernextNodeNode(pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) 774324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 775324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream->_next(stream); 776324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 777324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 778324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Treat next element as a single node even if it's a subtree. 779324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// This is used instead of next() when the result has to be a 780324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// tree root node. Also prevents us from duplicating recently-added 781324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// children; e.g., ^(type ID)+ adds ID to type and then 2nd iteration 782324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// must dup the type node, but ID has been added. 783324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 784324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Referencing to a rule result twice is ok; dup entire tree as 785324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// we can't be adding trees; e.g., expr expr. 786324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 787324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic pANTLR3_BASE_TREE 788324c4644fee44b9898524c09511bd33c3f12e2dfBen GruvernextNode (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) 789324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 790324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 791324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ANTLR3_UINT32 n; 792324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver pANTLR3_BASE_TREE el = stream->_next(stream); 793324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 794324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver n = stream->size(stream); 795324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream->dirty == ANTLR3_TRUE || (stream->cursor > n && n == 1)) 796324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 797324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // We are out of elements and the size is 1, which means we just 798324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // dup the node that we have 799324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 800324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream->adaptor->dupNode(stream->adaptor, el); 801324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 802324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 803324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // We were not out of nodes, so the one we received is the one to return 804324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // 805324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return el; 806324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 807324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 808324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Number of elements available in the stream 809324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 810324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic ANTLR3_UINT32 811324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruversize (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) 812324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 813324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ANTLR3_UINT32 n = 0; 814324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 815324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// Should be a count of one if singleElement is set. I copied this 816324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// logic from the java implementation, which I suspect is just guarding 817324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// against someone setting singleElement and forgetting to NULL it out 818324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /// 819324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream->singleElement != NULL) 820324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 821324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver n = 1; 822324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 823324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver else 824324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 825324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream->elements != NULL) 826324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 827324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return (ANTLR3_UINT32)(stream->elements->count); 828324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 829324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 830324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return n; 831324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 832324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 833324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// Returns the description string if there is one available (check for NULL). 834324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/// 835324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruverstatic void * 836324c4644fee44b9898524c09511bd33c3f12e2dfBen GruvergetDescription (pANTLR3_REWRITE_RULE_ELEMENT_STREAM stream) 837324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver{ 838324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stream->elementDescription == NULL) 839324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver { 840324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver stream->elementDescription = "<unknown source>"; 841324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 842324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 843324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stream->elementDescription; 844324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 845