1/** \file 2 * Contains the base functions that all tree adaptors start with. 3 * this implementation can then be overridden by any higher implementation. 4 * 5 */ 6 7// [The "BSD licence"] 8// Copyright (c) 2005-2009 Jim Idle, Temporal Wave LLC 9// http://www.temporal-wave.com 10// http://www.linkedin.com/in/jimidle 11// 12// All rights reserved. 13// 14// Redistribution and use in source and binary forms, with or without 15// modification, are permitted provided that the following conditions 16// are met: 17// 1. Redistributions of source code must retain the above copyright 18// notice, this list of conditions and the following disclaimer. 19// 2. Redistributions in binary form must reproduce the above copyright 20// notice, this list of conditions and the following disclaimer in the 21// documentation and/or other materials provided with the distribution. 22// 3. The name of the author may not be used to endorse or promote products 23// derived from this software without specific prior written permission. 24// 25// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 26// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 27// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 28// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 29// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 30// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 31// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 32// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 33// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 34// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 35 36#include <antlr3basetreeadaptor.h> 37 38#ifdef ANTLR3_WINDOWS 39#pragma warning( disable : 4100 ) 40#endif 41 42/* Interface functions 43 */ 44static pANTLR3_BASE_TREE nilNode (pANTLR3_BASE_TREE_ADAPTOR adaptor); 45static pANTLR3_BASE_TREE dbgNil (pANTLR3_BASE_TREE_ADAPTOR adaptor); 46static pANTLR3_BASE_TREE dupTree (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t); 47static pANTLR3_BASE_TREE dbgDupTree (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t); 48static pANTLR3_BASE_TREE dupTreeTT (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_BASE_TREE parent); 49static void addChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_BASE_TREE child); 50static void dbgAddChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_BASE_TREE child); 51static pANTLR3_BASE_TREE becomeRoot (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE newRoot, pANTLR3_BASE_TREE oldRoot); 52static pANTLR3_BASE_TREE dbgBecomeRoot (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE newRoot, pANTLR3_BASE_TREE oldRoot); 53static pANTLR3_BASE_TREE rulePostProcessing (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE root); 54static void addChildToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN child); 55static void dbgAddChildToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN child); 56static pANTLR3_BASE_TREE becomeRootToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, void * newRoot, pANTLR3_BASE_TREE oldRoot); 57static pANTLR3_BASE_TREE dbgBecomeRootToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, void * newRoot, pANTLR3_BASE_TREE oldRoot); 58static pANTLR3_BASE_TREE createTypeToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken); 59static pANTLR3_BASE_TREE dbgCreateTypeToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken); 60static pANTLR3_BASE_TREE createTypeTokenText (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken, pANTLR3_UINT8 text); 61static pANTLR3_BASE_TREE dbgCreateTypeTokenText (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken, pANTLR3_UINT8 text); 62static pANTLR3_BASE_TREE createTypeText (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_UINT8 text); 63static pANTLR3_BASE_TREE dbgCreateTypeText (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_UINT8 text); 64static ANTLR3_UINT32 getType (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t); 65static void setType (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 type); 66static pANTLR3_STRING getText (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t); 67static void setText (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_STRING t); 68static void setText8 (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_UINT8 t); 69static pANTLR3_BASE_TREE getChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 i); 70static ANTLR3_UINT32 getChildCount (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t); 71static ANTLR3_UINT32 getUniqueID (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t); 72static ANTLR3_BOOLEAN isNilNode (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t); 73static pANTLR3_STRING makeDot (pANTLR3_BASE_TREE_ADAPTOR adaptor, void * theTree); 74 75/** Given a pointer to a base tree adaptor structure (which is usually embedded in the 76 * super class the implements the tree adaptor used in the parse), initialize its 77 * function pointers and so on. 78 */ 79ANTLR3_API void 80antlr3BaseTreeAdaptorInit(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_DEBUG_EVENT_LISTENER debugger) 81{ 82 // Initialize the interface 83 // 84 if (debugger == NULL) 85 { 86 adaptor->nilNode = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR)) 87 nilNode; 88 adaptor->addChild = (void (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, void *)) 89 addChild; 90 adaptor->becomeRoot = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, void *)) 91 becomeRoot; 92 adaptor->addChildToken = (void (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, pANTLR3_COMMON_TOKEN)) 93 addChildToken; 94 adaptor->becomeRootToken = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, void *)) 95 becomeRootToken; 96 adaptor->createTypeToken = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, ANTLR3_UINT32, pANTLR3_COMMON_TOKEN)) 97 createTypeToken; 98 adaptor->createTypeTokenText = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, ANTLR3_UINT32, pANTLR3_COMMON_TOKEN, pANTLR3_UINT8)) 99 createTypeTokenText; 100 adaptor->createTypeText = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, ANTLR3_UINT32, pANTLR3_UINT8)) 101 createTypeText; 102 adaptor->dupTree = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *)) 103 dupTree; 104 } 105 else 106 { 107 adaptor->nilNode = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR)) 108 dbgNil; 109 adaptor->addChild = (void (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, void *)) 110 dbgAddChild; 111 adaptor->becomeRoot = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, void *)) 112 dbgBecomeRoot; 113 adaptor->addChildToken = (void (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, pANTLR3_COMMON_TOKEN)) 114 dbgAddChildToken; 115 adaptor->becomeRootToken = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, void *)) 116 dbgBecomeRootToken; 117 adaptor->createTypeToken = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, ANTLR3_UINT32, pANTLR3_COMMON_TOKEN)) 118 dbgCreateTypeToken; 119 adaptor->createTypeTokenText = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, ANTLR3_UINT32, pANTLR3_COMMON_TOKEN, pANTLR3_UINT8)) 120 dbgCreateTypeTokenText; 121 adaptor->createTypeText = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, ANTLR3_UINT32, pANTLR3_UINT8)) 122 dbgCreateTypeText; 123 adaptor->dupTree = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *)) 124 dbgDupTree; 125 debugger->adaptor = adaptor; 126 } 127 128 adaptor->dupTreeTT = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, void *)) 129 dupTreeTT; 130 adaptor->rulePostProcessing = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *)) 131 rulePostProcessing; 132 adaptor->getType = (ANTLR3_UINT32 (*)(pANTLR3_BASE_TREE_ADAPTOR, void *)) 133 getType; 134 adaptor->setType = (void (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_UINT32)) 135 setType; 136 adaptor->getText = (pANTLR3_STRING (*) (pANTLR3_BASE_TREE_ADAPTOR, void *)) 137 getText; 138 adaptor->setText8 = (void (*)(pANTLR3_BASE_TREE_ADAPTOR, pANTLR3_UINT8)) 139 setText8; 140 adaptor->setText = (void (*)(pANTLR3_BASE_TREE_ADAPTOR, pANTLR3_STRING)) 141 setText; 142 adaptor->getChild = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_UINT32)) 143 getChild; 144 adaptor->getChildCount = (ANTLR3_UINT32 (*)(pANTLR3_BASE_TREE_ADAPTOR, void *)) 145 getChildCount; 146 adaptor->getUniqueID = (ANTLR3_UINT32 (*)(pANTLR3_BASE_TREE_ADAPTOR, void *)) 147 getUniqueID; 148 adaptor->isNilNode = (ANTLR3_BOOLEAN (*)(pANTLR3_BASE_TREE_ADAPTOR, void *)) 149 isNilNode; 150 151 adaptor->makeDot = (pANTLR3_STRING (*)(pANTLR3_BASE_TREE_ADAPTOR, void *)) 152 makeDot; 153 154 /* Remaining functions filled in by the caller. 155 */ 156 return; 157} 158 159static void 160defineDotNodes(pANTLR3_BASE_TREE_ADAPTOR adaptor, void * t, pANTLR3_STRING dotSpec ) 161{ 162 // How many nodes are we talking about? 163 // 164 int nCount; 165 int i; 166 pANTLR3_BASE_TREE child; 167 char buff[64]; 168 pANTLR3_STRING text; 169 int j; 170 171 172 173 174 175 // Count the nodes 176 // 177 nCount = adaptor->getChildCount(adaptor, t); 178 179 if (nCount == 0) 180 { 181 // This will already have been included as a child of another node 182 // so there is nothing to add. 183 // 184 return; 185 } 186 187 // For each child of the current tree, define a node using the 188 // memory address of the node to name it 189 // 190 for (i = 0; i<nCount; i++) 191 { 192 193 // Pick up a pointer for the child 194 // 195 child = adaptor->getChild(adaptor, t, i); 196 197 // Name the node 198 // 199 sprintf(buff, "\tn%p[label=\"", child); 200 dotSpec->append8(dotSpec, buff); 201 text = adaptor->getText(adaptor, child); 202 for (j = 0; j < (ANTLR3_INT32)(text->len); j++) 203 { 204 switch(text->charAt(text, j)) 205 { 206 case '"': 207 208 dotSpec->append8(dotSpec, "\\\""); 209 break; 210 211 case '\n': 212 213 dotSpec->append8(dotSpec, "\\n"); 214 break; 215 216 case '\r': 217 218 dotSpec->append8(dotSpec, "\\r"); 219 break; 220 221 default: 222 223 dotSpec->addc(dotSpec, text->charAt(text, j)); 224 break; 225 } 226 } 227 dotSpec->append8(dotSpec, "\"]\n"); 228 229 // And now define the children of this child (if any) 230 // 231 defineDotNodes(adaptor, child, dotSpec); 232 } 233 234 // Done 235 // 236 return; 237} 238 239static void 240defineDotEdges(pANTLR3_BASE_TREE_ADAPTOR adaptor, void * t, pANTLR3_STRING dotSpec) 241{ 242 // How many nodes are we talking about? 243 // 244 int nCount; 245 int i; 246 247 if (t == NULL) 248 { 249 // No tree, so do nothing 250 // 251 return; 252 } 253 254 // Count the nodes 255 // 256 nCount = adaptor->getChildCount(adaptor, t); 257 258 if (nCount == 0) 259 { 260 // This will already have been included as a child of another node 261 // so there is nothing to add. 262 // 263 return; 264 } 265 266 // For each child, define an edge from this parent, then process 267 // and children of this child in the same way 268 // 269 for (i=0; i<nCount; i++) 270 { 271 pANTLR3_BASE_TREE child; 272 char buff[128]; 273 pANTLR3_STRING text; 274 int j; 275 276 // Next child 277 // 278 child = adaptor->getChild(adaptor, t, i); 279 280 // Create the edge relation 281 // 282 sprintf(buff, "\t\tn%p -> n%p\t\t// ", t, child); 283 284 dotSpec->append8(dotSpec, buff); 285 286 // Document the relationship 287 // 288 text = adaptor->getText(adaptor, t); 289 for (j = 0; j < (ANTLR3_INT32)(text->len); j++) 290 { 291 switch(text->charAt(text, j)) 292 { 293 case '"': 294 295 dotSpec->append8(dotSpec, "\\\""); 296 break; 297 298 case '\n': 299 300 dotSpec->append8(dotSpec, "\\n"); 301 break; 302 303 case '\r': 304 305 dotSpec->append8(dotSpec, "\\r"); 306 break; 307 308 default: 309 310 dotSpec->addc(dotSpec, text->charAt(text, j)); 311 break; 312 } 313 } 314 315 dotSpec->append8(dotSpec, " -> "); 316 317 text = adaptor->getText(adaptor, child); 318 for (j = 0; j < (ANTLR3_INT32)(text->len); j++) 319 { 320 switch(text->charAt(text, j)) 321 { 322 case '"': 323 324 dotSpec->append8(dotSpec, "\\\""); 325 break; 326 327 case '\n': 328 329 dotSpec->append8(dotSpec, "\\n"); 330 break; 331 332 case '\r': 333 334 dotSpec->append8(dotSpec, "\\r"); 335 break; 336 337 default: 338 339 dotSpec->addc(dotSpec, text->charAt(text, j)); 340 break; 341 } 342 } 343 dotSpec->append8(dotSpec, "\n"); 344 345 346 // Define edges for this child 347 // 348 defineDotEdges(adaptor, child, dotSpec); 349 } 350 351 // Done 352 // 353 return; 354} 355 356/// Produce a DOT specification for graphviz 357// 358static pANTLR3_STRING 359makeDot (pANTLR3_BASE_TREE_ADAPTOR adaptor, void * theTree) 360{ 361 // The string we are building up 362 // 363 pANTLR3_STRING dotSpec; 364 char buff[64]; 365 pANTLR3_STRING text; 366 int j; 367 368 dotSpec = adaptor->strFactory->newStr8 369 370 ( 371 adaptor->strFactory, 372 373 // Default look and feel 374 // 375 (pANTLR3_UINT8) 376 "digraph {\n\n" 377 "\tordering=out;\n" 378 "\tranksep=.4;\n" 379 "\tbgcolor=\"lightgrey\"; node [shape=box, fixedsize=false, fontsize=12, fontname=\"Helvetica-bold\", fontcolor=\"blue\"\n" 380 "\twidth=.25, height=.25, color=\"black\", fillcolor=\"white\", style=\"filled, solid, bold\"];\n\n" 381 "\tedge [arrowsize=.5, color=\"black\", style=\"bold\"]\n\n" 382 ); 383 384 if (theTree == NULL) 385 { 386 // No tree, so create a blank spec 387 // 388 dotSpec->append8(dotSpec, "n0[label=\"EMPTY TREE\"]\n"); 389 return dotSpec; 390 } 391 392 sprintf(buff, "\tn%p[label=\"", theTree); 393 dotSpec->append8(dotSpec, buff); 394 text = adaptor->getText(adaptor, theTree); 395 for (j = 0; j < (ANTLR3_INT32)(text->len); j++) 396 { 397 switch(text->charAt(text, j)) 398 { 399 case '"': 400 401 dotSpec->append8(dotSpec, "\\\""); 402 break; 403 404 case '\n': 405 406 dotSpec->append8(dotSpec, "\\n"); 407 break; 408 409 case '\r': 410 411 dotSpec->append8(dotSpec, "\\r"); 412 break; 413 414 default: 415 416 dotSpec->addc(dotSpec, text->charAt(text, j)); 417 break; 418 } 419 } 420 dotSpec->append8(dotSpec, "\"]\n"); 421 422 // First produce the node defintions 423 // 424 defineDotNodes(adaptor, theTree, dotSpec); 425 dotSpec->append8(dotSpec, "\n"); 426 defineDotEdges(adaptor, theTree, dotSpec); 427 428 // Terminate the spec 429 // 430 dotSpec->append8(dotSpec, "\n}"); 431 432 // Result 433 // 434 return dotSpec; 435} 436 437 438/** Create and return a nil tree node (no token payload) 439 */ 440static pANTLR3_BASE_TREE 441nilNode (pANTLR3_BASE_TREE_ADAPTOR adaptor) 442{ 443 return adaptor->create(adaptor, NULL); 444} 445 446static pANTLR3_BASE_TREE 447dbgNil (pANTLR3_BASE_TREE_ADAPTOR adaptor) 448{ 449 pANTLR3_BASE_TREE t; 450 451 t = adaptor->create (adaptor, NULL); 452 adaptor->debugger->createNode (adaptor->debugger, t); 453 454 return t; 455} 456 457/** Return a duplicate of the entire tree (implementation provided by the 458 * BASE_TREE interface.) 459 */ 460static pANTLR3_BASE_TREE 461dupTree (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t) 462{ 463 return adaptor->dupTreeTT(adaptor, t, NULL); 464} 465 466pANTLR3_BASE_TREE 467dupTreeTT (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_BASE_TREE parent) 468{ 469 pANTLR3_BASE_TREE newTree; 470 pANTLR3_BASE_TREE child; 471 pANTLR3_BASE_TREE newSubTree; 472 ANTLR3_UINT32 n; 473 ANTLR3_UINT32 i; 474 475 if (t == NULL) 476 { 477 return NULL; 478 } 479 newTree = t->dupNode(t); 480 481 // Ensure new subtree root has parent/child index set 482 // 483 adaptor->setChildIndex (adaptor, newTree, t->getChildIndex(t)); 484 adaptor->setParent (adaptor, newTree, parent); 485 n = adaptor->getChildCount (adaptor, t); 486 487 for (i=0; i < n; i++) 488 { 489 child = adaptor->getChild (adaptor, t, i); 490 newSubTree = adaptor->dupTreeTT (adaptor, child, t); 491 adaptor->addChild (adaptor, newTree, newSubTree); 492 } 493 return newTree; 494} 495 496/// Sends the required debugging events for duplicating a tree 497/// to the debugger. 498/// 499static void 500simulateTreeConstruction(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE tree) 501{ 502 ANTLR3_UINT32 n; 503 ANTLR3_UINT32 i; 504 pANTLR3_BASE_TREE child; 505 506 // Send the create node event 507 // 508 adaptor->debugger->createNode(adaptor->debugger, tree); 509 510 n = adaptor->getChildCount(adaptor, tree); 511 for (i = 0; i < n; i++) 512 { 513 child = adaptor->getChild(adaptor, tree, i); 514 simulateTreeConstruction(adaptor, child); 515 adaptor->debugger->addChild(adaptor->debugger, tree, child); 516 } 517} 518 519pANTLR3_BASE_TREE 520dbgDupTree (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE tree) 521{ 522 pANTLR3_BASE_TREE t; 523 524 // Call the normal dup tree mechanism first 525 // 526 t = adaptor->dupTreeTT(adaptor, tree, NULL); 527 528 // In order to tell the debugger what we have just done, we now 529 // simulate the tree building mechanism. THis will fire 530 // lots of debugging events to the client and look like we 531 // duped the tree.. 532 // 533 simulateTreeConstruction(adaptor, t); 534 535 return t; 536} 537 538/** Add a child to the tree t. If child is a flat tree (a list), make all 539 * in list children of t. Warning: if t has no children, but child does 540 * and child isNilNode then it is ok to move children to t via 541 * t.children = child.children; i.e., without copying the array. This 542 * is for construction and I'm not sure it's completely general for 543 * a tree's addChild method to work this way. Make sure you differentiate 544 * between your tree's addChild and this parser tree construction addChild 545 * if it's not ok to move children to t with a simple assignment. 546 */ 547static void 548addChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_BASE_TREE child) 549{ 550 if (t != NULL && child != NULL) 551 { 552 t->addChild(t, child); 553 } 554} 555static void 556dbgAddChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_BASE_TREE child) 557{ 558 if (t != NULL && child != NULL) 559 { 560 t->addChild(t, child); 561 adaptor->debugger->addChild(adaptor->debugger, t, child); 562 } 563} 564/** Use the adaptor implementation to add a child node with the supplied token 565 */ 566static void 567addChildToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN child) 568{ 569 if (t != NULL && child != NULL) 570 { 571 adaptor->addChild(adaptor, t, adaptor->create(adaptor, child)); 572 } 573} 574static void 575dbgAddChildToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN child) 576{ 577 pANTLR3_BASE_TREE tc; 578 579 if (t != NULL && child != NULL) 580 { 581 tc = adaptor->create(adaptor, child); 582 adaptor->addChild(adaptor, t, tc); 583 adaptor->debugger->addChild(adaptor->debugger, t, tc); 584 } 585} 586 587/** If oldRoot is a nil root, just copy or move the children to newRoot. 588 * If not a nil root, make oldRoot a child of newRoot. 589 * 590 * \code 591 * old=^(nil a b c), new=r yields ^(r a b c) 592 * old=^(a b c), new=r yields ^(r ^(a b c)) 593 * \endcode 594 * 595 * If newRoot is a nil-rooted single child tree, use the single 596 * child as the new root node. 597 * 598 * \code 599 * old=^(nil a b c), new=^(nil r) yields ^(r a b c) 600 * old=^(a b c), new=^(nil r) yields ^(r ^(a b c)) 601 * \endcode 602 * 603 * If oldRoot was null, it's ok, just return newRoot (even if isNilNode). 604 * 605 * \code 606 * old=null, new=r yields r 607 * old=null, new=^(nil r) yields ^(nil r) 608 * \endcode 609 * 610 * Return newRoot. Throw an exception if newRoot is not a 611 * simple node or nil root with a single child node--it must be a root 612 * node. If newRoot is <code>^(nil x)</endcode> return x as newRoot. 613 * 614 * Be advised that it's ok for newRoot to point at oldRoot's 615 * children; i.e., you don't have to copy the list. We are 616 * constructing these nodes so we should have this control for 617 * efficiency. 618 */ 619static pANTLR3_BASE_TREE 620becomeRoot (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE newRootTree, pANTLR3_BASE_TREE oldRootTree) 621{ 622 pANTLR3_BASE_TREE saveRoot; 623 624 /* Protect against tree rewrites if we are in some sort of error 625 * state, but have tried to recover. In C we can end up with a null pointer 626 * for a tree that was not produced. 627 */ 628 if (newRootTree == NULL) 629 { 630 return oldRootTree; 631 } 632 633 /* root is just the new tree as is if there is no 634 * current root tree. 635 */ 636 if (oldRootTree == NULL) 637 { 638 return newRootTree; 639 } 640 641 /* Produce ^(nil real-node) 642 */ 643 if (newRootTree->isNilNode(newRootTree)) 644 { 645 if (newRootTree->getChildCount(newRootTree) > 1) 646 { 647 /* TODO: Handle tree exceptions 648 */ 649 ANTLR3_FPRINTF(stderr, "More than one node as root! TODO: Create tree exception handling\n"); 650 return newRootTree; 651 } 652 653 /* The new root is the first child, keep track of the original newRoot 654 * because if it was a Nil Node, then we can reuse it now. 655 */ 656 saveRoot = newRootTree; 657 newRootTree = newRootTree->getChild(newRootTree, 0); 658 659 // Reclaim the old nilNode() 660 // 661 saveRoot->reuse(saveRoot); 662 } 663 664 /* Add old root into new root. addChild takes care of the case where oldRoot 665 * is a flat list (nill rooted tree). All children of oldroot are added to 666 * new root. 667 */ 668 newRootTree->addChild(newRootTree, oldRootTree); 669 670 // If the oldroot tree was a nil node, then we know at this point 671 // it has become orphaned by the rewrite logic, so we tell it to do 672 // whatever it needs to do to be reused. 673 // 674 if (oldRootTree->isNilNode(oldRootTree)) 675 { 676 // We have taken an old Root Tree and appended all its children to the new 677 // root. In addition though it was a nil node, which means the generated code 678 // will not reuse it again, so we will reclaim it here. First we want to zero out 679 // any pointers it was carrying around. We are just the baseTree handler so we 680 // don't know necessarilly know how to do this for the real node, we just ask the tree itself 681 // to do it. 682 // 683 oldRootTree->reuse(oldRootTree); 684 } 685 /* Always returns new root structure 686 */ 687 return newRootTree; 688 689} 690static pANTLR3_BASE_TREE 691dbgBecomeRoot (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE newRootTree, pANTLR3_BASE_TREE oldRootTree) 692{ 693 pANTLR3_BASE_TREE t; 694 695 t = becomeRoot(adaptor, newRootTree, oldRootTree); 696 697 adaptor->debugger->becomeRoot(adaptor->debugger, newRootTree, oldRootTree); 698 699 return t; 700} 701/** Transform ^(nil x) to x 702 */ 703static pANTLR3_BASE_TREE 704 rulePostProcessing (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE root) 705{ 706 pANTLR3_BASE_TREE saveRoot; 707 708 // Keep track of the root we are given. If it is a nilNode, then we 709 // can reuse it rather than orphaning it! 710 // 711 saveRoot = root; 712 713 if (root != NULL && root->isNilNode(root)) 714 { 715 if (root->getChildCount(root) == 0) 716 { 717 root = NULL; 718 } 719 else if (root->getChildCount(root) == 1) 720 { 721 root = root->getChild(root, 0); 722 root->setParent(root, NULL); 723 root->setChildIndex(root, -1); 724 725 // The root we were given was a nil node, wiht one child, which means it has 726 // been abandoned and would be lost in the node factory. However 727 // nodes can be flagged as resuable to prevent this terrible waste 728 // 729 saveRoot->reuse(saveRoot); 730 } 731 } 732 733 return root; 734} 735 736/** Use the adaptor interface to set a new tree node with the supplied token 737 * to the root of the tree. 738 */ 739static pANTLR3_BASE_TREE 740 becomeRootToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, void * newRoot, pANTLR3_BASE_TREE oldRoot) 741{ 742 return adaptor->becomeRoot(adaptor, adaptor->create(adaptor, newRoot), oldRoot); 743} 744static pANTLR3_BASE_TREE 745dbgBecomeRootToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, void * newRoot, pANTLR3_BASE_TREE oldRoot) 746{ 747 pANTLR3_BASE_TREE t; 748 749 t = adaptor->becomeRoot(adaptor, adaptor->create(adaptor, newRoot), oldRoot); 750 751 adaptor->debugger->becomeRoot(adaptor->debugger,t, oldRoot); 752 753 return t; 754} 755 756/** Use the super class supplied create() method to create a new node 757 * from the supplied token. 758 */ 759static pANTLR3_BASE_TREE 760createTypeToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken) 761{ 762 /* Create the new token 763 */ 764 fromToken = adaptor->createTokenFromToken(adaptor, fromToken); 765 766 /* Set the type of the new token to that supplied 767 */ 768 fromToken->setType(fromToken, tokenType); 769 770 /* Return a new node based upon this token 771 */ 772 return adaptor->create(adaptor, fromToken); 773} 774static pANTLR3_BASE_TREE 775dbgCreateTypeToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken) 776{ 777 pANTLR3_BASE_TREE t; 778 779 t = createTypeToken(adaptor, tokenType, fromToken); 780 781 adaptor->debugger->createNode(adaptor->debugger, t); 782 783 return t; 784} 785 786static pANTLR3_BASE_TREE 787createTypeTokenText (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken, pANTLR3_UINT8 text) 788{ 789 /* Create the new token 790 */ 791 fromToken = adaptor->createTokenFromToken(adaptor, fromToken); 792 793 /* Set the type of the new token to that supplied 794 */ 795 fromToken->setType(fromToken, tokenType); 796 797 /* Set the text of the token accordingly 798 */ 799 fromToken->setText8(fromToken, text); 800 801 /* Return a new node based upon this token 802 */ 803 return adaptor->create(adaptor, fromToken); 804} 805static pANTLR3_BASE_TREE 806dbgCreateTypeTokenText (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken, pANTLR3_UINT8 text) 807{ 808 pANTLR3_BASE_TREE t; 809 810 t = createTypeTokenText(adaptor, tokenType, fromToken, text); 811 812 adaptor->debugger->createNode(adaptor->debugger, t); 813 814 return t; 815} 816 817static pANTLR3_BASE_TREE 818 createTypeText (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_UINT8 text) 819{ 820 pANTLR3_COMMON_TOKEN fromToken; 821 822 /* Create the new token 823 */ 824 fromToken = adaptor->createToken(adaptor, tokenType, text); 825 826 /* Return a new node based upon this token 827 */ 828 return adaptor->create(adaptor, fromToken); 829} 830static pANTLR3_BASE_TREE 831 dbgCreateTypeText (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_UINT8 text) 832{ 833 pANTLR3_BASE_TREE t; 834 835 t = createTypeText(adaptor, tokenType, text); 836 837 adaptor->debugger->createNode(adaptor->debugger, t); 838 839 return t; 840 841} 842/** Dummy implementation - will be supplied by super class 843 */ 844static ANTLR3_UINT32 845 getType (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t) 846{ 847 return 0; 848} 849 850/** Dummy implementation - will be supplied by super class 851 */ 852static void 853 setType (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 type) 854{ 855 ANTLR3_FPRINTF(stderr, "Internal error - implementor of superclass containing ANTLR3_TREE_ADAPTOR did not implement setType()\n"); 856} 857 858/** Dummy implementation - will be supplied by super class 859 */ 860static pANTLR3_STRING 861 getText (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t) 862{ 863 ANTLR3_FPRINTF(stderr, "Internal error - implementor of superclass containing ANTLR3_TREE_ADAPTOR did not implement getText()\n"); 864 return NULL; 865} 866 867/** Dummy implementation - will be supplied by super class 868 */ 869static void 870 setText (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_STRING t) 871{ 872 ANTLR3_FPRINTF(stderr, "Internal error - implementor of superclass containing ANTLR3_TREE_ADAPTOR did not implement setText()\n"); 873} 874/** Dummy implementation - will be supplied by super class 875 */ 876static void 877setText8 (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_UINT8 t) 878{ 879 ANTLR3_FPRINTF(stderr, "Internal error - implementor of superclass containing ANTLR3_TREE_ADAPTOR did not implement setText()\n"); 880} 881 882static pANTLR3_BASE_TREE 883 getChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE tree, ANTLR3_UINT32 i) 884{ 885 ANTLR3_FPRINTF(stderr, "Internal error - implementor of superclass containing ANTLR3_TREE_ADAPTOR did not implement getChild()\n"); 886 return NULL; 887} 888 889static ANTLR3_UINT32 890 getChildCount (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE tree) 891{ 892 ANTLR3_FPRINTF(stderr, "Internal error - implementor of superclass containing ANTLR3_TREE_ADAPTOR did not implement getChildCount()\n"); 893 return 0; 894} 895 896/** Returns a uniqueID for the node. Because this is the C implementation 897 * we can just use its address suitably converted/cast to an integer. 898 */ 899static ANTLR3_UINT32 900 getUniqueID (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE node) 901{ 902 return ANTLR3_UINT32_CAST(node); 903} 904 905static ANTLR3_BOOLEAN 906isNilNode (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t) 907{ 908 return t->isNilNode(t); 909} 910