/** \file
* This is the standard tree adaptor used by the C runtime unless the grammar
* source file says to use anything different. It embeds a BASE_TREE to which
* it adds its own implementation of anything that the base tree is not
* good for, plus a number of methods that any other adaptor type
* needs to implement too.
* \ingroup pANTLR3_COMMON_TREE_ADAPTOR
*/
// [The "BSD licence"]
// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
// http://www.temporal-wave.com
// http://www.linkedin.com/in/jimidle
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// 3. The name of the author may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <antlr3commontreeadaptor.h>
#ifdef ANTLR3_WINDOWS
#pragma warning( disable : 4100 )
#endif
/* BASE_TREE_ADAPTOR overrides... */
static pANTLR3_BASE_TREE dupNode (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE treeNode);
static pANTLR3_BASE_TREE create (pANTLR3_BASE_TREE_ADAPTOR adpator, pANTLR3_COMMON_TOKEN payload);
static pANTLR3_BASE_TREE dbgCreate (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_COMMON_TOKEN payload);
static pANTLR3_COMMON_TOKEN createToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_UINT8 text);
static pANTLR3_COMMON_TOKEN createTokenFromToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_COMMON_TOKEN fromToken);
static pANTLR3_COMMON_TOKEN getToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t);
static pANTLR3_STRING getText (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t);
static ANTLR3_UINT32 getType (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t);
static pANTLR3_BASE_TREE getChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 i);
static ANTLR3_UINT32 getChildCount (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t);
static void replaceChildren (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE parent, ANTLR3_INT32 startChildIndex, ANTLR3_INT32 stopChildIndex, pANTLR3_BASE_TREE t);
static void setDebugEventListener (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_DEBUG_EVENT_LISTENER debugger);
static void setChildIndex (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_INT32 i);
static ANTLR3_INT32 getChildIndex (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t);
static void setParent (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE child, pANTLR3_BASE_TREE parent);
static pANTLR3_BASE_TREE getParent (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE child);
static void setChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 i, pANTLR3_BASE_TREE child);
static void deleteChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 i);
static pANTLR3_BASE_TREE errorNode (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_TOKEN_STREAM ctnstream, pANTLR3_COMMON_TOKEN startToken, pANTLR3_COMMON_TOKEN stopToken, pANTLR3_EXCEPTION e);
/* Methods specific to each tree adaptor
*/
static void setTokenBoundaries (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN startToken, pANTLR3_COMMON_TOKEN stopToken);
static void dbgSetTokenBoundaries (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN startToken, pANTLR3_COMMON_TOKEN stopToken);
static ANTLR3_MARKER getTokenStartIndex (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t);
static ANTLR3_MARKER getTokenStopIndex (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t);
static void ctaFree (pANTLR3_BASE_TREE_ADAPTOR adaptor);
/** Create a new tree adaptor. Note that despite the fact that this is
* creating a new COMMON_TREE adaptor, we return the address of the
* BASE_TREE interface, as should any other adaptor that wishes to be
* used as the tree element of a tree parse/build. It needs to be given the
* address of a valid string factory as we do not know what the originating
* input stream encoding type was. This way we can rely on just using
* the original input stream's string factory or one of the correct type
* which the user supplies us.
*/
ANTLR3_API pANTLR3_BASE_TREE_ADAPTOR
ANTLR3_TREE_ADAPTORNew(pANTLR3_STRING_FACTORY strFactory)
{
pANTLR3_COMMON_TREE_ADAPTOR cta;
// First job is to create the memory we need for the tree adaptor interface.
//
cta = (pANTLR3_COMMON_TREE_ADAPTOR) ANTLR3_MALLOC((size_t)(sizeof(ANTLR3_COMMON_TREE_ADAPTOR)));
if (cta == NULL)
{
return NULL;
}
// Memory is initialized, so initialize the base tree adaptor
//
antlr3BaseTreeAdaptorInit(&(cta->baseAdaptor), NULL);
// Install our interface overrides. Strangeness is to allow generated code to treat them
// as returning void *
//
cta->baseAdaptor.dupNode = (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))
dupNode;
cta->baseAdaptor.create = (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, pANTLR3_COMMON_TOKEN))
create;
cta->baseAdaptor.createToken =
createToken;
cta->baseAdaptor.createTokenFromToken =
createTokenFromToken;
cta->baseAdaptor.setTokenBoundaries = (void (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, pANTLR3_COMMON_TOKEN, pANTLR3_COMMON_TOKEN))
setTokenBoundaries;
cta->baseAdaptor.getTokenStartIndex = (ANTLR3_MARKER (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))
getTokenStartIndex;
cta->baseAdaptor.getTokenStopIndex = (ANTLR3_MARKER (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))
getTokenStopIndex;
cta->baseAdaptor.getText = (pANTLR3_STRING (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))
getText;
cta->baseAdaptor.getType = (ANTLR3_UINT32 (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))
getType;
cta->baseAdaptor.getChild = (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_UINT32))
getChild;
cta->baseAdaptor.setChild = (void (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_UINT32, void *))
setChild;
cta->baseAdaptor.setParent = (void (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, void *))
setParent;
cta->baseAdaptor.getParent = (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))
getParent;
cta->baseAdaptor.setChildIndex = (void (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_UINT32))
setChildIndex;
cta->baseAdaptor.deleteChild = (void (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_UINT32))
deleteChild;
cta->baseAdaptor.getChildCount = (ANTLR3_UINT32 (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))
getChildCount;
cta->baseAdaptor.getChildIndex = (ANTLR3_INT32 (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))
getChildIndex;
cta->baseAdaptor.free = (void (*) (pANTLR3_BASE_TREE_ADAPTOR))
ctaFree;
cta->baseAdaptor.setDebugEventListener =
setDebugEventListener;
cta->baseAdaptor.replaceChildren = (void (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_INT32, ANTLR3_INT32, void *))
replaceChildren;
cta->baseAdaptor.errorNode = (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, pANTLR3_TOKEN_STREAM, pANTLR3_COMMON_TOKEN, pANTLR3_COMMON_TOKEN, pANTLR3_EXCEPTION))
errorNode;
// Install the super class pointer
//
cta->baseAdaptor.super = cta;
// Install a tree factory for creating new tree nodes
//
cta->arboretum = antlr3ArboretumNew(strFactory);
// Install a token factory for imaginary tokens, these imaginary
// tokens do not require access to the input stream so we can
// dummy the creation of it, but they will need a string factory.
//
cta->baseAdaptor.tokenFactory = antlr3TokenFactoryNew(NULL);
cta->baseAdaptor.tokenFactory->unTruc.strFactory = strFactory;
// Allow the base tree adaptor to share the tree factory's string factory.
//
cta->baseAdaptor.strFactory = strFactory;
// Return the address of the base adaptor interface.
//
return &(cta->baseAdaptor);
}
/// Debugging version of the tree adaptor (not normally called as generated code
/// calls setDebugEventListener instead which changes a normal token stream to
/// a debugging stream and means that a user's instantiation code does not need
/// to be changed just to debug with AW.
///
ANTLR3_API pANTLR3_BASE_TREE_ADAPTOR
ANTLR3_TREE_ADAPTORDebugNew(pANTLR3_STRING_FACTORY strFactory, pANTLR3_DEBUG_EVENT_LISTENER debugger)
{
pANTLR3_BASE_TREE_ADAPTOR ta;
// Create a normal one first
//
ta = ANTLR3_TREE_ADAPTORNew(strFactory);
if (ta != NULL)
{
// Reinitialize as a debug version
//
antlr3BaseTreeAdaptorInit(ta, debugger);
ta->create = (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, pANTLR3_COMMON_TOKEN))
dbgCreate;
ta->setTokenBoundaries = (void (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, pANTLR3_COMMON_TOKEN, pANTLR3_COMMON_TOKEN))
dbgSetTokenBoundaries;
}
return ta;
}
/// Causes an existing common tree adaptor to become a debug version
///
static void
setDebugEventListener (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_DEBUG_EVENT_LISTENER debugger)
{
// Reinitialize as a debug version
//
antlr3BaseTreeAdaptorInit(adaptor, debugger);
adaptor->create = (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, pANTLR3_COMMON_TOKEN))
dbgCreate;
adaptor->setTokenBoundaries = (void (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, pANTLR3_COMMON_TOKEN, pANTLR3_COMMON_TOKEN))
dbgSetTokenBoundaries;
}
static void
ctaFree(pANTLR3_BASE_TREE_ADAPTOR adaptor)
{
pANTLR3_COMMON_TREE_ADAPTOR cta;
cta = (pANTLR3_COMMON_TREE_ADAPTOR)(adaptor->super);
/* Free the tree factory we created
*/
cta->arboretum->close(((pANTLR3_COMMON_TREE_ADAPTOR)(adaptor->super))->arboretum);
/* Free the token factory we created
*/
adaptor->tokenFactory->close(adaptor->tokenFactory);
/* Free the super pointer, as it is this that was allocated
* and is the common tree structure.
*/
ANTLR3_FREE(adaptor->super);
}
/* BASE_TREE_ADAPTOR overrides */
static pANTLR3_BASE_TREE
errorNode (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_TOKEN_STREAM ctnstream, pANTLR3_COMMON_TOKEN startToken, pANTLR3_COMMON_TOKEN stopToken, pANTLR3_EXCEPTION e)
{
// Use the supplied common tree node stream to get another tree from the factory
// TODO: Look at creating the erronode as in Java, but this is complicated by the
// need to track and free the memory allocated to it, so for now, we just
// want something in the tree that isn't a NULL pointer.
//
return adaptor->createTypeText(adaptor, ANTLR3_TOKEN_INVALID, (pANTLR3_UINT8)"Tree Error Node");
}
/** Duplicate the supplied node.
*/
static pANTLR3_BASE_TREE
dupNode (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE treeNode)
{
return treeNode == NULL ? NULL : treeNode->dupNode(treeNode);
}
static pANTLR3_BASE_TREE
create (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_COMMON_TOKEN payload)
{
pANTLR3_BASE_TREE ct;
/* Create a new common tree as this is what this adaptor deals with
*/
ct = ((pANTLR3_COMMON_TREE_ADAPTOR)(adaptor->super))->arboretum->newFromToken(((pANTLR3_COMMON_TREE_ADAPTOR)(adaptor->super))->arboretum, payload);
/* But all adaptors return the pointer to the base interface.
*/
return ct;
}
static pANTLR3_BASE_TREE
dbgCreate (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_COMMON_TOKEN payload)
{
pANTLR3_BASE_TREE ct;
ct = create(adaptor, payload);
adaptor->debugger->createNode(adaptor->debugger, ct);
return ct;
}
/** Tell me how to create a token for use with imaginary token nodes.
* For example, there is probably no input symbol associated with imaginary
* token DECL, but you need to create it as a payload or whatever for
* the DECL node as in ^(DECL type ID).
*
* If you care what the token payload objects' type is, you should
* override this method and any other createToken variant.
*/
static pANTLR3_COMMON_TOKEN
createToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_UINT8 text)
{
pANTLR3_COMMON_TOKEN newToken;
newToken = adaptor->tokenFactory->newToken(adaptor->tokenFactory);
if (newToken != NULL)
{
newToken->textState = ANTLR3_TEXT_CHARP;
newToken->tokText.chars = (pANTLR3_UCHAR)text;
newToken->setType(newToken, tokenType);
newToken->input = adaptor->tokenFactory->input;
newToken->strFactory = adaptor->strFactory;
}
return newToken;
}
/** Tell me how to create a token for use with imaginary token nodes.
* For example, there is probably no input symbol associated with imaginary
* token DECL, but you need to create it as a payload or whatever for
* the DECL node as in ^(DECL type ID).
*
* This is a variant of createToken where the new token is derived from
* an actual real input token. Typically this is for converting '{'
* tokens to BLOCK etc... You'll see
*
* r : lc='{' ID+ '}' -> ^(BLOCK[$lc] ID+) ;
*
* If you care what the token payload objects' type is, you should
* override this method and any other createToken variant.
*
* NB: this being C it is not so easy to extend the types of creaeteToken.
* We will have to see if anyone needs to do this and add any variants to
* this interface.
*/
static pANTLR3_COMMON_TOKEN
createTokenFromToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_COMMON_TOKEN fromToken)
{
pANTLR3_COMMON_TOKEN newToken;
newToken = adaptor->tokenFactory->newToken(adaptor->tokenFactory);
if (newToken != NULL)
{
// Create the text using our own string factory to avoid complicating
// commontoken.
//
pANTLR3_STRING text;
newToken->toString = fromToken->toString;
if (fromToken->textState == ANTLR3_TEXT_CHARP)
{
newToken->textState = ANTLR3_TEXT_CHARP;
newToken->tokText.chars = fromToken->tokText.chars;
}
else
{
text = fromToken->getText(fromToken);
newToken->textState = ANTLR3_TEXT_STRING;
newToken->tokText.text = adaptor->strFactory->newPtr(adaptor->strFactory, text->chars, text->len);
}
newToken->setLine (newToken, fromToken->getLine(fromToken));
newToken->setTokenIndex (newToken, fromToken->getTokenIndex(fromToken));
newToken->setCharPositionInLine (newToken, fromToken->getCharPositionInLine(fromToken));
newToken->setChannel (newToken, fromToken->getChannel(fromToken));
newToken->setType (newToken, fromToken->getType(fromToken));
}
return newToken;
}
/* Specific methods for a TreeAdaptor */
/** Track start/stop token for subtree root created for a rule.
* Only works with CommonTree nodes. For rules that match nothing,
* seems like this will yield start=i and stop=i-1 in a nil node.
* Might be useful info so I'll not force to be i..i.
*/
static void
setTokenBoundaries (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN startToken, pANTLR3_COMMON_TOKEN stopToken)
{
ANTLR3_MARKER start;
ANTLR3_MARKER stop;
pANTLR3_COMMON_TREE ct;
if (t == NULL)
{
return;
}
if ( startToken != NULL)
{
start = startToken->getTokenIndex(startToken);
}
else
{
start = 0;
}
if ( stopToken != NULL)
{
stop = stopToken->getTokenIndex(stopToken);
}
else
{
stop = 0;
}
ct = (pANTLR3_COMMON_TREE)(t->super);
ct->startIndex = start;
ct->stopIndex = stop;
}
static void
dbgSetTokenBoundaries (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN startToken, pANTLR3_COMMON_TOKEN stopToken)
{
setTokenBoundaries(adaptor, t, startToken, stopToken);
if (t != NULL && startToken != NULL && stopToken != NULL)
{
adaptor->debugger->setTokenBoundaries(adaptor->debugger, t, startToken->getTokenIndex(startToken), stopToken->getTokenIndex(stopToken));
}
}
static ANTLR3_MARKER
getTokenStartIndex (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)
{
return ((pANTLR3_COMMON_TREE)(t->super))->startIndex;
}
static ANTLR3_MARKER
getTokenStopIndex (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)
{
return ((pANTLR3_COMMON_TREE)(t->super))->stopIndex;
}
static pANTLR3_STRING
getText (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)
{
return t->getText(t);
}
static ANTLR3_UINT32
getType (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)
{
return t->getType(t);
}
static void
replaceChildren
(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE parent, ANTLR3_INT32 startChildIndex, ANTLR3_INT32 stopChildIndex, pANTLR3_BASE_TREE t)
{
if (parent != NULL)
{
parent->replaceChildren(parent, startChildIndex, stopChildIndex, t);
}
}
static pANTLR3_BASE_TREE
getChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 i)
{
return t->getChild(t, i);
}
static void
setChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 i, pANTLR3_BASE_TREE child)
{
t->setChild(t, i, child);
}
static void
deleteChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 i)
{
t->deleteChild(t, i);
}
static ANTLR3_UINT32
getChildCount (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)
{
return t->getChildCount(t);
}
static void
setChildIndex (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_INT32 i)
{
t->setChildIndex(t, i);
}
static ANTLR3_INT32
getChildIndex (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)
{
return t->getChildIndex(t);
}
static void
setParent (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE child, pANTLR3_BASE_TREE parent)
{
child->setParent(child, parent);
}
static pANTLR3_BASE_TREE
getParent (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE child)
{
return child->getParent(child);
}