bundles/org.simantics.databoard/cpp/DataBoardTest/libantlr3c-3.2/src/antlr3commontreeadaptor.c

   1 /** \file\r
   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
   8  */\r
   9 \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
  14 //\r
  15 // All rights reserved.\r
  16 //\r
  17 // Redistribution and use in source and binary forms, with or without\r
  18 // modification, are permitted provided that the following conditions\r
  19 // are met:\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
  27 //\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
  38 \r
  39 #include    <antlr3commontreeadaptor.h>\r
  40 \r
  41 #ifdef  ANTLR3_WINDOWS\r
  42 #pragma warning( disable : 4100 )\r
  43 #endif\r
  44 \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
  66  */\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
  71 \r
  72 static  void            ctaFree                 (pANTLR3_BASE_TREE_ADAPTOR adaptor);\r
  73 \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
  82  */\r
  83 ANTLR3_API pANTLR3_BASE_TREE_ADAPTOR\r
  84 ANTLR3_TREE_ADAPTORNew(pANTLR3_STRING_FACTORY strFactory)\r
  85 {\r
  86         pANTLR3_COMMON_TREE_ADAPTOR     cta;\r
  87 \r
  88         // First job is to create the memory we need for the tree adaptor interface.\r
  89         //\r
  90         cta     = (pANTLR3_COMMON_TREE_ADAPTOR) ANTLR3_MALLOC((size_t)(sizeof(ANTLR3_COMMON_TREE_ADAPTOR)));\r
  91 \r
  92         if      (cta == NULL)\r
  93         {\r
  94                 return  NULL;\r
  95         }\r
  96 \r
  97         // Memory is initialized, so initialize the base tree adaptor\r
  98         //\r
  99         antlr3BaseTreeAdaptorInit(&(cta->baseAdaptor), NULL);\r
 100 \r
 101         // Install our interface overrides. Strangeness is to allow generated code to treat them\r
 102     // as returning void *\r
 103         //\r
 104         cta->baseAdaptor.dupNode                                =  (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))\r
 105                                                                                                         dupNode;\r
 106         cta->baseAdaptor.create                                 =  (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, pANTLR3_COMMON_TOKEN))\r
 107                                                                                                         create;\r
 108         cta->baseAdaptor.createToken                    =  \r
 109                                                                                                         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
 117                                                     getTokenStopIndex;\r
 118         cta->baseAdaptor.getText                                =  (pANTLR3_STRING (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))\r
 119                                                     getText;\r
 120         cta->baseAdaptor.getType                                =  (ANTLR3_UINT32  (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))\r
 121                                                     getType;\r
 122         cta->baseAdaptor.getChild                               =  (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_UINT32))\r
 123                                                     getChild;\r
 124         cta->baseAdaptor.setChild                               =  (void   (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_UINT32, void *))\r
 125                                                     setChild;\r
 126         cta->baseAdaptor.setParent                              =  (void   (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, void *))\r
 127                                                     setParent;\r
 128     cta->baseAdaptor.getParent                          =  (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))\r
 129                                                     getParent;\r
 130         cta->baseAdaptor.setChildIndex                  =  (void   (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_UINT32))\r
 131                                                     setChildIndex;\r
 132         cta->baseAdaptor.deleteChild                    =  (void   (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_UINT32))\r
 133                                                     deleteChild;\r
 134         cta->baseAdaptor.getChildCount                  =  (ANTLR3_UINT32  (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))\r
 135                                                     getChildCount;\r
 136         cta->baseAdaptor.getChildIndex                  =  (ANTLR3_INT32  (*) (pANTLR3_BASE_TREE_ADAPTOR, void *))\r
 137                                                     getChildIndex;\r
 138         cta->baseAdaptor.free                                   =  (void  (*) (pANTLR3_BASE_TREE_ADAPTOR))\r
 139                                                     ctaFree;\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
 143                                                     replaceChildren;\r
 144         cta->baseAdaptor.errorNode                              =  (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, pANTLR3_TOKEN_STREAM, pANTLR3_COMMON_TOKEN, pANTLR3_COMMON_TOKEN, pANTLR3_EXCEPTION))\r
 145                                                     errorNode;\r
 146 \r
 147         // Install the super class pointer\r
 148         //\r
 149         cta->baseAdaptor.super      = cta;\r
 150 \r
 151         // Install a tree factory for creating new tree nodes\r
 152         //\r
 153         cta->arboretum  = antlr3ArboretumNew(strFactory);\r
 154 \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
 158         //\r
 159         cta->baseAdaptor.tokenFactory                                           = antlr3TokenFactoryNew(NULL);\r
 160         cta->baseAdaptor.tokenFactory->unTruc.strFactory        = strFactory;\r
 161 \r
 162         // Allow the base tree adaptor to share the tree factory's string factory.\r
 163         //\r
 164         cta->baseAdaptor.strFactory     = strFactory;\r
 165 \r
 166         // Return the address of the base adaptor interface.\r
 167         //\r
 168         return  &(cta->baseAdaptor);\r
 169 }\r
 170 \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
 175 ///\r
 176 ANTLR3_API pANTLR3_BASE_TREE_ADAPTOR\r
 177 ANTLR3_TREE_ADAPTORDebugNew(pANTLR3_STRING_FACTORY strFactory, pANTLR3_DEBUG_EVENT_LISTENER     debugger)\r
 178 {\r
 179         pANTLR3_BASE_TREE_ADAPTOR       ta;\r
 180 \r
 181         // Create a normal one first\r
 182         //\r
 183         ta      = ANTLR3_TREE_ADAPTORNew(strFactory);\r
 184         \r
 185         if      (ta != NULL)\r
 186         {\r
 187                 // Reinitialize as a debug version\r
 188                 //\r
 189                 antlr3BaseTreeAdaptorInit(ta, debugger);\r
 190                 ta->create                              = (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, pANTLR3_COMMON_TOKEN))\r
 191                                                                         dbgCreate;\r
 192                 ta->setTokenBoundaries  = (void   (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, pANTLR3_COMMON_TOKEN, pANTLR3_COMMON_TOKEN))\r
 193                                                                         dbgSetTokenBoundaries;\r
 194         }\r
 195 \r
 196         return  ta;\r
 197 }\r
 198 \r
 199 /// Causes an existing common tree adaptor to become a debug version\r
 200 ///\r
 201 static  void\r
 202 setDebugEventListener   (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_DEBUG_EVENT_LISTENER debugger)\r
 203 {\r
 204         // Reinitialize as a debug version\r
 205         //\r
 206         antlr3BaseTreeAdaptorInit(adaptor, debugger);\r
 207 \r
 208         adaptor->create                         = (void * (*) (pANTLR3_BASE_TREE_ADAPTOR, pANTLR3_COMMON_TOKEN))\r
 209                                     dbgCreate;\r
 210         adaptor->setTokenBoundaries     = (void   (*) (pANTLR3_BASE_TREE_ADAPTOR, void *, pANTLR3_COMMON_TOKEN, pANTLR3_COMMON_TOKEN))\r
 211                                     dbgSetTokenBoundaries;\r
 212 \r
 213 }\r
 214 \r
 215 static void\r
 216 ctaFree(pANTLR3_BASE_TREE_ADAPTOR adaptor)\r
 217 {\r
 218     pANTLR3_COMMON_TREE_ADAPTOR cta;\r
 219 \r
 220     cta = (pANTLR3_COMMON_TREE_ADAPTOR)(adaptor->super);\r
 221 \r
 222     /* Free the tree factory we created\r
 223      */\r
 224     cta->arboretum->close(((pANTLR3_COMMON_TREE_ADAPTOR)(adaptor->super))->arboretum);\r
 225 \r
 226     /* Free the token factory we created\r
 227      */\r
 228     adaptor->tokenFactory->close(adaptor->tokenFactory);\r
 229 \r
 230     /* Free the super pointer, as it is this that was allocated\r
 231      * and is the common tree structure.\r
 232      */\r
 233     ANTLR3_FREE(adaptor->super);\r
 234 }\r
 235 \r
 236 /* BASE_TREE_ADAPTOR overrides */\r
 237 \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
 240 {\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
 245         //\r
 246         return adaptor->createTypeText(adaptor, ANTLR3_TOKEN_INVALID, (pANTLR3_UINT8)"Tree Error Node");\r
 247 \r
 248 }\r
 249 \r
 250 /** Duplicate the supplied node.\r
 251  */\r
 252 static  pANTLR3_BASE_TREE\r
 253 dupNode         (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE treeNode)\r
 254 {\r
 255         return  treeNode == NULL ? NULL : treeNode->dupNode(treeNode);\r
 256 }\r
 257 \r
 258 static  pANTLR3_BASE_TREE\r
 259 create          (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_COMMON_TOKEN payload)\r
 260 {\r
 261     pANTLR3_BASE_TREE   ct;\r
 262     \r
 263     /* Create a new common tree as this is what this adaptor deals with\r
 264      */\r
 265     ct = ((pANTLR3_COMMON_TREE_ADAPTOR)(adaptor->super))->arboretum->newFromToken(((pANTLR3_COMMON_TREE_ADAPTOR)(adaptor->super))->arboretum, payload);\r
 266 \r
 267     /* But all adaptors return the pointer to the base interface.\r
 268      */\r
 269     return  ct;\r
 270 }\r
 271 static  pANTLR3_BASE_TREE\r
 272 dbgCreate               (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_COMMON_TOKEN payload)\r
 273 {\r
 274         pANTLR3_BASE_TREE       ct;\r
 275 \r
 276         ct = create(adaptor, payload);\r
 277         adaptor->debugger->createNode(adaptor->debugger, ct);\r
 278 \r
 279         return ct;\r
 280 }\r
 281 \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
 286  *\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
 289  */\r
 290 static  pANTLR3_COMMON_TOKEN\r
 291 createToken             (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_UINT8 text)\r
 292 {\r
 293     pANTLR3_COMMON_TOKEN    newToken;\r
 294 \r
 295     newToken    = adaptor->tokenFactory->newToken(adaptor->tokenFactory);\r
 296 \r
 297     if  (newToken != NULL)\r
 298     {   \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
 304     }\r
 305     return  newToken;\r
 306 }\r
 307 \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
 312  *\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
 316  *\r
 317  *    r : lc='{' ID+ '}' -> ^(BLOCK[$lc] ID+) ;\r
 318  *\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
 321  *\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
 324  *     this interface.\r
 325  */\r
 326 static  pANTLR3_COMMON_TOKEN\r
 327 createTokenFromToken    (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_COMMON_TOKEN fromToken)\r
 328 {\r
 329     pANTLR3_COMMON_TOKEN    newToken;\r
 330 \r
 331     newToken    = adaptor->tokenFactory->newToken(adaptor->tokenFactory);\r
 332     \r
 333     if  (newToken != NULL)\r
 334     {\r
 335                 // Create the text using our own string factory to avoid complicating\r
 336                 // commontoken.\r
 337                 //\r
 338                 pANTLR3_STRING  text;\r
 339 \r
 340                 newToken->toString  = fromToken->toString;\r
 341 \r
 342                 if      (fromToken->textState == ANTLR3_TEXT_CHARP)\r
 343                 {\r
 344                         newToken->textState             = ANTLR3_TEXT_CHARP;\r
 345                         newToken->tokText.chars = fromToken->tokText.chars;\r
 346                 }\r
 347                 else\r
 348                 {\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
 352                 }\r
 353 \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
 359     }\r
 360 \r
 361     return  newToken;\r
 362 }\r
 363 \r
 364 /* Specific methods for a TreeAdaptor */\r
 365 \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
 370  */\r
 371 static  void\r
 372 setTokenBoundaries      (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN startToken, pANTLR3_COMMON_TOKEN stopToken)\r
 373 {\r
 374         ANTLR3_MARKER   start;\r
 375         ANTLR3_MARKER   stop;\r
 376 \r
 377         pANTLR3_COMMON_TREE         ct;\r
 378 \r
 379         if      (t == NULL)\r
 380         {\r
 381                 return;\r
 382         }\r
 383 \r
 384         if      ( startToken != NULL)\r
 385         {\r
 386                 start = startToken->getTokenIndex(startToken);\r
 387         }\r
 388         else\r
 389         {\r
 390                 start = 0;\r
 391         }\r
 392 \r
 393         if      ( stopToken != NULL)\r
 394         {\r
 395                 stop = stopToken->getTokenIndex(stopToken);\r
 396         }\r
 397         else\r
 398         {\r
 399                 stop = 0;\r
 400         }\r
 401 \r
 402         ct      = (pANTLR3_COMMON_TREE)(t->super);\r
 403 \r
 404         ct->startIndex  = start;\r
 405         ct->stopIndex   = stop;\r
 406 \r
 407 }\r
 408 static  void\r
 409 dbgSetTokenBoundaries   (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN startToken, pANTLR3_COMMON_TOKEN stopToken)\r
 410 {\r
 411         setTokenBoundaries(adaptor, t, startToken, stopToken);\r
 412 \r
 413         if      (t != NULL && startToken != NULL && stopToken != NULL)\r
 414         {\r
 415                 adaptor->debugger->setTokenBoundaries(adaptor->debugger, t, startToken->getTokenIndex(startToken), stopToken->getTokenIndex(stopToken));\r
 416         }\r
 417 }\r
 418 \r
 419 static  ANTLR3_MARKER   \r
 420 getTokenStartIndex      (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)\r
 421 {\r
 422     return  ((pANTLR3_COMMON_TREE)(t->super))->startIndex;\r
 423 }\r
 424 \r
 425 static  ANTLR3_MARKER   \r
 426 getTokenStopIndex       (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)\r
 427 {\r
 428     return  ((pANTLR3_COMMON_TREE)(t->super))->stopIndex;\r
 429 }\r
 430 \r
 431 static  pANTLR3_STRING\r
 432 getText         (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)\r
 433 {\r
 434     return  t->getText(t);\r
 435 }\r
 436 \r
 437 static  ANTLR3_UINT32\r
 438 getType         (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)\r
 439 {\r
 440     return  t->getType(t);\r
 441 }\r
 442 \r
 443 static  void                                    \r
 444 replaceChildren\r
 445 (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE parent, ANTLR3_INT32 startChildIndex, ANTLR3_INT32 stopChildIndex, pANTLR3_BASE_TREE t)\r
 446 {\r
 447         if      (parent != NULL)\r
 448         {\r
 449                 parent->replaceChildren(parent, startChildIndex, stopChildIndex, t);\r
 450         }\r
 451 }\r
 452 \r
 453 static  pANTLR3_BASE_TREE\r
 454 getChild                                (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 i)\r
 455 {\r
 456         return t->getChild(t, i);\r
 457 }\r
 458 static  void\r
 459 setChild                                (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 i, pANTLR3_BASE_TREE child)\r
 460 {\r
 461         t->setChild(t, i, child);\r
 462 }\r
 463 \r
 464 static  void\r
 465 deleteChild                             (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 i)\r
 466 {\r
 467         t->deleteChild(t, i);\r
 468 }\r
 469 \r
 470 static  ANTLR3_UINT32\r
 471 getChildCount                   (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)\r
 472 {\r
 473         return t->getChildCount(t);\r
 474 }\r
 475 \r
 476 static  void\r
 477 setChildIndex                   (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_INT32 i)\r
 478 {\r
 479         t->setChildIndex(t, i);\r
 480 }\r
 481 \r
 482 static  ANTLR3_INT32\r
 483 getChildIndex                   (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t)\r
 484 {\r
 485         return t->getChildIndex(t);\r
 486 }\r
 487 static  void\r
 488 setParent                               (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE child, pANTLR3_BASE_TREE parent)\r
 489 {\r
 490         child->setParent(child, parent);\r
 491 }\r
 492 static  pANTLR3_BASE_TREE\r
 493 getParent                               (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE child)\r
 494 {\r
 495         return child->getParent(child);\r
 496 }\r