X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.databoard%2Fcpp%2FDataBoardTest%2Flibantlr3c-3.2%2Fsrc%2Fantlr3commontree.c;fp=bundles%2Forg.simantics.databoard%2Fcpp%2FDataBoardTest%2Flibantlr3c-3.2%2Fsrc%2Fantlr3commontree.c;h=b600314d9b1a633e6111463df63130a47831fed1;hb=969bd23cab98a79ca9101af33334000879fb60c5;hp=0000000000000000000000000000000000000000;hpb=866dba5cd5a3929bbeae85991796acb212338a08;p=simantics%2Fplatform.git

diff --git a/bundles/org.simantics.databoard/cpp/DataBoardTest/libantlr3c-3.2/src/antlr3commontree.c b/bundles/org.simantics.databoard/cpp/DataBoardTest/libantlr3c-3.2/src/antlr3commontree.c
new file mode 100644
index 000000000..b600314d9
--- /dev/null
+++ b/bundles/org.simantics.databoard/cpp/DataBoardTest/libantlr3c-3.2/src/antlr3commontree.c
@@ -0,0 +1,545 @@
+// \file
+//
+// Implementation of ANTLR3 CommonTree, which you can use as a
+// starting point for your own tree. Though it is often easier just to tag things on
+// to the user pointer in the tree unless you are building a different type
+// of structure.
+//
+
+// [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    <antlr3commontree.h>
+
+
+static pANTLR3_COMMON_TOKEN getToken				(pANTLR3_BASE_TREE tree);
+static pANTLR3_BASE_TREE    dupNode					(pANTLR3_BASE_TREE tree);
+static ANTLR3_BOOLEAN	    isNilNode					(pANTLR3_BASE_TREE tree);
+static ANTLR3_UINT32	    getType					(pANTLR3_BASE_TREE tree);
+static pANTLR3_STRING	    getText					(pANTLR3_BASE_TREE tree);
+static ANTLR3_UINT32	    getLine					(pANTLR3_BASE_TREE tree);
+static ANTLR3_UINT32	    getCharPositionInLine	(pANTLR3_BASE_TREE tree);
+static pANTLR3_STRING	    toString				(pANTLR3_BASE_TREE tree);
+static pANTLR3_BASE_TREE	getParent				(pANTLR3_BASE_TREE tree);
+static void					setParent				(pANTLR3_BASE_TREE tree, pANTLR3_BASE_TREE parent);
+static void    				setChildIndex			(pANTLR3_BASE_TREE tree, ANTLR3_INT32 i);
+static ANTLR3_INT32			getChildIndex			(pANTLR3_BASE_TREE tree);
+static void					createChildrenList		(pANTLR3_BASE_TREE tree);
+static void                 reuse                   (pANTLR3_BASE_TREE tree);
+
+// Factory functions for the Arboretum
+//
+static void					newPool				(pANTLR3_ARBORETUM factory);
+static pANTLR3_BASE_TREE    newPoolTree			(pANTLR3_ARBORETUM factory);
+static pANTLR3_BASE_TREE    newFromTree			(pANTLR3_ARBORETUM factory, pANTLR3_COMMON_TREE tree);
+static pANTLR3_BASE_TREE    newFromToken		(pANTLR3_ARBORETUM factory, pANTLR3_COMMON_TOKEN token);
+static void					factoryClose		(pANTLR3_ARBORETUM factory);
+
+ANTLR3_API pANTLR3_ARBORETUM
+antlr3ArboretumNew(pANTLR3_STRING_FACTORY strFactory)
+{
+    pANTLR3_ARBORETUM   factory;
+
+    // Allocate memory
+    //
+    factory	= (pANTLR3_ARBORETUM) ANTLR3_MALLOC((size_t)sizeof(ANTLR3_ARBORETUM));
+    if	(factory == NULL)
+    {
+		return	NULL;
+    }
+
+	// Install a vector factory to create, track and free() any child
+	// node lists.
+	//
+	factory->vFactory					= antlr3VectorFactoryNew(0);
+	if	(factory->vFactory == NULL)
+	{
+		free(factory);
+		return	NULL;
+	}
+
+    // We also keep a reclaim stack, so that any Nil nodes that are
+    // orphaned are not just left in the pool but are reused, other wise
+    // we create 6 times as many nilNodes as ordinary nodes and use loads of
+    // memory. Perhaps at some point, the analysis phase will generate better
+    // code and we won't need to do this here.
+    //
+    factory->nilStack       =  antlr3StackNew(0);
+
+    // Install factory API
+    //
+    factory->newTree	    =  newPoolTree;
+    factory->newFromTree    =  newFromTree;
+    factory->newFromToken   =  newFromToken;
+    factory->close			=  factoryClose;
+
+    // Allocate the initial pool
+    //
+    factory->thisPool	= -1;
+    factory->pools		= NULL;
+    newPool(factory);
+
+    // Factory space is good, we now want to initialize our cheating token
+    // which one it is initialized is the model for all tokens we manufacture
+    //
+    antlr3SetCTAPI(&factory->unTruc);
+
+    // Set some initial variables for future copying, including a string factory
+    // that we can use later for converting trees to strings.
+    //
+	factory->unTruc.factory				= factory;
+    factory->unTruc.baseTree.strFactory	= strFactory;
+
+    return  factory;
+
+}
+
+static void
+newPool(pANTLR3_ARBORETUM factory)
+{
+    // Increment factory count
+    //
+    factory->thisPool++;
+
+    // Ensure we have enough pointers allocated
+    //
+    factory->pools = (pANTLR3_COMMON_TREE *)
+					ANTLR3_REALLOC(	(void *)factory->pools,										// Current pools pointer (starts at NULL)
+					(ANTLR3_UINT32)((factory->thisPool + 1) * sizeof(pANTLR3_COMMON_TREE *))	// Memory for new pool pointers
+					);
+
+    // Allocate a new pool for the factory
+    //
+    factory->pools[factory->thisPool]	=
+			    (pANTLR3_COMMON_TREE) 
+				ANTLR3_MALLOC((size_t)(sizeof(ANTLR3_COMMON_TREE) * ANTLR3_FACTORY_POOL_SIZE));
+
+
+    // Reset the counters
+    //
+    factory->nextTree	= 0;
+  
+    // Done
+    //
+    return;
+}
+
+static	pANTLR3_BASE_TREE    
+newPoolTree	    (pANTLR3_ARBORETUM factory)
+{
+	pANTLR3_COMMON_TREE    tree;
+
+    // If we have anything on the re claim stack, reuse that sucker first
+    //
+    tree = factory->nilStack->peek(factory->nilStack);
+
+    if  (tree != NULL)
+    {
+        // Cool we got something we could reuse, it will have been cleaned up by
+        // whatever put it back on the stack (for instance if it had a child vector,
+        // that will have been cleared to hold zero entries and that vector will get reused too.
+        // It is the basetree pointer that is placed on the stack of course
+        //
+        factory->nilStack->pop(factory->nilStack);
+        return (pANTLR3_BASE_TREE)tree;
+
+    }
+	// See if we need a new tree pool before allocating a new tree
+	//
+	if	(factory->nextTree >= ANTLR3_FACTORY_POOL_SIZE)
+	{
+		// We ran out of tokens in the current pool, so we need a new pool
+		//
+		newPool(factory);
+	}
+
+	// Assuming everything went well - we are trying for performance here so doing minimal
+	// error checking - then we can work out what the pointer is to the next commontree.
+	//
+	tree   = factory->pools[factory->thisPool] + factory->nextTree;
+	factory->nextTree++;
+
+	// We have our token pointer now, so we can initialize it to the predefined model.
+	//
+    antlr3SetCTAPI(tree);
+
+    // Set some initial variables for future copying, including a string factory
+    // that we can use later for converting trees to strings.
+    //
+	tree->factory				= factory;
+    tree->baseTree.strFactory	= factory->unTruc.baseTree.strFactory;
+
+	// The super points to the common tree so we must override the one used by
+	// by the pre-built tree as otherwise we will always poitn to the same initial
+	// common tree and we might spend 3 hours trying to debug why - this would never
+	// happen to me of course! :-(
+	//
+	tree->baseTree.super	= tree;
+
+	// And we are done
+	//
+	return  &(tree->baseTree);
+}
+
+
+static pANTLR3_BASE_TREE	    
+newFromTree(pANTLR3_ARBORETUM factory, pANTLR3_COMMON_TREE tree)
+{
+	pANTLR3_BASE_TREE	newTree;
+
+	newTree = factory->newTree(factory);
+
+	if	(newTree == NULL)
+	{
+		return	NULL;
+	}
+
+	// Pick up the payload we had in the supplied tree
+	//
+	((pANTLR3_COMMON_TREE)(newTree->super))->token   = tree->token;
+	newTree->u		    = tree->baseTree.u;							// Copy any user pointer
+
+	return  newTree;
+}
+
+static pANTLR3_BASE_TREE	    
+newFromToken(pANTLR3_ARBORETUM factory, pANTLR3_COMMON_TOKEN token)
+{
+	pANTLR3_BASE_TREE	newTree;
+
+	newTree = factory->newTree(factory);
+
+	if	(newTree == NULL)
+	{
+		return	NULL;
+	}
+
+	// Pick up the payload we had in the supplied tree
+	//
+	((pANTLR3_COMMON_TREE)(newTree->super))->token = token;
+
+	return newTree;
+}
+
+static	void
+factoryClose	    (pANTLR3_ARBORETUM factory)
+{
+	ANTLR3_INT32	    poolCount;
+
+	// First close the vector factory that supplied all the child pointer
+	// vectors.
+	//
+	factory->vFactory->close(factory->vFactory);
+
+    if  (factory->nilStack !=  NULL)
+    {
+        factory->nilStack->free(factory->nilStack);
+    }
+
+	// We now JUST free the pools because the C runtime CommonToken based tree
+	// cannot contain anything that was not made by this factory.
+	//
+	for	(poolCount = 0; poolCount <= factory->thisPool; poolCount++)
+	{
+		// We can now free this pool allocation
+		//
+		ANTLR3_FREE(factory->pools[poolCount]);
+		factory->pools[poolCount] = NULL;
+	}
+
+	// All the pools are deallocated we can free the pointers to the pools
+	// now.
+	//
+	ANTLR3_FREE(factory->pools);
+
+	// Finally, we can free the space for the factory itself
+	//
+	ANTLR3_FREE(factory);
+}
+
+
+ANTLR3_API void 
+antlr3SetCTAPI(pANTLR3_COMMON_TREE tree)
+{
+    // Init base tree
+    //
+    antlr3BaseTreeNew(&(tree->baseTree));
+
+    // We need a pointer to ourselves for 
+    // the payload and few functions that we
+    // provide.
+    //
+    tree->baseTree.super    =  tree;
+
+    // Common tree overrides
+
+    tree->baseTree.isNilNode					= isNilNode;
+    tree->baseTree.toString					= toString;
+    tree->baseTree.dupNode					= (void *(*)(pANTLR3_BASE_TREE))(dupNode);
+    tree->baseTree.getLine					= getLine;
+    tree->baseTree.getCharPositionInLine	= getCharPositionInLine;
+    tree->baseTree.toString					= toString;
+    tree->baseTree.getType					= getType;
+    tree->baseTree.getText					= getText;
+    tree->baseTree.getToken					= getToken;
+	tree->baseTree.getParent				= getParent;
+	tree->baseTree.setParent				= setParent;
+	tree->baseTree.setChildIndex			= setChildIndex;
+	tree->baseTree.getChildIndex			= getChildIndex;
+	tree->baseTree.createChildrenList		= createChildrenList;
+    tree->baseTree.reuse                    = reuse;
+	tree->baseTree.free						= NULL;	// Factory trees have no free function
+	
+	tree->baseTree.children	= NULL;
+
+    tree->token				= NULL;	// No token as yet
+    tree->startIndex		= 0;
+    tree->stopIndex			= 0;
+	tree->parent			= NULL;	// No parent yet
+	tree->childIndex		= -1;
+
+    return;
+}
+
+// --------------------------------------
+// Non factory node constructors.
+//
+
+ANTLR3_API pANTLR3_COMMON_TREE
+antlr3CommonTreeNew()
+{
+	pANTLR3_COMMON_TREE	tree;
+	tree    = ANTLR3_MALLOC(sizeof(ANTLR3_COMMON_TREE));
+
+	if	(tree == NULL)
+	{
+		return NULL;
+	}
+
+	antlr3SetCTAPI(tree);
+
+	return tree;
+}
+
+ANTLR3_API pANTLR3_COMMON_TREE	    
+antlr3CommonTreeNewFromToken(pANTLR3_COMMON_TOKEN token)
+{
+	pANTLR3_COMMON_TREE	newTree;
+
+	newTree = antlr3CommonTreeNew();
+
+	if	(newTree == NULL)
+	{
+		return	NULL;
+	}
+
+	//Pick up the payload we had in the supplied tree
+	//
+	newTree->token = token;
+	return newTree;
+}
+
+/// Create a new vector for holding child nodes using the inbuilt
+/// vector factory.
+///
+static void
+createChildrenList  (pANTLR3_BASE_TREE tree)
+{
+	tree->children = ((pANTLR3_COMMON_TREE)(tree->super))->factory->vFactory->newVector(((pANTLR3_COMMON_TREE)(tree->super))->factory->vFactory);
+}
+
+
+static pANTLR3_COMMON_TOKEN 
+getToken			(pANTLR3_BASE_TREE tree)
+{
+    // The token is the payload of the common tree or other implementor
+    // so it is stored within ourselves, which is the super pointer.Note 
+	// that whatever the actual token is, it is passed around by its pointer
+	// to the common token implementation, which it may of course surround
+	// with its own super structure.
+    //
+    return  ((pANTLR3_COMMON_TREE)(tree->super))->token;
+}
+
+static pANTLR3_BASE_TREE    
+dupNode			(pANTLR3_BASE_TREE tree)
+{
+    // The node we are duplicating is in fact the common tree (that's why we are here)
+    // so we use the super pointer to duplicate.
+    //
+    pANTLR3_COMMON_TREE	    theOld;
+    
+	theOld	= (pANTLR3_COMMON_TREE)(tree->super);
+
+	// The pointer we return is the base implementation of course
+    //
+	return  theOld->factory->newFromTree(theOld->factory, theOld);
+}
+
+static ANTLR3_BOOLEAN	    
+isNilNode			(pANTLR3_BASE_TREE tree)
+{
+	// This is a Nil tree if it has no payload (Token in our case)
+	//
+	if	(((pANTLR3_COMMON_TREE)(tree->super))->token == NULL)
+	{
+		return ANTLR3_TRUE;
+	}
+	else
+	{
+		return ANTLR3_FALSE;
+	}
+}
+
+static ANTLR3_UINT32	    
+getType			(pANTLR3_BASE_TREE tree)
+{
+	pANTLR3_COMMON_TREE    theTree;
+
+	theTree = (pANTLR3_COMMON_TREE)(tree->super);
+
+	if	(theTree->token == NULL)
+	{
+		return	0;
+	}
+	else
+	{
+		return	theTree->token->getType(theTree->token);
+	}
+}
+
+static pANTLR3_STRING	    
+getText			(pANTLR3_BASE_TREE tree)
+{
+	return	tree->toString(tree);
+}
+
+static ANTLR3_UINT32	    getLine			(pANTLR3_BASE_TREE tree)
+{
+	pANTLR3_COMMON_TREE	    cTree;
+	pANTLR3_COMMON_TOKEN    token;
+
+	cTree   = (pANTLR3_COMMON_TREE)(tree->super);
+
+	token   = cTree->token;
+
+	if	(token == NULL || token->getLine(token) == 0)
+	{
+		if  (tree->getChildCount(tree) > 0)
+		{
+			pANTLR3_BASE_TREE	child;
+
+			child   = (pANTLR3_BASE_TREE)tree->getChild(tree, 0);
+			return child->getLine(child);
+		}
+		return 0;
+	}
+	return  token->getLine(token);
+}
+
+static ANTLR3_UINT32	    getCharPositionInLine	(pANTLR3_BASE_TREE tree)
+{
+	pANTLR3_COMMON_TOKEN    token;
+
+	token   = ((pANTLR3_COMMON_TREE)(tree->super))->token;
+
+	if	(token == NULL || token->getCharPositionInLine(token) == -1)
+	{
+		if  (tree->getChildCount(tree) > 0)
+		{
+			pANTLR3_BASE_TREE	child;
+
+			child   = (pANTLR3_BASE_TREE)tree->getChild(tree, 0);
+
+			return child->getCharPositionInLine(child);
+		}
+		return 0;
+	}
+	return  token->getCharPositionInLine(token);
+}
+
+static pANTLR3_STRING	    toString			(pANTLR3_BASE_TREE tree)
+{
+	if  (tree->isNilNode(tree) == ANTLR3_TRUE)
+	{
+		pANTLR3_STRING  nilNode;
+
+		nilNode	= tree->strFactory->newPtr(tree->strFactory, (pANTLR3_UINT8)"nil", 3);
+
+		return nilNode;
+	}
+
+	return	((pANTLR3_COMMON_TREE)(tree->super))->token->getText(((pANTLR3_COMMON_TREE)(tree->super))->token);
+}
+
+static pANTLR3_BASE_TREE	
+getParent				(pANTLR3_BASE_TREE tree)
+{
+	return & (((pANTLR3_COMMON_TREE)(tree->super))->parent->baseTree);
+}
+
+static void					
+setParent				(pANTLR3_BASE_TREE tree, pANTLR3_BASE_TREE parent)
+{
+	((pANTLR3_COMMON_TREE)(tree->super))->parent = parent == NULL ? NULL : ((pANTLR3_COMMON_TREE)(parent->super))->parent;
+}
+
+static void    				
+setChildIndex			(pANTLR3_BASE_TREE tree, ANTLR3_INT32 i)
+{
+	((pANTLR3_COMMON_TREE)(tree->super))->childIndex = i;
+}
+static	ANTLR3_INT32			
+getChildIndex			(pANTLR3_BASE_TREE tree )
+{
+	return ((pANTLR3_COMMON_TREE)(tree->super))->childIndex;
+}
+
+/** Clean up any child vector that the tree might have, so it can be reused,
+ *  then add it into the reuse stack.
+ */
+static void
+reuse                   (pANTLR3_BASE_TREE tree)
+{
+    pANTLR3_COMMON_TREE	    cTree;
+
+	cTree   = (pANTLR3_COMMON_TREE)(tree->super);
+
+    if  (cTree->factory != NULL)
+    {
+
+        if  (cTree->baseTree.children != NULL)
+        {
+            
+            cTree->baseTree.children->clear(cTree->baseTree.children);
+        }
+       cTree->factory->nilStack->push(cTree->factory->nilStack, tree, NULL);
+       
+    }
+}