xref: /aosp_15_r20/external/antlr/runtime/Cpp/include/antlr3commontreeadaptor.inl (revision 16467b971bd3e2009fad32dd79016f2c7e421deb)

ANTLR_BEGIN_NAMESPACE()

template<class ImplTraits>
ANTLR_INLINE CommonTreeAdaptor<ImplTraits>::CommonTreeAdaptor(DebuggerType*)
{
}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::TreeType*	  CommonTreeAdaptor<ImplTraits>::nilNode()
{
	return this->create(NULL);
}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::TreeType*	  CommonTreeAdaptor<ImplTraits>::dupTree( TreeType* tree)
{
	return this->dupTreeTT(tree, NULL);
}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::TreeType*	  CommonTreeAdaptor<ImplTraits>::dupTreeTT( TreeType* t, TreeType* parent)
{
	TreeType*	newTree;
	TreeType*	child;
	TreeType*	newSubTree;
	ANTLR_UINT32		n;
	ANTLR_UINT32		i;

	if	(t == NULL)
		return NULL;

	newTree = t->dupNode();

	// Ensure new subtree root has parent/child index set
	//
	this->setChildIndex( newTree, t->getChildIndex() );
	this->setParent(newTree, parent);
	n = this->getChildCount(t);

	for	(i=0; i < n; i++)
	{
		child = this->getChild(t, i);
		newSubTree = this->dupTreeTT(child, t);
		this->addChild(newTree, newSubTree);
	}
	return	newTree;
}

template<class ImplTraits>
void	CommonTreeAdaptor<ImplTraits>::addChild( TreeType* t, TreeType* child)
{
	if	(t != NULL && child != NULL)
	{
		t->addChild(child);
	}
}

template<class ImplTraits>
void	CommonTreeAdaptor<ImplTraits>::addChildToken( TreeType* t, CommonTokenType* child)
{
	if	(t != NULL && child != NULL)
	{
		this->addChild(t, this->create(child));
	}
}

template<class ImplTraits>
void	CommonTreeAdaptor<ImplTraits>::setParent( TreeType* child, TreeType* parent)
{
	child->setParent(parent);
}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::TreeType*		CommonTreeAdaptor<ImplTraits>::getParent( TreeType* child)
{
	return child->getParent();
}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::TreeType*		CommonTreeAdaptor<ImplTraits>::errorNode( CommonTokenType* tnstream, CommonTokenType* startToken, CommonTokenType* stopToken)
{
	// Use the supplied common tree node stream to get another tree from the factory
	// TODO: Look at creating the erronode as in Java, but this is complicated by the
	// need to track and free the memory allocated to it, so for now, we just
	// want something in the tree that isn't a NULL pointer.
	//
	return this->createTypeText( CommonTokenType::TOKEN_INVALID, "Tree Error Node");

}

template<class ImplTraits>
bool	CommonTreeAdaptor<ImplTraits>::isNilNode( TreeType* t)
{
	return t->isNilNode();
}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::TreeType*	    CommonTreeAdaptor<ImplTraits>::becomeRoot( TreeType* newRootTree, TreeType* oldRootTree)
{
	TreeType* 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())
	{
		if	(newRootTree->getChildCount() > 1)
		{
			/* TODO: Handle tree exceptions
			 */
			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(0);

        // Reclaim the old nilNode()
        //
        saveRoot->reuse();
	}

	/* 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(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())
    {
        // 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();
    }
	/* Always returns new root structure
	 */
	return	newRootTree;
}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::TreeType*	CommonTreeAdaptor<ImplTraits>::becomeRootToken(CommonTokenType* newRoot, TreeType* oldRoot)
{
	return	this->becomeRoot(this->create(newRoot), oldRoot);
}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::TreeType*	 	CommonTreeAdaptor<ImplTraits>::create( CommonTokenType* payload)
{
	return new TreeType(payload);
}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::TreeType*  CommonTreeAdaptor<ImplTraits>::createTypeToken( ANTLR_UINT32 tokenType,
																						  CommonTokenType* fromToken)
{
	/* Create the new token
	 */
	fromToken = this->createTokenFromToken(fromToken);

	/* Set the type of the new token to that supplied
	 */
	fromToken->setType(tokenType);

	/* Return a new node based upon this token
	 */
	return	this->create(fromToken);

}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::TreeType*	CommonTreeAdaptor<ImplTraits>::createTypeTokenText( ANTLR_UINT32 tokenType, CommonTokenType* fromToken, const ANTLR_UINT8* text)
{
	/* Create the new token
	 */
	fromToken = this->createTokenFromToken(fromToken);

	/* Set the type of the new token to that supplied
	 */
	fromToken->setType(tokenType);

	/* Set the text of the token accordingly
	 */
	fromToken->setText(text);

	/* Return a new node based upon this token
	 */
	return	this->create(fromToken);
}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::TreeType*	    CommonTreeAdaptor<ImplTraits>::createTypeText( ANTLR_UINT32 tokenType, const ANTLR_UINT8* text)
{
	CommonTokenType*	fromToken;

	/* Create the new token
	 */
	fromToken = this->createToken(tokenType, text);

	/* Return a new node based upon this token
	 */
	return	this->create(fromToken);
}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::TreeType*	CommonTreeAdaptor<ImplTraits>::dupNode( TreeType* treeNode)
{
	return  (treeNode == NULL) ? NULL : treeNode->dupNode();
}

