| /** \file |
| * Contains the base functions that all tree adaptors start with. |
| * this implementation can then be overridden by any higher implementation. |
| * |
| */ |
| |
| // [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 <antlr3basetreeadaptor.h> |
| |
| #ifdef ANTLR3_WINDOWS |
| #pragma warning( disable : 4100 ) |
| #endif |
| |
| /* Interface functions |
| */ |
| static pANTLR3_BASE_TREE nilNode (pANTLR3_BASE_TREE_ADAPTOR adaptor); |
| static pANTLR3_BASE_TREE dbgNil (pANTLR3_BASE_TREE_ADAPTOR adaptor); |
| static pANTLR3_BASE_TREE dupTree (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t); |
| static pANTLR3_BASE_TREE dbgDupTree (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t); |
| static pANTLR3_BASE_TREE dupTreeTT (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_BASE_TREE parent); |
| static void addChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_BASE_TREE child); |
| static void dbgAddChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_BASE_TREE child); |
| static pANTLR3_BASE_TREE becomeRoot (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE newRoot, pANTLR3_BASE_TREE oldRoot); |
| static pANTLR3_BASE_TREE dbgBecomeRoot (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE newRoot, pANTLR3_BASE_TREE oldRoot); |
| static pANTLR3_BASE_TREE rulePostProcessing (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE root); |
| static void addChildToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN child); |
| static void dbgAddChildToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN child); |
| static pANTLR3_BASE_TREE becomeRootToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, void * newRoot, pANTLR3_BASE_TREE oldRoot); |
| static pANTLR3_BASE_TREE dbgBecomeRootToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, void * newRoot, pANTLR3_BASE_TREE oldRoot); |
| static pANTLR3_BASE_TREE createTypeToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken); |
| static pANTLR3_BASE_TREE dbgCreateTypeToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken); |
| static pANTLR3_BASE_TREE createTypeTokenText (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken, pANTLR3_UINT8 text); |
| static pANTLR3_BASE_TREE dbgCreateTypeTokenText (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken, pANTLR3_UINT8 text); |
| static pANTLR3_BASE_TREE createTypeText (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_UINT8 text); |
| static pANTLR3_BASE_TREE dbgCreateTypeText (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_UINT8 text); |
| static ANTLR3_UINT32 getType (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t); |
| static void setType (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 type); |
| static pANTLR3_STRING getText (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t); |
| static void setText (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_STRING t); |
| static void setText8 (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_UINT8 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 ANTLR3_UINT32 getUniqueID (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t); |
| static ANTLR3_BOOLEAN isNilNode (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t); |
| static pANTLR3_STRING makeDot (pANTLR3_BASE_TREE_ADAPTOR adaptor, void * theTree); |
| |
| /** Given a pointer to a base tree adaptor structure (which is usually embedded in the |
| * super class the implements the tree adaptor used in the parse), initialize its |
| * function pointers and so on. |
| */ |
| ANTLR3_API void |
| antlr3BaseTreeAdaptorInit(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_DEBUG_EVENT_LISTENER debugger) |
| { |
| // Initialize the interface |
| // |
| if (debugger == NULL) |
| { |
| adaptor->nilNode = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR)) |
| nilNode; |
| adaptor->addChild = (void (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, void *)) |
| addChild; |
| adaptor->becomeRoot = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, void *)) |
| becomeRoot; |
| adaptor->addChildToken = (void (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, pANTLR3_COMMON_TOKEN)) |
| addChildToken; |
| adaptor->becomeRootToken = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, void *)) |
| becomeRootToken; |
| adaptor->createTypeToken = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, ANTLR3_UINT32, pANTLR3_COMMON_TOKEN)) |
| createTypeToken; |
| adaptor->createTypeTokenText = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, ANTLR3_UINT32, pANTLR3_COMMON_TOKEN, pANTLR3_UINT8)) |
| createTypeTokenText; |
| adaptor->createTypeText = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, ANTLR3_UINT32, pANTLR3_UINT8)) |
| createTypeText; |
| adaptor->dupTree = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *)) |
| dupTree; |
| } |
| else |
| { |
| adaptor->nilNode = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR)) |
| dbgNil; |
| adaptor->addChild = (void (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, void *)) |
| dbgAddChild; |
| adaptor->becomeRoot = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, void *)) |
| dbgBecomeRoot; |
| adaptor->addChildToken = (void (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, pANTLR3_COMMON_TOKEN)) |
| dbgAddChildToken; |
| adaptor->becomeRootToken = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, void *)) |
| dbgBecomeRootToken; |
| adaptor->createTypeToken = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, ANTLR3_UINT32, pANTLR3_COMMON_TOKEN)) |
| dbgCreateTypeToken; |
| adaptor->createTypeTokenText = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, ANTLR3_UINT32, pANTLR3_COMMON_TOKEN, pANTLR3_UINT8)) |
| dbgCreateTypeTokenText; |
| adaptor->createTypeText = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, ANTLR3_UINT32, pANTLR3_UINT8)) |
| dbgCreateTypeText; |
| adaptor->dupTree = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *)) |
| dbgDupTree; |
| debugger->adaptor = adaptor; |
| } |
| |
| adaptor->dupTreeTT = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, void *)) |
| dupTreeTT; |
| adaptor->rulePostProcessing = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *)) |
| rulePostProcessing; |
| adaptor->getType = (ANTLR3_UINT32 (*)(pANTLR3_BASE_TREE_ADAPTOR, void *)) |
| getType; |
| adaptor->setType = (void (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_UINT32)) |
| setType; |
| adaptor->getText = (pANTLR3_STRING (*) (pANTLR3_BASE_TREE_ADAPTOR, void *)) |
| getText; |
| adaptor->setText8 = (void (*)(pANTLR3_BASE_TREE_ADAPTOR, pANTLR3_UINT8)) |
| setText8; |
| adaptor->setText = (void (*)(pANTLR3_BASE_TREE_ADAPTOR, pANTLR3_STRING)) |
| setText; |
| adaptor->getChild = (void * (*)(pANTLR3_BASE_TREE_ADAPTOR, void *, ANTLR3_UINT32)) |
| getChild; |
| adaptor->getChildCount = (ANTLR3_UINT32 (*)(pANTLR3_BASE_TREE_ADAPTOR, void *)) |
| getChildCount; |
| adaptor->getUniqueID = (ANTLR3_UINT32 (*)(pANTLR3_BASE_TREE_ADAPTOR, void *)) |
| getUniqueID; |
| adaptor->isNilNode = (ANTLR3_BOOLEAN (*)(pANTLR3_BASE_TREE_ADAPTOR, void *)) |
| isNilNode; |
| |
| adaptor->makeDot = (pANTLR3_STRING (*)(pANTLR3_BASE_TREE_ADAPTOR, void *)) |
| makeDot; |
| |
| /* Remaining functions filled in by the caller. |
| */ |
| return; |
| } |
| |
| static void |
| defineDotNodes(pANTLR3_BASE_TREE_ADAPTOR adaptor, void * t, pANTLR3_STRING dotSpec ) |
| { |
| // How many nodes are we talking about? |
| // |
| int nCount; |
| int i; |
| pANTLR3_BASE_TREE child; |
| char buff[64]; |
| pANTLR3_STRING text; |
| int j; |
| |
| |
| |
| |
| |
| // Count the nodes |
| // |
| nCount = adaptor->getChildCount(adaptor, t); |
| |
| if (nCount == 0) |
| { |
| // This will already have been included as a child of another node |
| // so there is nothing to add. |
| // |
| return; |
| } |
| |
| // For each child of the current tree, define a node using the |
| // memory address of the node to name it |
| // |
| for (i = 0; i<nCount; i++) |
| { |
| |
| // Pick up a pointer for the child |
| // |
| child = adaptor->getChild(adaptor, t, i); |
| |
| // Name the node |
| // |
| sprintf(buff, "\tn%p[label=\"", child); |
| dotSpec->append8(dotSpec, buff); |
| text = adaptor->getText(adaptor, child); |
| for (j = 0; j < (ANTLR3_INT32)(text->len); j++) |
| { |
| switch(text->charAt(text, j)) |
| { |
| case '"': |
| |
| dotSpec->append8(dotSpec, "\\\""); |
| break; |
| |
| case '\n': |
| |
| dotSpec->append8(dotSpec, "\\n"); |
| break; |
| |
| case '\r': |
| |
| dotSpec->append8(dotSpec, "\\r"); |
| break; |
| |
| default: |
| |
| dotSpec->addc(dotSpec, text->charAt(text, j)); |
| break; |
| } |
| } |
| dotSpec->append8(dotSpec, "\"]\n"); |
| |
| // And now define the children of this child (if any) |
| // |
| defineDotNodes(adaptor, child, dotSpec); |
| } |
| |
| // Done |
| // |
| return; |
| } |
| |
| static void |
| defineDotEdges(pANTLR3_BASE_TREE_ADAPTOR adaptor, void * t, pANTLR3_STRING dotSpec) |
| { |
| // How many nodes are we talking about? |
| // |
| int nCount; |
| int i; |
| |
| if (t == NULL) |
| { |
| // No tree, so do nothing |
| // |
| return; |
| } |
| |
| // Count the nodes |
| // |
| nCount = adaptor->getChildCount(adaptor, t); |
| |
| if (nCount == 0) |
| { |
| // This will already have been included as a child of another node |
| // so there is nothing to add. |
| // |
| return; |
| } |
| |
| // For each child, define an edge from this parent, then process |
| // and children of this child in the same way |
| // |
| for (i=0; i<nCount; i++) |
| { |
| pANTLR3_BASE_TREE child; |
| char buff[128]; |
| pANTLR3_STRING text; |
| int j; |
| |
| // Next child |
| // |
| child = adaptor->getChild(adaptor, t, i); |
| |
| // Create the edge relation |
| // |
| sprintf(buff, "\t\tn%p -> n%p\t\t// ", t, child); |
| |
| dotSpec->append8(dotSpec, buff); |
| |
| // Document the relationship |
| // |
| text = adaptor->getText(adaptor, t); |
| for (j = 0; j < (ANTLR3_INT32)(text->len); j++) |
| { |
| switch(text->charAt(text, j)) |
| { |
| case '"': |
| |
| dotSpec->append8(dotSpec, "\\\""); |
| break; |
| |
| case '\n': |
| |
| dotSpec->append8(dotSpec, "\\n"); |
| break; |
| |
| case '\r': |
| |
| dotSpec->append8(dotSpec, "\\r"); |
| break; |
| |
| default: |
| |
| dotSpec->addc(dotSpec, text->charAt(text, j)); |
| break; |
| } |
| } |
| |
| dotSpec->append8(dotSpec, " -> "); |
| |
| text = adaptor->getText(adaptor, child); |
| for (j = 0; j < (ANTLR3_INT32)(text->len); j++) |
| { |
| switch(text->charAt(text, j)) |
| { |
| case '"': |
| |
| dotSpec->append8(dotSpec, "\\\""); |
| break; |
| |
| case '\n': |
| |
| dotSpec->append8(dotSpec, "\\n"); |
| break; |
| |
| case '\r': |
| |
| dotSpec->append8(dotSpec, "\\r"); |
| break; |
| |
| default: |
| |
| dotSpec->addc(dotSpec, text->charAt(text, j)); |
| break; |
| } |
| } |
| dotSpec->append8(dotSpec, "\n"); |
| |
| |
| // Define edges for this child |
| // |
| defineDotEdges(adaptor, child, dotSpec); |
| } |
| |
| // Done |
| // |
| return; |
| } |
| |
| /// Produce a DOT specification for graphviz |
| // |
| static pANTLR3_STRING |
| makeDot (pANTLR3_BASE_TREE_ADAPTOR adaptor, void * theTree) |
| { |
| // The string we are building up |
| // |
| pANTLR3_STRING dotSpec; |
| char buff[64]; |
| pANTLR3_STRING text; |
| int j; |
| |
| dotSpec = adaptor->strFactory->newStr8 |
| |
| ( |
| adaptor->strFactory, |
| |
| // Default look and feel |
| // |
| (pANTLR3_UINT8) |
| "digraph {\n\n" |
| "\tordering=out;\n" |
| "\tranksep=.4;\n" |
| "\tbgcolor=\"lightgrey\"; node [shape=box, fixedsize=false, fontsize=12, fontname=\"Helvetica-bold\", fontcolor=\"blue\"\n" |
| "\twidth=.25, height=.25, color=\"black\", fillcolor=\"white\", style=\"filled, solid, bold\"];\n\n" |
| "\tedge [arrowsize=.5, color=\"black\", style=\"bold\"]\n\n" |
| ); |
| |
| if (theTree == NULL) |
| { |
| // No tree, so create a blank spec |
| // |
| dotSpec->append8(dotSpec, "n0[label=\"EMPTY TREE\"]\n"); |
| return dotSpec; |
| } |
| |
| sprintf(buff, "\tn%p[label=\"", theTree); |
| dotSpec->append8(dotSpec, buff); |
| text = adaptor->getText(adaptor, theTree); |
| for (j = 0; j < (ANTLR3_INT32)(text->len); j++) |
| { |
| switch(text->charAt(text, j)) |
| { |
| case '"': |
| |
| dotSpec->append8(dotSpec, "\\\""); |
| break; |
| |
| case '\n': |
| |
| dotSpec->append8(dotSpec, "\\n"); |
| break; |
| |
| case '\r': |
| |
| dotSpec->append8(dotSpec, "\\r"); |
| break; |
| |
| default: |
| |
| dotSpec->addc(dotSpec, text->charAt(text, j)); |
| break; |
| } |
| } |
| dotSpec->append8(dotSpec, "\"]\n"); |
| |
| // First produce the node defintions |
| // |
| defineDotNodes(adaptor, theTree, dotSpec); |
| dotSpec->append8(dotSpec, "\n"); |
| defineDotEdges(adaptor, theTree, dotSpec); |
| |
| // Terminate the spec |
| // |
| dotSpec->append8(dotSpec, "\n}"); |
| |
| // Result |
| // |
| return dotSpec; |
| } |
| |
| |
| /** Create and return a nil tree node (no token payload) |
| */ |
| static pANTLR3_BASE_TREE |
| nilNode (pANTLR3_BASE_TREE_ADAPTOR adaptor) |
| { |
| return adaptor->create(adaptor, NULL); |
| } |
| |
| static pANTLR3_BASE_TREE |
| dbgNil (pANTLR3_BASE_TREE_ADAPTOR adaptor) |
| { |
| pANTLR3_BASE_TREE t; |
| |
| t = adaptor->create (adaptor, NULL); |
| adaptor->debugger->createNode (adaptor->debugger, t); |
| |
| return t; |
| } |
| |
| /** Return a duplicate of the entire tree (implementation provided by the |
| * BASE_TREE interface.) |
| */ |
| static pANTLR3_BASE_TREE |
| dupTree (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t) |
| { |
| return adaptor->dupTreeTT(adaptor, t, NULL); |
| } |
| |
| pANTLR3_BASE_TREE |
| dupTreeTT (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_BASE_TREE parent) |
| { |
| pANTLR3_BASE_TREE newTree; |
| pANTLR3_BASE_TREE child; |
| pANTLR3_BASE_TREE newSubTree; |
| ANTLR3_UINT32 n; |
| ANTLR3_UINT32 i; |
| |
| if (t == NULL) |
| { |
| return NULL; |
| } |
| newTree = t->dupNode(t); |
| |
| // Ensure new subtree root has parent/child index set |
| // |
| adaptor->setChildIndex (adaptor, newTree, t->getChildIndex(t)); |
| adaptor->setParent (adaptor, newTree, parent); |
| n = adaptor->getChildCount (adaptor, t); |
| |
| for (i=0; i < n; i++) |
| { |
| child = adaptor->getChild (adaptor, t, i); |
| newSubTree = adaptor->dupTreeTT (adaptor, child, t); |
| adaptor->addChild (adaptor, newTree, newSubTree); |
| } |
| return newTree; |
| } |
| |
| /// Sends the required debugging events for duplicating a tree |
| /// to the debugger. |
| /// |
| static void |
| simulateTreeConstruction(pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE tree) |
| { |
| ANTLR3_UINT32 n; |
| ANTLR3_UINT32 i; |
| pANTLR3_BASE_TREE child; |
| |
| // Send the create node event |
| // |
| adaptor->debugger->createNode(adaptor->debugger, tree); |
| |
| n = adaptor->getChildCount(adaptor, tree); |
| for (i = 0; i < n; i++) |
| { |
| child = adaptor->getChild(adaptor, tree, i); |
| simulateTreeConstruction(adaptor, child); |
| adaptor->debugger->addChild(adaptor->debugger, tree, child); |
| } |
| } |
| |
| pANTLR3_BASE_TREE |
| dbgDupTree (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE tree) |
| { |
| pANTLR3_BASE_TREE t; |
| |
| // Call the normal dup tree mechanism first |
| // |
| t = adaptor->dupTreeTT(adaptor, tree, NULL); |
| |
| // In order to tell the debugger what we have just done, we now |
| // simulate the tree building mechanism. THis will fire |
| // lots of debugging events to the client and look like we |
| // duped the tree.. |
| // |
| simulateTreeConstruction(adaptor, t); |
| |
| return t; |
| } |
| |
| /** Add a child to the tree t. If child is a flat tree (a list), make all |
| * in list children of t. Warning: if t has no children, but child does |
| * and child isNilNode then it is ok to move children to t via |
| * t.children = child.children; i.e., without copying the array. This |
| * is for construction and I'm not sure it's completely general for |
| * a tree's addChild method to work this way. Make sure you differentiate |
| * between your tree's addChild and this parser tree construction addChild |
| * if it's not ok to move children to t with a simple assignment. |
| */ |
| static void |
| addChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_BASE_TREE child) |
| { |
| if (t != NULL && child != NULL) |
| { |
| t->addChild(t, child); |
| } |
| } |
| static void |
| dbgAddChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_BASE_TREE child) |
| { |
| if (t != NULL && child != NULL) |
| { |
| t->addChild(t, child); |
| adaptor->debugger->addChild(adaptor->debugger, t, child); |
| } |
| } |
| /** Use the adaptor implementation to add a child node with the supplied token |
| */ |
| static void |
| addChildToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN child) |
| { |
| if (t != NULL && child != NULL) |
| { |
| adaptor->addChild(adaptor, t, adaptor->create(adaptor, child)); |
| } |
| } |
| static void |
| dbgAddChildToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, pANTLR3_COMMON_TOKEN child) |
| { |
| pANTLR3_BASE_TREE tc; |
| |
| if (t != NULL && child != NULL) |
| { |
| tc = adaptor->create(adaptor, child); |
| adaptor->addChild(adaptor, t, tc); |
| adaptor->debugger->addChild(adaptor->debugger, t, tc); |
| } |
| } |
| |
| /** If oldRoot is a nil root, just copy or move the children to newRoot. |
| * If not a nil root, make oldRoot a child of newRoot. |
| * |
| * \code |
| * old=^(nil a b c), new=r yields ^(r a b c) |
| * old=^(a b c), new=r yields ^(r ^(a b c)) |
| * \endcode |
| * |
| * If newRoot is a nil-rooted single child tree, use the single |
| * child as the new root node. |
| * |
| * \code |
| * old=^(nil a b c), new=^(nil r) yields ^(r a b c) |
| * old=^(a b c), new=^(nil r) yields ^(r ^(a b c)) |
| * \endcode |
| * |
| * If oldRoot was null, it's ok, just return newRoot (even if isNilNode). |
| * |
| * \code |
| * old=null, new=r yields r |
| * old=null, new=^(nil r) yields ^(nil r) |
| * \endcode |
| * |
| * Return newRoot. Throw an exception if newRoot is not a |
| * simple node or nil root with a single child node--it must be a root |
| * node. If newRoot is <code>^(nil x)</endcode> return x as newRoot. |
| * |
| * Be advised that it's ok for newRoot to point at oldRoot's |
| * children; i.e., you don't have to copy the list. We are |
| * constructing these nodes so we should have this control for |
| * efficiency. |
| */ |
| static pANTLR3_BASE_TREE |
| becomeRoot (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE newRootTree, pANTLR3_BASE_TREE oldRootTree) |
| { |
| pANTLR3_BASE_TREE saveRoot; |
| |
| /* Protect against tree rewrites if we are in some sort of error |
| * state, but have tried to recover. In C we can end up with a null pointer |
| * for a tree that was not produced. |
| */ |
| if (newRootTree == NULL) |
| { |
| return oldRootTree; |
| } |
| |
| /* root is just the new tree as is if there is no |
| * current root tree. |
| */ |
| if (oldRootTree == NULL) |
| { |
| return newRootTree; |
| } |
| |
| /* Produce ^(nil real-node) |
| */ |
| if (newRootTree->isNilNode(newRootTree)) |
| { |
| if (newRootTree->getChildCount(newRootTree) > 1) |
| { |
| /* TODO: Handle tree exceptions |
| */ |
| ANTLR3_FPRINTF(stderr, "More than one node as root! TODO: Create tree exception handling\n"); |
| return newRootTree; |
| } |
| |
| /* The new root is the first child, keep track of the original newRoot |
| * because if it was a Nil Node, then we can reuse it now. |
| */ |
| saveRoot = newRootTree; |
| newRootTree = newRootTree->getChild(newRootTree, 0); |
| |
| // Reclaim the old nilNode() |
| // |
| saveRoot->reuse(saveRoot); |
| } |
| |
| /* Add old root into new root. addChild takes care of the case where oldRoot |
| * is a flat list (nill rooted tree). All children of oldroot are added to |
| * new root. |
| */ |
| newRootTree->addChild(newRootTree, oldRootTree); |
| |
| // If the oldroot tree was a nil node, then we know at this point |
| // it has become orphaned by the rewrite logic, so we tell it to do |
| // whatever it needs to do to be reused. |
| // |
| if (oldRootTree->isNilNode(oldRootTree)) |
| { |
| // We have taken an old Root Tree and appended all its children to the new |
| // root. In addition though it was a nil node, which means the generated code |
| // will not reuse it again, so we will reclaim it here. First we want to zero out |
| // any pointers it was carrying around. We are just the baseTree handler so we |
| // don't know necessarilly know how to do this for the real node, we just ask the tree itself |
| // to do it. |
| // |
| oldRootTree->reuse(oldRootTree); |
| } |
| /* Always returns new root structure |
| */ |
| return newRootTree; |
| |
| } |
| static pANTLR3_BASE_TREE |
| dbgBecomeRoot (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE newRootTree, pANTLR3_BASE_TREE oldRootTree) |
| { |
| pANTLR3_BASE_TREE t; |
| |
| t = becomeRoot(adaptor, newRootTree, oldRootTree); |
| |
| adaptor->debugger->becomeRoot(adaptor->debugger, newRootTree, oldRootTree); |
| |
| return t; |
| } |
| /** Transform ^(nil x) to x |
| */ |
| static pANTLR3_BASE_TREE |
| rulePostProcessing (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE root) |
| { |
| pANTLR3_BASE_TREE saveRoot; |
| |
| // Keep track of the root we are given. If it is a nilNode, then we |
| // can reuse it rather than orphaning it! |
| // |
| saveRoot = root; |
| |
| if (root != NULL && root->isNilNode(root)) |
| { |
| if (root->getChildCount(root) == 0) |
| { |
| root = NULL; |
| } |
| else if (root->getChildCount(root) == 1) |
| { |
| root = root->getChild(root, 0); |
| root->setParent(root, NULL); |
| root->setChildIndex(root, -1); |
| |
| // The root we were given was a nil node, wiht one child, which means it has |
| // been abandoned and would be lost in the node factory. However |
| // nodes can be flagged as resuable to prevent this terrible waste |
| // |
| saveRoot->reuse(saveRoot); |
| } |
| } |
| |
| return root; |
| } |
| |
| /** Use the adaptor interface to set a new tree node with the supplied token |
| * to the root of the tree. |
| */ |
| static pANTLR3_BASE_TREE |
| becomeRootToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, void * newRoot, pANTLR3_BASE_TREE oldRoot) |
| { |
| return adaptor->becomeRoot(adaptor, adaptor->create(adaptor, newRoot), oldRoot); |
| } |
| static pANTLR3_BASE_TREE |
| dbgBecomeRootToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, void * newRoot, pANTLR3_BASE_TREE oldRoot) |
| { |
| pANTLR3_BASE_TREE t; |
| |
| t = adaptor->becomeRoot(adaptor, adaptor->create(adaptor, newRoot), oldRoot); |
| |
| adaptor->debugger->becomeRoot(adaptor->debugger,t, oldRoot); |
| |
| return t; |
| } |
| |
| /** Use the super class supplied create() method to create a new node |
| * from the supplied token. |
| */ |
| static pANTLR3_BASE_TREE |
| createTypeToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken) |
| { |
| /* Create the new token |
| */ |
| fromToken = adaptor->createTokenFromToken(adaptor, fromToken); |
| |
| /* Set the type of the new token to that supplied |
| */ |
| fromToken->setType(fromToken, tokenType); |
| |
| /* Return a new node based upon this token |
| */ |
| return adaptor->create(adaptor, fromToken); |
| } |
| static pANTLR3_BASE_TREE |
| dbgCreateTypeToken (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken) |
| { |
| pANTLR3_BASE_TREE t; |
| |
| t = createTypeToken(adaptor, tokenType, fromToken); |
| |
| adaptor->debugger->createNode(adaptor->debugger, t); |
| |
| return t; |
| } |
| |
| static pANTLR3_BASE_TREE |
| createTypeTokenText (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken, pANTLR3_UINT8 text) |
| { |
| /* Create the new token |
| */ |
| fromToken = adaptor->createTokenFromToken(adaptor, fromToken); |
| |
| /* Set the type of the new token to that supplied |
| */ |
| fromToken->setType(fromToken, tokenType); |
| |
| /* Set the text of the token accordingly |
| */ |
| fromToken->setText8(fromToken, text); |
| |
| /* Return a new node based upon this token |
| */ |
| return adaptor->create(adaptor, fromToken); |
| } |
| static pANTLR3_BASE_TREE |
| dbgCreateTypeTokenText (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_COMMON_TOKEN fromToken, pANTLR3_UINT8 text) |
| { |
| pANTLR3_BASE_TREE t; |
| |
| t = createTypeTokenText(adaptor, tokenType, fromToken, text); |
| |
| adaptor->debugger->createNode(adaptor->debugger, t); |
| |
| return t; |
| } |
| |
| static pANTLR3_BASE_TREE |
| createTypeText (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_UINT8 text) |
| { |
| pANTLR3_COMMON_TOKEN fromToken; |
| |
| /* Create the new token |
| */ |
| fromToken = adaptor->createToken(adaptor, tokenType, text); |
| |
| /* Return a new node based upon this token |
| */ |
| return adaptor->create(adaptor, fromToken); |
| } |
| static pANTLR3_BASE_TREE |
| dbgCreateTypeText (pANTLR3_BASE_TREE_ADAPTOR adaptor, ANTLR3_UINT32 tokenType, pANTLR3_UINT8 text) |
| { |
| pANTLR3_BASE_TREE t; |
| |
| t = createTypeText(adaptor, tokenType, text); |
| |
| adaptor->debugger->createNode(adaptor->debugger, t); |
| |
| return t; |
| |
| } |
| /** Dummy implementation - will be supplied by super class |
| */ |
| static ANTLR3_UINT32 |
| getType (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t) |
| { |
| return 0; |
| } |
| |
| /** Dummy implementation - will be supplied by super class |
| */ |
| static void |
| setType (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t, ANTLR3_UINT32 type) |
| { |
| ANTLR3_FPRINTF(stderr, "Internal error - implementor of superclass containing ANTLR3_TREE_ADAPTOR did not implement setType()\n"); |
| } |
| |
| /** Dummy implementation - will be supplied by super class |
| */ |
| static pANTLR3_STRING |
| getText (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t) |
| { |
| ANTLR3_FPRINTF(stderr, "Internal error - implementor of superclass containing ANTLR3_TREE_ADAPTOR did not implement getText()\n"); |
| return NULL; |
| } |
| |
| /** Dummy implementation - will be supplied by super class |
| */ |
| static void |
| setText (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_STRING t) |
| { |
| ANTLR3_FPRINTF(stderr, "Internal error - implementor of superclass containing ANTLR3_TREE_ADAPTOR did not implement setText()\n"); |
| } |
| /** Dummy implementation - will be supplied by super class |
| */ |
| static void |
| setText8 (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_UINT8 t) |
| { |
| ANTLR3_FPRINTF(stderr, "Internal error - implementor of superclass containing ANTLR3_TREE_ADAPTOR did not implement setText()\n"); |
| } |
| |
| static pANTLR3_BASE_TREE |
| getChild (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE tree, ANTLR3_UINT32 i) |
| { |
| ANTLR3_FPRINTF(stderr, "Internal error - implementor of superclass containing ANTLR3_TREE_ADAPTOR did not implement getChild()\n"); |
| return NULL; |
| } |
| |
| static ANTLR3_UINT32 |
| getChildCount (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE tree) |
| { |
| ANTLR3_FPRINTF(stderr, "Internal error - implementor of superclass containing ANTLR3_TREE_ADAPTOR did not implement getChildCount()\n"); |
| return 0; |
| } |
| |
| /** Returns a uniqueID for the node. Because this is the C implementation |
| * we can just use its address suitably converted/cast to an integer. |
| */ |
| static ANTLR3_UINT32 |
| getUniqueID (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE node) |
| { |
| return ANTLR3_UINT32_CAST(node); |
| } |
| |
| static ANTLR3_BOOLEAN |
| isNilNode (pANTLR3_BASE_TREE_ADAPTOR adaptor, pANTLR3_BASE_TREE t) |
| { |
| return t->isNilNode(t); |
| } |
