X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.databoard%2Fcpp%2FDataBoardTest%2Flibantlr3c-3.2%2Fsrc%2Fantlr3commontreeadaptor.c;fp=bundles%2Forg.simantics.databoard%2Fcpp%2FDataBoardTest%2Flibantlr3c-3.2%2Fsrc%2Fantlr3commontreeadaptor.c;h=4ac0782404c8190ba18c72fa87fb46f18520869d;hb=969bd23cab98a79ca9101af33334000879fb60c5;hp=0000000000000000000000000000000000000000;hpb=866dba5cd5a3929bbeae85991796acb212338a08;p=simantics%2Fplatform.git diff --git a/bundles/org.simantics.databoard/cpp/DataBoardTest/libantlr3c-3.2/src/antlr3commontreeadaptor.c b/bundles/org.simantics.databoard/cpp/DataBoardTest/libantlr3c-3.2/src/antlr3commontreeadaptor.c new file mode 100644 index 000000000..4ac078240 --- /dev/null +++ b/bundles/org.simantics.databoard/cpp/DataBoardTest/libantlr3c-3.2/src/antlr3commontreeadaptor.c @@ -0,0 +1,496 @@ +/** \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 + +#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); +}