template<class ImplTraits>
ANTLR_UINT32	CommonTreeAdaptor<ImplTraits>::getType( TreeType* t)
{
	return t->getType();
}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::StringType	CommonTreeAdaptor<ImplTraits>::getText( TreeType* t)
{
	return t->getText();
}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::TreeType*	    CommonTreeAdaptor<ImplTraits>::getChild( TreeType* t, ANTLR_UINT32 i)
{
	return t->getChild(i);
}

template<class ImplTraits>
void	CommonTreeAdaptor<ImplTraits>::setChild( TreeType* t, ANTLR_UINT32 i, TreeType* child)
{
	t->setChild(i, child);
}

template<class ImplTraits>
void	CommonTreeAdaptor<ImplTraits>::deleteChild( TreeType* t, ANTLR_UINT32 i)
{
	t->deleteChild(i);
}

template<class ImplTraits>
void	CommonTreeAdaptor<ImplTraits>::setChildIndex( TreeType* t, ANTLR_INT32 i)
{
	t->setChildIndex(i);
}

template<class ImplTraits>
ANTLR_INT32	CommonTreeAdaptor<ImplTraits>::getChildIndex( TreeType * t)
{
	return t->getChildIndex();
}

template<class ImplTraits>
ANTLR_UINT32	CommonTreeAdaptor<ImplTraits>::getChildCount( TreeType* t)
{
	return t->getChildCount();
}

template<class ImplTraits>
ANTLR_UINT64	CommonTreeAdaptor<ImplTraits>::getUniqueID( TreeType* node )
{
	return	reinterpret_cast<ANTLR_UINT64>(node);
}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::CommonTokenType*
	     CommonTreeAdaptor<ImplTraits>::createToken( ANTLR_UINT32 tokenType, const ANTLR_UINT8* text)
{
	CommonTokenType*    newToken = new CommonTokenType;

    if	(newToken != NULL)
    {
		newToken->set_tokText( (const char*) text );
		newToken->setType(tokenType);
    }
    return  newToken;

}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::CommonTokenType*
	CommonTreeAdaptor<ImplTraits>::createTokenFromToken( CommonTokenType* fromToken)
{
	CommonTokenType*    newToken;

    newToken	= new CommonTokenType;

    if	(newToken != NULL)
    {
		// Create the text using our own string factory to avoid complicating
		// commontoken.
		//
		StringType	text = fromToken->getText();
		newToken->set_tokText( text );
		newToken->setLine( fromToken->getLine() );
		newToken->setTokenIndex( fromToken->getTokenIndex() );
		newToken->setCharPositionInLine( fromToken->getCharPositionInLine() );
		newToken->setChannel( fromToken->getChannel() );
		newToken->setType( fromToken->getType() );
    }

    return  newToken;
}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::CommonTokenType*
		 CommonTreeAdaptor<ImplTraits>::getToken( TreeType* t)
{
	return t->getToken();
}

template<class ImplTraits>
void CommonTreeAdaptor<ImplTraits>::setTokenBoundaries( TreeType* t, CommonTokenType* startToken, CommonTokenType* stopToken)
{
	ANTLR_MARKER   start;
	ANTLR_MARKER   stop;

	TreeType*	    ct;

	if	(t == NULL)
	{
		return;
	}

	if	( startToken != NULL)
	{
		start = startToken->getTokenIndex();
	}
	else
	{
		start = 0;
	}

	if	( stopToken != NULL)
	{
		stop = stopToken->getTokenIndex();
	}
	else
	{
		stop = 0;
	}

	ct	= t;

	ct->set_startIndex(start);
	ct->set_stopIndex(stop);
}

template<class ImplTraits>
ANTLR_MARKER	CommonTreeAdaptor<ImplTraits>::getTokenStartIndex( TreeType* t)
{
	return t->get_tokenStartIndex();
}

