| /** \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); |
| } |