Move antlr. Add `make test` to Makefile.

1 files changed, 909 insertions, 0 deletions

diff --git a/antlr/libantlr3c-3.4/src/antlr3basetreeadaptor.c b/antlr/libantlr3c-3.4/src/antlr3basetreeadaptor.c
new file mode 100644
index 0000000..e35878f
--- /dev/null
+++ b/antlr/libantlr3c-3.4/src/antlr3basetreeadaptor.c
@@ -0,0 +1,909 @@
+/** \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);
+}