template<class ImplTraits>
ANTLR_MARKER	CommonTreeAdaptor<ImplTraits>::getTokenStopIndex( TreeType* t)
{
	return t->get_tokenStopIndex();
}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::StringType	 CommonTreeAdaptor<ImplTraits>::makeDot( TreeType* theTree)
{
	// The string we are building up
	//
	StringType		dotSpec;
	char            buff[64];
	StringType      text;

	dotSpec = "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->append("n0[label=\"EMPTY TREE\"]\n");
		return dotSpec;
	}

    sprintf(buff, "\tn%p[label=\"", theTree);
	dotSpec.append(buff);
    text = this->getText(theTree);
    for (std::size_t j = 0; j < text.size(); j++)
    {
            switch(text[j])
            {
                case '"':
                    dotSpec.append("\\\"");
                    break;

                case '\n':
                    dotSpec.append("\\n");
                    break;

                case '\r':
                    dotSpec.append("\\r");
                    break;

                default:
                    dotSpec += text[j];
                    break;
            }
    }
	dotSpec->append("\"]\n");

	// First produce the node defintions
	//
	this->defineDotNodes(theTree, dotSpec);
	dotSpec.append("\n");
	this->defineDotEdges(theTree, dotSpec);

	// Terminate the spec
	//
	dotSpec.append("\n}");

	// Result
	//
	return dotSpec;
}

template<class ImplTraits>
void CommonTreeAdaptor<ImplTraits>::replaceChildren( TreeType* parent, ANTLR_INT32 startChildIndex, ANTLR_INT32 stopChildIndex, TreeType* t)
{
	if	(parent != NULL)
		parent->replaceChildren(startChildIndex, stopChildIndex, t);
}

template<class ImplTraits>
CommonTreeAdaptor<ImplTraits>::~CommonTreeAdaptor()
{
}

template<class ImplTraits>
void CommonTreeAdaptor<ImplTraits>::defineDotNodes(TreeType* t, const StringType& dotSpec)
{
	// How many nodes are we talking about?
	//
	int	nCount;
	int i;
    TreeType* child;
	char	buff[64];
	StringType	text;
	int		j;

	// Count the nodes
	//
	nCount = this->getChildCount(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 = this->getChild(t, i);

		// Name the node
		//
		sprintf(buff, "\tn%p[label=\"", child);
		dotSpec->append(buff);
		text = this->getText(child);
		for (j = 0; j < text.size(); j++)
		{
            switch(text[j])
            {
                case '"':
                    dotSpec.append("\\\"");
                    break;

                case '\n':
                    dotSpec.append("\\n");
                    break;

                case '\r':
                    dotSpec.append("\\r");
                    break;

                default:
                    dotSpec += text[j];
                    break;
            }
		}
		dotSpec.append("\"]\n");

		// And now define the children of this child (if any)
		//
		this->defineDotNodes(child, dotSpec);
	}

	// Done
	//
	return;
}

