2 * This is the standard tree adaptor used by the C runtime unless the grammar
\r
3 * source file says to use anything different. It embeds a BASE_TREE to which
\r
4 * it adds its own implementation of anything that the base tree is not
\r
5 * good for, plus a number of methods that any other adaptor type
\r
6 * needs to implement too.
\r
7 * \ingroup pANTLR3_COMMON_TREE_ADAPTOR
\r
10 // [The "BSD licence"]
\r
11 // Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC
\r
12 // http://www.temporal-wave.com
\r
13 // http://www.linkedin.com/in/jimidle
\r
15 // All rights reserved.
\r
17 // Redistribution and use in source and binary forms, with or without
\r
18 // modification, are permitted provided that the following conditions
\r
20 // 1. Redistributions of source code must retain the above copyright
\r
21 // notice, this list of conditions and the following disclaimer.
\r
22 // 2. Redistributions in binary form must reproduce the above copyright
\r
23 // notice, this list of conditions and the following disclaimer in the
\r
24 // documentation and/or other materials provided with the distribution.
\r
25 // 3. The name of the author may not be used to endorse or promote products
\r
26 // derived from this software without specific prior written permission.
\r
28 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
\r
29 // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
\r
30 // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
\r
31 // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
\r
32 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
\r
33 // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
\r
34 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
\r
35 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
\r
36 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
\r
37 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\r
39 #include <antlr3commontreeadaptor.h>
\r
41 #ifdef ANTLR3_WINDOWS
\r
42 #pragma warning( disable : 4100 )
\r
45 /* BASE_TREE_ADAPTOR overrides... */
\r
46 static pANTLR3_BASE_TREE dupNode (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE treeNode);
\r
47 static pANTLR3_BASE_TREE create (pANTLR3_BASE_TREE_ADAPTOR adpator, pANTLR3_COMMON_TOKEN payload);
\r
48 static pANTLR3_BASE_TREE dbgCreate (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_COMMON_TOKEN payload);
\r
49 static pANTLR3_COMMON_TOKEN createToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_UINT8 text);
\r
50 static pANTLR3_COMMON_TOKEN createTokenFromToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_COMMON_TOKEN fromToken);
\r
51 static pANTLR3_COMMON_TOKEN getToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t);
\r
52 static pANTLR3_STRING getText (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t);
\r
53 static ANTLR3_UINT32 getType (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t);
\r
54 static pANTLR3_BASE_TREE getChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 i);
\r
55 static ANTLR3_UINT32 getChildCount (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t);
\r
56 static void replaceChildren (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE parent, ANTLR3_INT32 startChildIndex, ANTLR3_INT32 stopChildIndex, pANTLR3_BASE_TREE t);
\r
57 static void setDebugEventListener (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_DEBUG_EVENT_LISTENER debugger);
\r
58 static void setChildIndex (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_INT32 i);
\r
59 static ANTLR3_INT32 getChildIndex (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t);
\r
60 static void setParent (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE child, pANTLR3_BASE_TREE parent);
\r
61 static pANTLR3_BASE_TREE getParent (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE child);
\r
62 static void setChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 i, pANTLR3_BASE_TREE child);
\r
63 static void deleteChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 i);
\r
64 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);
\r
65 /* Methods specific to each tree adaptor
\r
67 static void setTokenBoundaries (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN startToken, pANTLR3_COMMON_TOKEN stopToken);
\r
68 static void dbgSetTokenBoundaries (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN startToken, pANTLR3_COMMON_TOKEN stopToken);
\r
69 static ANTLR3_MARKER getTokenStartIndex (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t);
\r
70 static ANTLR3_MARKER getTokenStopIndex (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t);
\r
72 static void ctaFree (pANTLR3_BASE_TREE_ADAPTOR adaptor);
\r
74 /** Create a new tree adaptor. Note that despite the fact that this is
\r
75 * creating a new COMMON_TREE adaptor, we return the address of the
\r
76 * BASE_TREE interface, as should any other adaptor that wishes to be
\r
77 * used as the tree element of a tree parse/build. It needs to be given the
\r
78 * address of a valid string factory as we do not know what the originating
\r
79 * input stream encoding type was. This way we can rely on just using
\r
80 * the original input stream's string factory or one of the correct type
\r
81 * which the user supplies us.
\r
83 ANTLR3_API pANTLR3_BASE_TREE_ADAPTOR
\r
84 ANTLR3_TREE_ADAPTORNew(pANTLR3_STRING_FACTORY strFactory)
\r
86 pANTLR3_COMMON_TREE_ADAPTOR cta;
\r
88 // First job is to create the memory we need for the tree adaptor interface.
\r
90 cta = (pANTLR3_COMMON_TREE_ADAPTOR) ANTLR3_MALLOC((size_t)(sizeof(ANTLR3_COMMON_TREE_ADAPTOR)));
\r
97 // Memory is initialized, so initialize the base tree adaptor
\r
99 antlr3BaseTreeAdaptorInit(&(cta->baseAdaptor), NULL);
\r
101 // Install our interface overrides. Strangeness is to allow generated code to treat them
\r
102 // as returning void *
\r
104 cta->baseAdaptor.dupNode = (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))
\r
106 cta->baseAdaptor.create = (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, pANTLR3_COMMON_TOKEN))
\r
108 cta->baseAdaptor.createToken =
\r
110 cta->baseAdaptor.createTokenFromToken =
\r
111 createTokenFromToken;
\r
112 cta->baseAdaptor.setTokenBoundaries = (void (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, pANTLR3_COMMON_TOKEN, pANTLR3_COMMON_TOKEN))
\r
113 setTokenBoundaries;
\r
114 cta->baseAdaptor.getTokenStartIndex = (ANTLR3_MARKER (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))
\r
115 getTokenStartIndex;
\r
116 cta->baseAdaptor.getTokenStopIndex = (ANTLR3_MARKER (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))
\r
118 cta->baseAdaptor.getText = (pANTLR3_STRING (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))
\r
120 cta->baseAdaptor.getType = (ANTLR3_UINT32 (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))
\r
122 cta->baseAdaptor.getChild = (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_UINT32))
\r
124 cta->baseAdaptor.setChild = (void (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_UINT32, void *))
\r
126 cta->baseAdaptor.setParent = (void (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, void *))
\r
128 cta->baseAdaptor.getParent = (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))
\r
130 cta->baseAdaptor.setChildIndex = (void (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_UINT32))
\r
132 cta->baseAdaptor.deleteChild = (void (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_UINT32))
\r
134 cta->baseAdaptor.getChildCount = (ANTLR3_UINT32 (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))
\r
136 cta->baseAdaptor.getChildIndex = (ANTLR3_INT32 (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))
\r
138 cta->baseAdaptor.free = (void (*) (pANTLR3_BASE_TREE_ADAPTOR))
\r
140 cta->baseAdaptor.setDebugEventListener =
\r
141 setDebugEventListener;
\r
142 cta->baseAdaptor.replaceChildren = (void (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_INT32, ANTLR3_INT32, void *))
\r
144 cta->baseAdaptor.errorNode = (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, pANTLR3_TOKEN_STREAM, pANTLR3_COMMON_TOKEN, pANTLR3_COMMON_TOKEN, pANTLR3_EXCEPTION))
\r
147 // Install the super class pointer
\r
149 cta->baseAdaptor.super = cta;
\r
151 // Install a tree factory for creating new tree nodes
\r
153 cta->arboretum = antlr3ArboretumNew(strFactory);
\r
155 // Install a token factory for imaginary tokens, these imaginary
\r
156 // tokens do not require access to the input stream so we can
\r
157 // dummy the creation of it, but they will need a string factory.
\r
159 cta->baseAdaptor.tokenFactory = antlr3TokenFactoryNew(NULL);
\r
160 cta->baseAdaptor.tokenFactory->unTruc.strFactory = strFactory;
\r
162 // Allow the base tree adaptor to share the tree factory's string factory.
\r
164 cta->baseAdaptor.strFactory = strFactory;
\r
166 // Return the address of the base adaptor interface.
\r
168 return &(cta->baseAdaptor);
\r
171 /// Debugging version of the tree adaptor (not normally called as generated code
\r
172 /// calls setDebugEventListener instead which changes a normal token stream to
\r
173 /// a debugging stream and means that a user's instantiation code does not need
\r
174 /// to be changed just to debug with AW.
\r
176 ANTLR3_API pANTLR3_BASE_TREE_ADAPTOR
\r
177 ANTLR3_TREE_ADAPTORDebugNew(pANTLR3_STRING_FACTORY strFactory, pANTLR3_DEBUG_EVENT_LISTENER debugger)
\r
179 pANTLR3_BASE_TREE_ADAPTOR ta;
\r
181 // Create a normal one first
\r
183 ta = ANTLR3_TREE_ADAPTORNew(strFactory);
\r
187 // Reinitialize as a debug version
\r
189 antlr3BaseTreeAdaptorInit(ta, debugger);
\r
190 ta->create = (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, pANTLR3_COMMON_TOKEN))
\r
192 ta->setTokenBoundaries = (void (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, pANTLR3_COMMON_TOKEN, pANTLR3_COMMON_TOKEN))
\r
193 dbgSetTokenBoundaries;
\r
199 /// Causes an existing common tree adaptor to become a debug version
\r
202 setDebugEventListener (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_DEBUG_EVENT_LISTENER debugger)
\r
204 // Reinitialize as a debug version
\r
206 antlr3BaseTreeAdaptorInit(adaptor, debugger);
\r
208 adaptor->create = (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, pANTLR3_COMMON_TOKEN))
\r
210 adaptor->setTokenBoundaries = (void (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, pANTLR3_COMMON_TOKEN, pANTLR3_COMMON_TOKEN))
\r
211 dbgSetTokenBoundaries;
\r
216 ctaFree(pANTLR3_BASE_TREE_ADAPTOR adaptor)
\r
218 pANTLR3_COMMON_TREE_ADAPTOR cta;
\r
220 cta = (pANTLR3_COMMON_TREE_ADAPTOR)(adaptor->super);
\r
222 /* Free the tree factory we created
\r
224 cta->arboretum->close(((pANTLR3_COMMON_TREE_ADAPTOR)(adaptor->super))->arboretum);
\r
226 /* Free the token factory we created
\r
228 adaptor->tokenFactory->close(adaptor->tokenFactory);
\r
230 /* Free the super pointer, as it is this that was allocated
\r
231 * and is the common tree structure.
\r
233 ANTLR3_FREE(adaptor->super);
\r
236 /* BASE_TREE_ADAPTOR overrides */
\r
238 static pANTLR3_BASE_TREE
\r
239 errorNode (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_TOKEN_STREAM ctnstream, pANTLR3_COMMON_TOKEN startToken, pANTLR3_COMMON_TOKEN stopToken, pANTLR3_EXCEPTION e)
\r
241 // Use the supplied common tree node stream to get another tree from the factory
\r
242 // TODO: Look at creating the erronode as in Java, but this is complicated by the
\r
243 // need to track and free the memory allocated to it, so for now, we just
\r
244 // want something in the tree that isn't a NULL pointer.
\r
246 return adaptor->createTypeText(adaptor, ANTLR3_TOKEN_INVALID, (pANTLR3_UINT8)"Tree Error Node");
\r
250 /** Duplicate the supplied node.
\r
252 static pANTLR3_BASE_TREE
\r
253 dupNode (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE treeNode)
\r
255 return treeNode == NULL ? NULL : treeNode->dupNode(treeNode);
\r
258 static pANTLR3_BASE_TREE
\r
259 create (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_COMMON_TOKEN payload)
\r
261 pANTLR3_BASE_TREE ct;
\r
263 /* Create a new common tree as this is what this adaptor deals with
\r
265 ct = ((pANTLR3_COMMON_TREE_ADAPTOR)(adaptor->super))->arboretum->newFromToken(((pANTLR3_COMMON_TREE_ADAPTOR)(adaptor->super))->arboretum, payload);
\r
267 /* But all adaptors return the pointer to the base interface.
\r
271 static pANTLR3_BASE_TREE
\r
272 dbgCreate (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_COMMON_TOKEN payload)
\r
274 pANTLR3_BASE_TREE ct;
\r
276 ct = create(adaptor, payload);
\r
277 adaptor->debugger->createNode(adaptor->debugger, ct);
\r
282 /** Tell me how to create a token for use with imaginary token nodes.
\r
283 * For example, there is probably no input symbol associated with imaginary
\r
284 * token DECL, but you need to create it as a payload or whatever for
\r
285 * the DECL node as in ^(DECL type ID).
\r
287 * If you care what the token payload objects' type is, you should
\r
288 * override this method and any other createToken variant.
\r
290 static pANTLR3_COMMON_TOKEN
\r
291 createToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_UINT8 text)
\r
293 pANTLR3_COMMON_TOKEN newToken;
\r
295 newToken = adaptor->tokenFactory->newToken(adaptor->tokenFactory);
\r
297 if (newToken != NULL)
\r
299 newToken->textState = ANTLR3_TEXT_CHARP;
\r
300 newToken->tokText.chars = (pANTLR3_UCHAR)text;
\r
301 newToken->setType(newToken, tokenType);
\r
302 newToken->input = adaptor->tokenFactory->input;
\r
303 newToken->strFactory = adaptor->strFactory;
\r
308 /** Tell me how to create a token for use with imaginary token nodes.
\r
309 * For example, there is probably no input symbol associated with imaginary
\r
310 * token DECL, but you need to create it as a payload or whatever for
\r
311 * the DECL node as in ^(DECL type ID).
\r
313 * This is a variant of createToken where the new token is derived from
\r
314 * an actual real input token. Typically this is for converting '{'
\r
315 * tokens to BLOCK etc... You'll see
\r
317 * r : lc='{' ID+ '}' -> ^(BLOCK[$lc] ID+) ;
\r
319 * If you care what the token payload objects' type is, you should
\r
320 * override this method and any other createToken variant.
\r
322 * NB: this being C it is not so easy to extend the types of creaeteToken.
\r
323 * We will have to see if anyone needs to do this and add any variants to
\r
326 static pANTLR3_COMMON_TOKEN
\r
327 createTokenFromToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_COMMON_TOKEN fromToken)
\r
329 pANTLR3_COMMON_TOKEN newToken;
\r
331 newToken = adaptor->tokenFactory->newToken(adaptor->tokenFactory);
\r
333 if (newToken != NULL)
\r
335 // Create the text using our own string factory to avoid complicating
\r
338 pANTLR3_STRING text;
\r
340 newToken->toString = fromToken->toString;
\r
342 if (fromToken->textState == ANTLR3_TEXT_CHARP)
\r
344 newToken->textState = ANTLR3_TEXT_CHARP;
\r
345 newToken->tokText.chars = fromToken->tokText.chars;
\r
349 text = fromToken->getText(fromToken);
\r
350 newToken->textState = ANTLR3_TEXT_STRING;
\r
351 newToken->tokText.text = adaptor->strFactory->newPtr(adaptor->strFactory, text->chars, text->len);
\r
354 newToken->setLine (newToken, fromToken->getLine(fromToken));
\r
355 newToken->setTokenIndex (newToken, fromToken->getTokenIndex(fromToken));
\r
356 newToken->setCharPositionInLine (newToken, fromToken->getCharPositionInLine(fromToken));
\r
357 newToken->setChannel (newToken, fromToken->getChannel(fromToken));
\r
358 newToken->setType (newToken, fromToken->getType(fromToken));
\r
364 /* Specific methods for a TreeAdaptor */
\r
366 /** Track start/stop token for subtree root created for a rule.
\r
367 * Only works with CommonTree nodes. For rules that match nothing,
\r
368 * seems like this will yield start=i and stop=i-1 in a nil node.
\r
369 * Might be useful info so I'll not force to be i..i.
\r
372 setTokenBoundaries (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN startToken, pANTLR3_COMMON_TOKEN stopToken)
\r
374 ANTLR3_MARKER start;
\r
375 ANTLR3_MARKER stop;
\r
377 pANTLR3_COMMON_TREE ct;
\r
384 if ( startToken != NULL)
\r
386 start = startToken->getTokenIndex(startToken);
\r
393 if ( stopToken != NULL)
\r
395 stop = stopToken->getTokenIndex(stopToken);
\r
402 ct = (pANTLR3_COMMON_TREE)(t->super);
\r
404 ct->startIndex = start;
\r
405 ct->stopIndex = stop;
\r
409 dbgSetTokenBoundaries (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN startToken, pANTLR3_COMMON_TOKEN stopToken)
\r
411 setTokenBoundaries(adaptor, t, startToken, stopToken);
\r
413 if (t != NULL && startToken != NULL && stopToken != NULL)
\r
415 adaptor->debugger->setTokenBoundaries(adaptor->debugger, t, startToken->getTokenIndex(startToken), stopToken->getTokenIndex(stopToken));
\r
419 static ANTLR3_MARKER
\r
420 getTokenStartIndex (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)
\r
422 return ((pANTLR3_COMMON_TREE)(t->super))->startIndex;
\r
425 static ANTLR3_MARKER
\r
426 getTokenStopIndex (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)
\r
428 return ((pANTLR3_COMMON_TREE)(t->super))->stopIndex;
\r
431 static pANTLR3_STRING
\r
432 getText (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)
\r
434 return t->getText(t);
\r
437 static ANTLR3_UINT32
\r
438 getType (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)
\r
440 return t->getType(t);
\r
445 (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE parent, ANTLR3_INT32 startChildIndex, ANTLR3_INT32 stopChildIndex, pANTLR3_BASE_TREE t)
\r
447 if (parent != NULL)
\r
449 parent->replaceChildren(parent, startChildIndex, stopChildIndex, t);
\r
453 static pANTLR3_BASE_TREE
\r
454 getChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 i)
\r
456 return t->getChild(t, i);
\r
459 setChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 i, pANTLR3_BASE_TREE child)
\r
461 t->setChild(t, i, child);
\r
465 deleteChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 i)
\r
467 t->deleteChild(t, i);
\r
470 static ANTLR3_UINT32
\r
471 getChildCount (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)
\r
473 return t->getChildCount(t);
\r
477 setChildIndex (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_INT32 i)
\r
479 t->setChildIndex(t, i);
\r
482 static ANTLR3_INT32
\r
483 getChildIndex (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)
\r
485 return t->getChildIndex(t);
\r
488 setParent (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE child, pANTLR3_BASE_TREE parent)
\r
490 child->setParent(child, parent);
\r
492 static pANTLR3_BASE_TREE
\r
493 getParent (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE child)
\r
495 return child->getParent(child);
\r