Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
tree: ac1e62f221
Fetching contributors…

Cannot retrieve contributors at this time

956 lines (780 sloc) 25.41 kb
/// \file
/// Defines the implementation of the common node stream the default
/// tree node stream used by ANTLR.
///
#include <antlr3commontreenodestream.h>
#ifdef ANTLR3_WINDOWS
#pragma warning( disable : 4100 )
#endif
// COMMON TREE STREAM API
//
static void addNavigationNode (pANTLR3_COMMON_TREE_NODE_STREAM ctns, ANTLR3_UINT32 ttype);
static ANTLR3_BOOLEAN hasUniqueNavigationNodes (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
static pANTLR3_BASE_TREE newDownNode (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
static pANTLR3_BASE_TREE newUpNode (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
static void reset (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
static pANTLR3_STRING toNodesOnlyString (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
static void push (pANTLR3_COMMON_TREE_NODE_STREAM ctns, ANTLR3_INT32 index);
static ANTLR3_INT32 pop (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
//static ANTLR3_INT32 index (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
// TREE NODE STREAM API
//
static pANTLR3_BASE_TREE_ADAPTOR getTreeAdaptor (pANTLR3_TREE_NODE_STREAM tns);
static pANTLR3_BASE_TREE getTreeSource (pANTLR3_TREE_NODE_STREAM tns);
static pANTLR3_BASE_TREE _LT (pANTLR3_TREE_NODE_STREAM tns, ANTLR3_INT32 k);
static pANTLR3_BASE_TREE get (pANTLR3_TREE_NODE_STREAM tns, ANTLR3_INT32 k);
static void setUniqueNavigationNodes (pANTLR3_TREE_NODE_STREAM tns, ANTLR3_BOOLEAN uniqueNavigationNodes);
static pANTLR3_STRING toString (pANTLR3_TREE_NODE_STREAM tns);
static pANTLR3_STRING toStringSS (pANTLR3_TREE_NODE_STREAM tns, pANTLR3_BASE_TREE start, pANTLR3_BASE_TREE stop);
static void toStringWork (pANTLR3_TREE_NODE_STREAM tns, pANTLR3_BASE_TREE start, pANTLR3_BASE_TREE stop, pANTLR3_STRING buf);
static void replaceChildren (pANTLR3_TREE_NODE_STREAM tns, pANTLR3_BASE_TREE parent, ANTLR3_INT32 startChildIndex, ANTLR3_INT32 stopChildIndex, pANTLR3_BASE_TREE t);
// INT STREAM API
//
static void consume (pANTLR3_INT_STREAM is);
static ANTLR3_MARKER tindex (pANTLR3_INT_STREAM is);
static ANTLR3_UINT32 _LA (pANTLR3_INT_STREAM is, ANTLR3_INT32 i);
static ANTLR3_MARKER mark (pANTLR3_INT_STREAM is);
static void release (pANTLR3_INT_STREAM is, ANTLR3_MARKER marker);
static void rewindMark (pANTLR3_INT_STREAM is, ANTLR3_MARKER marker);
static void rewindLast (pANTLR3_INT_STREAM is);
static void seek (pANTLR3_INT_STREAM is, ANTLR3_MARKER index);
static ANTLR3_UINT32 size (pANTLR3_INT_STREAM is);
// Helper functions
//
static void fillBuffer (pANTLR3_COMMON_TREE_NODE_STREAM ctns, pANTLR3_BASE_TREE t);
static void fillBufferRoot (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
static ANTLR3_INT32 getNodeIndex (pANTLR3_COMMON_TREE_NODE_STREAM ctns, pANTLR3_BASE_TREE t);
// Constructors
//
static void antlr3TreeNodeStreamFree (pANTLR3_TREE_NODE_STREAM tns);
static void antlr3CommonTreeNodeStreamFree (pANTLR3_COMMON_TREE_NODE_STREAM ctns);
ANTLR3_API pANTLR3_TREE_NODE_STREAM
antlr3TreeNodeStreamNew()
{
pANTLR3_TREE_NODE_STREAM stream;
// Memory for the interface structure
//
stream = (pANTLR3_TREE_NODE_STREAM) ANTLR3_CALLOC(1, sizeof(ANTLR3_TREE_NODE_STREAM));
if (stream == NULL)
{
return NULL;
}
// Install basic API
//
stream->replaceChildren = replaceChildren;
stream->free = antlr3TreeNodeStreamFree;
return stream;
}
static void
antlr3TreeNodeStreamFree(pANTLR3_TREE_NODE_STREAM stream)
{
ANTLR3_FREE(stream);
}
ANTLR3_API pANTLR3_COMMON_TREE_NODE_STREAM
antlr3CommonTreeNodeStreamNewTree(pANTLR3_BASE_TREE tree, ANTLR3_UINT32 hint)
{
pANTLR3_COMMON_TREE_NODE_STREAM stream;
stream = antlr3CommonTreeNodeStreamNew(tree->strFactory, hint);
if (stream == NULL)
{
return NULL;
}
stream->root = tree;
return stream;
}
ANTLR3_API pANTLR3_COMMON_TREE_NODE_STREAM
antlr3CommonTreeNodeStreamNewStream(pANTLR3_COMMON_TREE_NODE_STREAM inStream)
{
pANTLR3_COMMON_TREE_NODE_STREAM stream;
// Memory for the interface structure
//
stream = (pANTLR3_COMMON_TREE_NODE_STREAM) ANTLR3_CALLOC(1, sizeof(ANTLR3_COMMON_TREE_NODE_STREAM));
if (stream == NULL)
{
return NULL;
}
// Copy in all the reusable parts of the originating stream and create new
// pieces where necessary.
//
// String factory for tree walker
//
stream->stringFactory = inStream->stringFactory;
// Create an adaptor for the common tree node stream
//
stream->adaptor = inStream->adaptor;
// Create space for the tree node stream interface
//
stream->tnstream = antlr3TreeNodeStreamNew();
if (stream->tnstream == NULL)
{
stream->free (stream);
return NULL;
}
// Create space for the INT_STREAM interface
//
stream->tnstream->istream = antlr3IntStreamNew();
if (stream->tnstream->istream == NULL)
{
stream->tnstream->free (stream->tnstream);
stream->free (stream);
return NULL;
}
// Install the common tree node stream API
//
stream->addNavigationNode = addNavigationNode;
stream->hasUniqueNavigationNodes = hasUniqueNavigationNodes;
stream->newDownNode = newDownNode;
stream->newUpNode = newUpNode;
stream->reset = reset;
stream->push = push;
stream->pop = pop;
stream->free = antlr3CommonTreeNodeStreamFree;
// Install the tree node stream API
//
stream->tnstream->getTreeAdaptor = getTreeAdaptor;
stream->tnstream->getTreeSource = getTreeSource;
stream->tnstream->_LT = _LT;
stream->tnstream->setUniqueNavigationNodes = setUniqueNavigationNodes;
stream->tnstream->toString = toString;
stream->tnstream->toStringSS = toStringSS;
stream->tnstream->toStringWork = toStringWork;
stream->tnstream->get = get;
// Install INT_STREAM interface
//
stream->tnstream->istream->consume = consume;
stream->tnstream->istream->index = tindex;
stream->tnstream->istream->_LA = _LA;
stream->tnstream->istream->mark = mark;
stream->tnstream->istream->release = release;
stream->tnstream->istream->rewind = rewindMark;
stream->tnstream->istream->rewindLast = rewindLast;
stream->tnstream->istream->seek = seek;
stream->tnstream->istream->size = size;
// Initialize data elements of INT stream
//
stream->tnstream->istream->type = ANTLR3_COMMONTREENODE;
stream->tnstream->istream->super = (stream->tnstream);
// Initialize data elements of TREE stream
//
stream->tnstream->ctns = stream;
// Initialize data elements of the COMMON TREE NODE stream
//
stream->super = NULL;
stream->uniqueNavigationNodes = ANTLR3_FALSE;
stream->markers = NULL;
stream->nodeStack = inStream->nodeStack;
// Create the node list map
//
stream->nodes = antlr3VectorNew(DEFAULT_INITIAL_BUFFER_SIZE);
stream->p = -1;
// Install the navigation nodes
//
// Install the navigation nodes
//
antlr3SetCTAPI(&(stream->UP));
antlr3SetCTAPI(&(stream->DOWN));
antlr3SetCTAPI(&(stream->EOF_NODE));
antlr3SetCTAPI(&(stream->INVALID_NODE));
stream->UP.token = inStream->UP.token;
stream->DOWN.token = inStream->DOWN.token;
stream->EOF_NODE.token = inStream->EOF_NODE.token;
stream->INVALID_NODE.token = inStream->INVALID_NODE.token;
// Reuse the root tree of the originating stream
//
stream->root = inStream->root;
// Signal that this is a rewriting stream so we don't
// free the originating tree. Anything that we rewrite or
// duplicate here will be done through the adaptor or
// the original tree factory.
//
stream->isRewriter = ANTLR3_TRUE;
return stream;
}
ANTLR3_API pANTLR3_COMMON_TREE_NODE_STREAM
antlr3CommonTreeNodeStreamNew(pANTLR3_STRING_FACTORY strFactory, ANTLR3_UINT32 hint)
{
pANTLR3_COMMON_TREE_NODE_STREAM stream;
pANTLR3_COMMON_TOKEN token;
// Memory for the interface structure
//
stream = (pANTLR3_COMMON_TREE_NODE_STREAM) ANTLR3_CALLOC(1, sizeof(ANTLR3_COMMON_TREE_NODE_STREAM));
if (stream == NULL)
{
return NULL;
}
// String factory for tree walker
//
stream->stringFactory = strFactory;
// Create an adaptor for the common tree node stream
//
stream->adaptor = ANTLR3_TREE_ADAPTORNew(strFactory);
if (stream->adaptor == NULL)
{
stream->free(stream);
return NULL;
}
// Create space for the tree node stream interface
//
stream->tnstream = antlr3TreeNodeStreamNew();
if (stream->tnstream == NULL)
{
stream->adaptor->free (stream->adaptor);
stream->free (stream);
return NULL;
}
// Create space for the INT_STREAM interface
//
stream->tnstream->istream = antlr3IntStreamNew();
if (stream->tnstream->istream == NULL)
{
stream->adaptor->free (stream->adaptor);
stream->tnstream->free (stream->tnstream);
stream->free (stream);
return NULL;
}
// Install the common tree node stream API
//
stream->addNavigationNode = addNavigationNode;
stream->hasUniqueNavigationNodes = hasUniqueNavigationNodes;
stream->newDownNode = newDownNode;
stream->newUpNode = newUpNode;
stream->reset = reset;
stream->push = push;
stream->pop = pop;
stream->free = antlr3CommonTreeNodeStreamFree;
// Install the tree node stream API
//
stream->tnstream->getTreeAdaptor = getTreeAdaptor;
stream->tnstream->getTreeSource = getTreeSource;
stream->tnstream->_LT = _LT;
stream->tnstream->setUniqueNavigationNodes = setUniqueNavigationNodes;
stream->tnstream->toString = toString;
stream->tnstream->toStringSS = toStringSS;
stream->tnstream->toStringWork = toStringWork;
stream->tnstream->get = get;
// Install INT_STREAM interface
//
stream->tnstream->istream->consume = consume;
stream->tnstream->istream->index = tindex;
stream->tnstream->istream->_LA = _LA;
stream->tnstream->istream->mark = mark;
stream->tnstream->istream->release = release;
stream->tnstream->istream->rewind = rewindMark;
stream->tnstream->istream->rewindLast = rewindLast;
stream->tnstream->istream->seek = seek;
stream->tnstream->istream->size = size;
// Initialize data elements of INT stream
//
stream->tnstream->istream->type = ANTLR3_COMMONTREENODE;
stream->tnstream->istream->super = (stream->tnstream);
// Initialize data elements of TREE stream
//
stream->tnstream->ctns = stream;
// Initialize data elements of the COMMON TREE NODE stream
//
stream->super = NULL;
stream->uniqueNavigationNodes = ANTLR3_FALSE;
stream->markers = NULL;
stream->nodeStack = antlr3StackNew(INITIAL_CALL_STACK_SIZE);
// Create the node list map
//
if (hint == 0)
{
hint = DEFAULT_INITIAL_BUFFER_SIZE;
}
stream->nodes = antlr3VectorNew(hint);
stream->p = -1;
// Install the navigation nodes
//
antlr3SetCTAPI(&(stream->UP));
antlr3SetCTAPI(&(stream->DOWN));
antlr3SetCTAPI(&(stream->EOF_NODE));
antlr3SetCTAPI(&(stream->INVALID_NODE));
token = antlr3CommonTokenNew(ANTLR3_TOKEN_UP);
token->text = stream->stringFactory->newPtr(stream->stringFactory, (pANTLR3_UINT8)"UP", 2);
stream->UP.token = token;
token = antlr3CommonTokenNew(ANTLR3_TOKEN_DOWN);
token->text = stream->stringFactory->newPtr(stream->stringFactory, (pANTLR3_UINT8)"DOWN", 2);
stream->DOWN.token = token;
token = antlr3CommonTokenNew(ANTLR3_TOKEN_EOF);
token->text = stream->stringFactory->newPtr(stream->stringFactory, (pANTLR3_UINT8)"EOF", 2);
stream->EOF_NODE.token = token;
token = antlr3CommonTokenNew(ANTLR3_TOKEN_INVALID);
token->text = stream->stringFactory->newPtr(stream->stringFactory, (pANTLR3_UINT8)"INVALID", 2);
stream->INVALID_NODE.token = token;
return stream;
}
/// Free up any resources that belong to this common tree node stream.
///
static void antlr3CommonTreeNodeStreamFree (pANTLR3_COMMON_TREE_NODE_STREAM ctns)
{
// If this is a rewrting stream, then certain resources
// belong to the originating node stream and we do not
// free them here.
//
if (ctns->isRewriter != ANTLR3_TRUE)
{
ctns->adaptor ->free (ctns->adaptor);
if (ctns->nodeStack != NULL)
{
ctns->nodeStack->free(ctns->nodeStack);
}
ANTLR3_FREE(ctns->INVALID_NODE.token);
ANTLR3_FREE(ctns->EOF_NODE.token);
ANTLR3_FREE(ctns->DOWN.token);
ANTLR3_FREE(ctns->UP.token);
}
if (ctns->nodes != NULL)
{
ctns->nodes ->free (ctns->nodes);
}
ctns->tnstream->istream ->free (ctns->tnstream->istream);
ctns->tnstream ->free (ctns->tnstream);
ANTLR3_FREE(ctns);
}
// ------------------------------------------------------------------------------
// Local helpers
//
/// Walk and fill the tree node buffer from the root tree
///
static void
fillBufferRoot(pANTLR3_COMMON_TREE_NODE_STREAM ctns)
{
// Call the generic buffer routine with the root as the
// argument
//
fillBuffer(ctns, ctns->root);
ctns->p = 0; // Indicate we are at buffer start
}
/// Walk tree with depth-first-search and fill nodes buffer.
/// Don't add in DOWN, UP nodes if the supplied tree is a list (t is isNilNode)
// such as the root tree is.
///
static void
fillBuffer(pANTLR3_COMMON_TREE_NODE_STREAM ctns, pANTLR3_BASE_TREE t)
{
ANTLR3_BOOLEAN nilNode;
ANTLR3_UINT32 nCount;
ANTLR3_UINT32 c;
nilNode = ctns->adaptor->isNilNode(ctns->adaptor, t);
// If the supplied node is not a nil (list) node then we
// add in the node itself to the vector
//
if (nilNode == ANTLR3_FALSE)
{
ctns->nodes->add(ctns->nodes, t, NULL);
}
// Only add a DOWN node if the tree is not a nil tree and
// the tree does have children.
//
nCount = t->getChildCount(t);
if (nilNode == ANTLR3_FALSE && nCount>0)
{
ctns->addNavigationNode(ctns, ANTLR3_TOKEN_DOWN);
}
// We always add any children the tree contains, which is
// a recursive call to this function, which will cause similar
// recursion and implement a depth first addition
//
for (c = 0; c < nCount; c++)
{
fillBuffer(ctns, ctns->adaptor->getChild(ctns->adaptor, t, c));
}
// If the tree had children and was not a nil (list) node, then we
// we need to add an UP node here to match the DOWN node
//
if (nilNode == ANTLR3_FALSE && nCount > 0)
{
ctns->addNavigationNode(ctns, ANTLR3_TOKEN_UP);
}
}
/// Determine the stream index for a particular node.
/// NB: This uses internal knowledge of the Antlr3 Vector for the
/// sake of efficiency. Don't do this in application code.
/// This is just an internal debugging type interface so does not need to be improved.
///
static ANTLR3_INT32
getNodeIndex(pANTLR3_COMMON_TREE_NODE_STREAM ctns, pANTLR3_BASE_TREE t)
{
ANTLR3_UINT32 i;
ANTLR3_UINT32 j;
pANTLR3_VECTOR_ELEMENT elements;
if (ctns->p == -1)
{
fillBufferRoot(ctns);
}
j = ctns->nodes->count;
elements = ctns->nodes->elements;
for (i = 0; i < j; i++)
{
if (t == elements[i].element)
{
return i;
}
}
return -1;
}
// ------------------------------------------------------------------------------
// Interface functions
//
/// Reset the input stream to the start of the input nodes.
///
static void
reset (pANTLR3_COMMON_TREE_NODE_STREAM ctns)
{
ctns->p = -1;
ctns->tnstream->istream->lastMarker = 0;
// Free and reset the node stack only if this is not
// a rewriter, which is going to reuse the originating
// node streams node stack
//
if (ctns->isRewriter != ANTLR3_TRUE)
{
if (ctns->nodeStack != NULL)
{
ctns->nodeStack->free(ctns->nodeStack);
ctns->nodeStack = antlr3StackNew(INITIAL_CALL_STACK_SIZE);
}
}
}
static pANTLR3_BASE_TREE
LB(pANTLR3_TREE_NODE_STREAM tns, ANTLR3_INT32 k)
{
if ( k==0)
{
return &(tns->ctns->INVALID_NODE.baseTree);
}
if ( (tns->ctns->p - k) < 0)
{
return &(tns->ctns->INVALID_NODE.baseTree);
}
return tns->ctns->nodes->get(tns->ctns->nodes, tns->ctns->p - k);
}
/// Get tree node at current input pointer + i ahead where i=1 is next node.
/// i<0 indicates nodes in the past. So -1 is previous node and -2 is
/// two nodes ago. LT(0) is undefined. For i>=n, return null.
/// Return null for LT(0) and any index that results in an absolute address
/// that is negative.
///
/// This is analogous to the _LT() method of the TokenStream, but this
/// returns a tree node instead of a token. Makes code gen identical
/// for both parser and tree grammars. :)
///
static pANTLR3_BASE_TREE
_LT (pANTLR3_TREE_NODE_STREAM tns, ANTLR3_INT32 k)
{
if (tns->ctns->p == -1)
{
fillBufferRoot(tns->ctns);
}
if (k < 0)
{
return LB(tns, -k);
}
else if (k == 0)
{
return &(tns->ctns->INVALID_NODE.baseTree);
}
// k was a legitimate request,
//
if (( tns->ctns->p + k - 1) >= (ANTLR3_INT32)(tns->ctns->nodes->count))
{
return &(tns->ctns->EOF_NODE.baseTree);
}
return tns->ctns->nodes->get(tns->ctns->nodes, tns->ctns->p + k - 1);
}
/// Where is this stream pulling nodes from? This is not the name, but
/// the object that provides node objects.
///
static pANTLR3_BASE_TREE
getTreeSource (pANTLR3_TREE_NODE_STREAM tns)
{
return tns->ctns->root;
}
/// Consume the next node from the input stream
///
static void
consume (pANTLR3_INT_STREAM is)
{
pANTLR3_TREE_NODE_STREAM tns;
pANTLR3_COMMON_TREE_NODE_STREAM ctns;
tns = (pANTLR3_TREE_NODE_STREAM)(is->super);
ctns = tns->ctns;
if (ctns->p == -1)
{
fillBufferRoot(ctns);
}
ctns->p++;
}
static ANTLR3_UINT32
_LA (pANTLR3_INT_STREAM is, ANTLR3_INT32 i)
{
pANTLR3_TREE_NODE_STREAM tns;
pANTLR3_BASE_TREE t;
tns = (pANTLR3_TREE_NODE_STREAM)(is->super);
// Ask LT for the 'token' at that position
//
t = tns->_LT(tns, i);
if (t == NULL)
{
return ANTLR3_TOKEN_INVALID;
}
// Token node was there so return the type of it
//
return t->getType(t);
}
/// Mark the state of the input stream so that we can come back to it
/// after a syntactic predicate and so on.
///
static ANTLR3_MARKER
mark (pANTLR3_INT_STREAM is)
{
pANTLR3_TREE_NODE_STREAM tns;
pANTLR3_COMMON_TREE_NODE_STREAM ctns;
tns = (pANTLR3_TREE_NODE_STREAM)(is->super);
ctns = tns->ctns;
if (tns->ctns->p == -1)
{
fillBufferRoot(tns->ctns);
}
// Return the current mark point
//
ctns->tnstream->istream->lastMarker = ctns->tnstream->istream->index(ctns->tnstream->istream);
return ctns->tnstream->istream->lastMarker;
}
static void
release (pANTLR3_INT_STREAM is, ANTLR3_MARKER marker)
{
}
/// Rewind the current state of the tree walk to the state it
/// was in when mark() was called and it returned marker. Also,
/// wipe out the lookahead which will force reloading a few nodes
/// but it is better than making a copy of the lookahead buffer
/// upon mark().
///
static void
rewindMark (pANTLR3_INT_STREAM is, ANTLR3_MARKER marker)
{
is->seek(is, marker);
}
static void
rewindLast (pANTLR3_INT_STREAM is)
{
is->seek(is, is->lastMarker);
}
/// consume() ahead until we hit index. Can't just jump ahead--must
/// spit out the navigation nodes.
///
static void
seek (pANTLR3_INT_STREAM is, ANTLR3_MARKER index)
{
pANTLR3_TREE_NODE_STREAM tns;
pANTLR3_COMMON_TREE_NODE_STREAM ctns;
tns = (pANTLR3_TREE_NODE_STREAM)(is->super);
ctns = tns->ctns;
ctns->p = ANTLR3_UINT32_CAST(index);
}
static ANTLR3_MARKER
tindex (pANTLR3_INT_STREAM is)
{
pANTLR3_TREE_NODE_STREAM tns;
pANTLR3_COMMON_TREE_NODE_STREAM ctns;
tns = (pANTLR3_TREE_NODE_STREAM)(is->super);
ctns = tns->ctns;
return (ANTLR3_MARKER)(ctns->p);
}
/// Expensive to compute the size of the whole tree while parsing.
/// This method only returns how much input has been seen so far. So
/// after parsing it returns true size.
///
static ANTLR3_UINT32
size (pANTLR3_INT_STREAM is)
{
pANTLR3_TREE_NODE_STREAM tns;
pANTLR3_COMMON_TREE_NODE_STREAM ctns;
tns = (pANTLR3_TREE_NODE_STREAM)(is->super);
ctns = tns->ctns;
if (ctns->p == -1)
{
fillBufferRoot(ctns);
}
return ctns->nodes->size(ctns->nodes);
}
/// As we flatten the tree, we use UP, DOWN nodes to represent
/// the tree structure. When debugging we need unique nodes
/// so instantiate new ones when uniqueNavigationNodes is true.
///
static void
addNavigationNode (pANTLR3_COMMON_TREE_NODE_STREAM ctns, ANTLR3_UINT32 ttype)
{
pANTLR3_BASE_TREE node;
node = NULL;
if (ttype == ANTLR3_TOKEN_DOWN)
{
if (ctns->hasUniqueNavigationNodes(ctns) == ANTLR3_TRUE)
{
node = ctns->newDownNode(ctns);
}
else
{
node = &(ctns->DOWN.baseTree);
}
}
else
{
if (ctns->hasUniqueNavigationNodes(ctns) == ANTLR3_TRUE)
{
node = ctns->newUpNode(ctns);
}
else
{
node = &(ctns->UP.baseTree);
}
}
// Now add the node we decided upon.
//
ctns->nodes->add(ctns->nodes, node, NULL);
}
static pANTLR3_BASE_TREE_ADAPTOR
getTreeAdaptor (pANTLR3_TREE_NODE_STREAM tns)
{
return tns->ctns->adaptor;
}
static ANTLR3_BOOLEAN
hasUniqueNavigationNodes (pANTLR3_COMMON_TREE_NODE_STREAM ctns)
{
return ctns->uniqueNavigationNodes;
}
static void
setUniqueNavigationNodes (pANTLR3_TREE_NODE_STREAM tns, ANTLR3_BOOLEAN uniqueNavigationNodes)
{
tns->ctns->uniqueNavigationNodes = uniqueNavigationNodes;
}
/// Print out the entire tree including DOWN/UP nodes. Uses
/// a recursive walk. Mostly useful for testing as it yields
/// the token types not text.
///
static pANTLR3_STRING
toString (pANTLR3_TREE_NODE_STREAM tns)
{
return tns->toStringSS(tns, tns->ctns->root, NULL);
}
static pANTLR3_STRING
toStringSS (pANTLR3_TREE_NODE_STREAM tns, pANTLR3_BASE_TREE start, pANTLR3_BASE_TREE stop)
{
pANTLR3_STRING buf;
buf = tns->ctns->stringFactory->newRaw(tns->ctns->stringFactory);
tns->toStringWork(tns, start, stop, buf);
return buf;
}
static void
toStringWork (pANTLR3_TREE_NODE_STREAM tns, pANTLR3_BASE_TREE p, pANTLR3_BASE_TREE stop, pANTLR3_STRING buf)
{
ANTLR3_UINT32 n;
ANTLR3_UINT32 c;
if (!p->isNilNode(p) )
{
pANTLR3_STRING text;
text = p->toString(p);
if (text == NULL)
{
text = tns->ctns->stringFactory->newRaw(tns->ctns->stringFactory);
text->addc (text, ' ');
text->addi (text, p->getType(p));
}
buf->appendS(buf, text);
}
if (p == stop)
{
return; /* Finished */
}
n = p->getChildCount(p);
if (n > 0 && ! p->isNilNode(p) )
{
buf->addc (buf, ' ');
buf->addi (buf, ANTLR3_TOKEN_DOWN);
}
for (c = 0; c<n ; c++)
{
pANTLR3_BASE_TREE child;
child = p->getChild(p, c);
tns->toStringWork(tns, child, stop, buf);
}
if (n > 0 && ! p->isNilNode(p) )
{
buf->addc (buf, ' ');
buf->addi (buf, ANTLR3_TOKEN_UP);
}
}
static ANTLR3_UINT32
getLookaheadSize (pANTLR3_COMMON_TREE_NODE_STREAM ctns)
{
return ctns->tail < ctns->head
? (ctns->lookAheadLength - ctns->head + ctns->tail)
: (ctns->tail - ctns->head);
}
static pANTLR3_BASE_TREE
newDownNode (pANTLR3_COMMON_TREE_NODE_STREAM ctns)
{
pANTLR3_COMMON_TREE dNode;
pANTLR3_COMMON_TOKEN token;
token = antlr3CommonTokenNew(ANTLR3_TOKEN_DOWN);
token->text = ctns->stringFactory->newPtr(ctns->stringFactory, (pANTLR3_UINT8)"DOWN", 4);
dNode = antlr3CommonTreeNewFromToken(token);
return &(dNode->baseTree);
}
static pANTLR3_BASE_TREE
newUpNode (pANTLR3_COMMON_TREE_NODE_STREAM ctns)
{
pANTLR3_COMMON_TREE uNode;
pANTLR3_COMMON_TOKEN token;
token = antlr3CommonTokenNew(ANTLR3_TOKEN_UP);
token->text = ctns->stringFactory->newPtr(ctns->stringFactory, (pANTLR3_UINT8)"UP", 2);
uNode = antlr3CommonTreeNewFromToken(token);
return &(uNode->baseTree);
}
/// Replace from start to stop child index of parent with t, which might
/// be a list. Number of children may be different
/// after this call. The stream is notified because it is walking the
/// tree and might need to know you are monkey-ing with the underlying
/// tree. Also, it might be able to modify the node stream to avoid
/// re-streaming for future phases.
///
/// If parent is null, don't do anything; must be at root of overall tree.
/// Can't replace whatever points to the parent externally. Do nothing.
///
static void
replaceChildren (pANTLR3_TREE_NODE_STREAM tns, pANTLR3_BASE_TREE parent, ANTLR3_INT32 startChildIndex, ANTLR3_INT32 stopChildIndex, pANTLR3_BASE_TREE t)
{
if (parent != NULL)
{
pANTLR3_BASE_TREE_ADAPTOR adaptor;
pANTLR3_COMMON_TREE_ADAPTOR cta;
adaptor = tns->getTreeAdaptor(tns);
cta = (pANTLR3_COMMON_TREE_ADAPTOR)(adaptor->super);
adaptor->replaceChildren(adaptor, parent, startChildIndex, stopChildIndex, t);
}
}
static pANTLR3_BASE_TREE
get (pANTLR3_TREE_NODE_STREAM tns, ANTLR3_INT32 k)
{
if (tns->ctns->p == -1)
{
fillBufferRoot(tns->ctns);
}
return tns->ctns->nodes->get(tns->ctns->nodes, k);
}
static void
push (pANTLR3_COMMON_TREE_NODE_STREAM ctns, ANTLR3_INT32 index)
{
ctns->nodeStack->push(ctns->nodeStack, ANTLR3_FUNC_PTR(ctns->p), NULL); // Save current index
ctns->tnstream->istream->seek(ctns->tnstream->istream, index);
}
static ANTLR3_INT32
pop (pANTLR3_COMMON_TREE_NODE_STREAM ctns)
{
ANTLR3_INT32 retVal;
retVal = ANTLR3_UINT32_CAST(ctns->nodeStack->pop(ctns->nodeStack));
ctns->tnstream->istream->seek(ctns->tnstream->istream, retVal);
return retVal;
}
Jump to Line
Something went wrong with that request. Please try again.