template<class ImplTraits>
void CommonTreeAdaptor<ImplTraits>::defineDotEdges(TreeType* t, const StringType& dotSpec)
{
	// How many nodes are we talking about?
	//
	int	nCount;
	if	(t == NULL)
	{
		// No tree, so do nothing
		//
		return;
	}

	// Count the nodes
	//
	nCount = this->getChildCount(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	(int i=0; i<nCount; i++)
	{
		TreeType* child;
		char	buff[128];
        StringType text;

		// Next child
		//
		child	= this->getChild(t, i);

		// Create the edge relation
		//
		sprintf(buff, "\t\tn%p -> n%p\t\t// ",  t, child);

		dotSpec.append(buff);

		// Document the relationship
		//
        text = this->getText(t);
		for (std::size_t j = 0; j < text.size(); j++)
        {
                switch(text[j])
                {
                    case '"':
                        dotSpec.append("\\\"");
                        break;

                    case '\n':
                        dotSpec.append("\\n");
                        break;

                    case '\r':
                        dotSpec.append("\\r");
                        break;

                    default:
                        dotSpec += text[j];
                        break;
                }
        }

        dotSpec.append(" -> ");

        text = this->getText(child);
        for (std::size_t j = 0; j < text.size(); j++)
        {
                switch(text[j])
                {
                    case '"':
                        dotSpec.append("\\\"");
                        break;

                    case '\n':
                        dotSpec.append("\\n");
                        break;

                    case '\r':
                        dotSpec.append("\\r");
                        break;

                    default:
                        dotSpec += text[j];
                        break;
                }
        }
		dotSpec.append("\n");

		// Define edges for this child
		//
		this->defineDotEdges(child, dotSpec);
	}

	// Done
	//
	return;
}

template<class ImplTraits>
typename CommonTreeAdaptor<ImplTraits>::TreeType* CommonTreeAdaptor<ImplTraits>::rulePostProcessing( TreeType* root)
{
	TreeType* 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())
	{
		if	(root->getChildCount() == 0)
		{
			root = NULL;
		}
		else if	(root->getChildCount() == 1)
		{
			root = root->getChild(0);
			root->setParent(NULL);
			root->setChildIndex(-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();
		}
	}
	return root;
}

template<class ImplTraits>
DebugTreeAdaptor<ImplTraits>::DebugTreeAdaptor( DebuggerType* debugger )
{
	m_debugger = debugger;
}

template<class ImplTraits>
void DebugTreeAdaptor<ImplTraits>::setDebugEventListener( DebuggerType* debugger)
{
	m_debugger = debugger;
}

template<class ImplTraits>
typename DebugTreeAdaptor<ImplTraits>::TreeType*	  DebugTreeAdaptor<ImplTraits>::nilNode()
{
	TreeType*	t = this->create(NULL);
	m_debugger->createNode(t);
	return	t;
}

template<class ImplTraits>
void	DebugTreeAdaptor<ImplTraits>::addChild(TreeType* t, TreeType* child)
{
	if	(t != NULL && child != NULL)
	{
		t->addChild(child);
		m_debugger->addChild(t, child);
	}
}

template<class ImplTraits>
void	DebugTreeAdaptor<ImplTraits>::addChildToken(TreeType* t, CommonTokenType* child)
{
	TreeType*	tc;
	if	(t != NULL && child != NULL)
	{
		tc = this->create(child);
		this->addChild(t, tc);
		m_debugger->addChild(t, tc);
	}
}

template<class ImplTraits>
typename DebugTreeAdaptor<ImplTraits>::TreeType* DebugTreeAdaptor<ImplTraits>::becomeRoot( TreeType* newRootTree, TreeType* oldRootTree )
{
	TreeType* t;
	t = this->becomeRoot(newRootTree, oldRootTree);
	m_debugger->becomeRoot(newRootTree, oldRootTree);
	return t;
}

template<class ImplTraits>
typename DebugTreeAdaptor<ImplTraits>::TreeType* DebugTreeAdaptor<ImplTraits>::becomeRootToken(TreeType* newRoot, TreeType* oldRoot)
{
	TreeType*	t;
	t =	this->becomeRoot(this->create(newRoot), oldRoot);
	m_debugger->becomeRoot(t, oldRoot);
	return t;
}

template<class ImplTraits>
typename DebugTreeAdaptor<ImplTraits>::TreeType* DebugTreeAdaptor<ImplTraits>::createTypeToken(ANTLR_UINT32 tokenType, CommonTokenType* fromToken)
{
	TreeType* t;
	t = this->createTypeToken(tokenType, fromToken);
	m_debugger->createNode(t);
	return t;
}

template<class ImplTraits>
typename DebugTreeAdaptor<ImplTraits>::TreeType* DebugTreeAdaptor<ImplTraits>::createTypeTokenText(ANTLR_UINT32 tokenType, CommonTokenType* fromToken, ANTLR_UINT8* text)
{
	TreeType* t;
	t = this->createTypeTokenText(tokenType, fromToken, text);
	m_debugger->createNode(t);
	return t;
}

template<class ImplTraits>
typename DebugTreeAdaptor<ImplTraits>::TreeType* DebugTreeAdaptor<ImplTraits>::createTypeText( ANTLR_UINT32 tokenType, ANTLR_UINT8* text)
{
	TreeType* t;
	t = this->createTypeText(tokenType, text);
	m_debugger->createNode(t);
	return t;
}

template<class ImplTraits>
typename DebugTreeAdaptor<ImplTraits>::TreeType* DebugTreeAdaptor<ImplTraits>::dupTree( TreeType* tree)
{
	TreeType* t;

	// Call the normal dup tree mechanism first
	//
	t = this->dupTreeTT(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..
	//
	this->simulateTreeConstruction( t);

	return t;
}

template<class ImplTraits>
void DebugTreeAdaptor<ImplTraits>::simulateTreeConstruction(TreeType* tree)
{
	ANTLR_UINT32		n;
	ANTLR_UINT32		i;
	TreeType*	child;

	// Send the create node event
	//
	m_debugger->createNode(tree);

	n = this->getChildCount(tree);
	for	(i = 0; i < n; i++)
	{
		child = this->getChild(tree, i);
		this->simulateTreeConstruction(child);
		m_debugger->addChild(tree, child);
	}
}


ANTLR_END_NAMESPACE()