/Users/parrt/antlr/code/antlr/main/runtime/CSharp/Sources/Antlr3.Runtime/Antlr.Runtime.Tree/CommonTreeNodeStream.cs

Go to the documentation of this file.

/*
[The "BSD licence"]
Copyright (c) 2007-2008 Johannes Luber
Copyright (c) 2005-2007 Kunle Odutola
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.
4. Unless explicitly state otherwise, any contribution intentionally 
   submitted for inclusion in this work to the copyright owner or licensor
   shall be under the terms and conditions of this license, without any 
   additional terms or conditions.

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.
*/


namespace Antlr.Runtime.Tree
{
        using System;
        using IEnumerable       = System.Collections.IEnumerable;
        using IEnumerator       = System.Collections.IEnumerator;
        using IDictionary       = System.Collections.IDictionary;
        using IList                     = System.Collections.IList;
        using ArrayList         = System.Collections.ArrayList;
        using Hashtable         = System.Collections.Hashtable;
        using StringBuilder = System.Text.StringBuilder;
        using StackList         = Antlr.Runtime.Collections.StackList;
        using Token                     = Antlr.Runtime.Token;
        using ITokenStream      = Antlr.Runtime.ITokenStream;
        
        public class CommonTreeNodeStream : ITreeNodeStream, IEnumerable
        {
                public const int DEFAULT_INITIAL_BUFFER_SIZE = 100;
                public const int INITIAL_CALL_STACK_SIZE = 10;

                #region Helper classes
                protected sealed class CommonTreeNodeStreamEnumerator : IEnumerator
                {
                        private CommonTreeNodeStream _nodeStream;
                        private int _index;
                        private object _currentItem;
                
                        #region Constructors

                        internal CommonTreeNodeStreamEnumerator()
                        {       
                        }

                        internal CommonTreeNodeStreamEnumerator(CommonTreeNodeStream nodeStream)
                        {
                                _nodeStream = nodeStream;
                                Reset();
                        }

                        #endregion

                        #region IEnumerator Members

                        public void Reset()
                        {
//                              if (_version != _hashList._version)
//                              {
//                                      throw new InvalidOperationException("Collection was modified; enumeration operation may not execute.");
//                              }
                                _index = 0;
                                _currentItem = null;
                        }

                        public object Current
                        {
                                get
                                {
                                        if (_currentItem == null)
                                        {
                                                throw new InvalidOperationException("Enumeration has either not started or has already finished.");
                                        }
                                        return _currentItem;
                                }
                        }

                        public bool MoveNext()
                        {
//                              if (_version != _hashList._version)
//                              {
//                                      throw new InvalidOperationException("Collection was modified; enumeration operation may not execute.");
//                              }

                                if ( _index >= _nodeStream.nodes.Count )
                                {
                                        int current = _index;
                                        _index++;
                                        if ( current < _nodeStream.nodes.Count ) 
                                        {
                                                _currentItem = _nodeStream.nodes[current];
                                        }
                                        _currentItem = _nodeStream.eof;
                                        return true;
                                }
                                _currentItem = null;
                                return false;
                        }

                        #endregion
                }

                #endregion

                #region IEnumerable Members

                public IEnumerator GetEnumerator()
                {
                        if ( p == -1 ) 
                        {
                                FillBuffer();
                        }
                        return new CommonTreeNodeStreamEnumerator(this);
                }

                #endregion

                #region Data Members
                // all these navigation nodes are shared and hence they
                // cannot contain any line/column info

                protected object down;
                protected object up;
                protected object eof;

                protected IList nodes;

                protected internal object root;

                protected ITokenStream tokens;

                ITreeAdaptor adaptor;

                protected bool uniqueNavigationNodes = false;

                protected int p = -1;

                protected int lastMarker;

                protected StackList calls;

                #endregion

                #region Constructors

                public CommonTreeNodeStream(object tree) 
                        : this(new CommonTreeAdaptor(), tree)
                {
                }

                public CommonTreeNodeStream(ITreeAdaptor adaptor, object tree) 
                        : this(adaptor, tree, DEFAULT_INITIAL_BUFFER_SIZE)
                {
                }

                public CommonTreeNodeStream(ITreeAdaptor adaptor, object tree, int initialBufferSize) 
                {
                        this.root = tree;
                        this.adaptor = adaptor;
                        nodes = new ArrayList(initialBufferSize);
                        down = adaptor.Create(Token.DOWN, "DOWN");
                        up = adaptor.Create(Token.UP, "UP");
                        eof = adaptor.Create(Token.EOF, "EOF");
                }

                #endregion

                #region Public API

                protected void FillBuffer() 
                {
                        FillBuffer(root);
                        p = 0; // buffer of nodes intialized now
                }

                public void FillBuffer(object t) 
                {
                        bool nil = adaptor.IsNil(t);
                        if ( !nil ) 
                        {
                                nodes.Add(t); // add this node
                        }
                        // add DOWN node if t has children
                        int n = adaptor.GetChildCount(t);
                        if ( !nil && (n > 0) ) 
                        {
                                AddNavigationNode(Token.DOWN);
                        }
                        // and now add all its children
                        for (int c = 0; c < n; c++) 
                        {
                                object child = adaptor.GetChild(t, c);
                                FillBuffer(child);
                        }
                        // add UP node if t has children
                        if ( !nil && (n > 0) ) 
                        {
                                AddNavigationNode(Token.UP);
                        }
                }

                protected int GetNodeIndex(object node)
                {
                        if ( p == -1 )
                        {
                                FillBuffer();
                        }
                        for (int i = 0; i < nodes.Count; i++)
                        {
                                object t = (object) nodes[i];
                                if ( t == node )
                                {
                                        return i;
                                }
                        }
                        return -1;
                }

                protected void AddNavigationNode(int ttype)
                {
                        object navNode = null;
                        if ( ttype == Token.DOWN )
                        {
                                if ( HasUniqueNavigationNodes )
                                {
                                        navNode = adaptor.Create(Token.DOWN, "DOWN");
                                }
                                else
                                {
                                        navNode = down;
                                }
                        }
                        else
                        {
                                if ( HasUniqueNavigationNodes )
                                {
                                        navNode = adaptor.Create(Token.UP, "UP");
                                }
                                else
                                {
                                        navNode = up;
                                }
                        }
                        nodes.Add(navNode);
                }

                public object Get(int i)
                {
                        if ( p == -1 )
                        {
                                FillBuffer();
                        }
                        return nodes[i];
                }

                public object LT(int k)
                {
                        if ( p == -1 )
                        {
                                FillBuffer();
                        }
                        if ( k == 0 )
                        {
                                return null;
                        }
                        if ( k < 0 )
                        {
                                return LB(-k);
                        }
                        if ( (p+k-1) >= nodes.Count )
                        {
                                return eof;
                        }
                        return nodes[p+k-1];
                }

                public virtual object CurrentSymbol {
                        get { return LT(1); }
                }

                protected object LB(int k) 
                {
                        if ( k == 0 )
                        {
                                return null;
                        }
                        if ( (p-k) < 0 )
                        {
                                return null;
                        }
                        return nodes[p-k];
                }

                virtual public object TreeSource
                {
                        get { return root; }
                }

                virtual public string SourceName {
                        get { return TokenStream.SourceName; }
                }

                virtual public ITokenStream TokenStream
                {
                        get { return tokens; }
                        set { this.tokens = value; }
                }

                public ITreeAdaptor TreeAdaptor
                {
                        get { return adaptor; }
                        set { adaptor = value; }
                }

                public bool HasUniqueNavigationNodes
                {
                        get { return uniqueNavigationNodes;  }
                        set { uniqueNavigationNodes = value; }
                }

                public void Push(int index) 
                {
                        if ( calls == null ) 
                        {
                                calls = new StackList();
                        }
                        calls.Push(p); // save current index
                        Seek(index);
                }

                public int Pop() 
                {
                        int ret = (int)calls.Pop();
                        Seek(ret);
                        return ret;
                }

                public void Reset()
                {
                        p = -1;
                        lastMarker = 0;
                        if (calls != null)
                        {
                                calls.Clear();
                        }
                }

                #endregion

                #region Tree Rewrite Interface

                public void ReplaceChildren(object parent, int startChildIndex, int stopChildIndex, object t)
                {
                        if (parent != null)
                        {
                                adaptor.ReplaceChildren(parent, startChildIndex, stopChildIndex, t);
                        }
                }

                #endregion

                #region Satisfy IntStream interface

                public virtual void Consume()
                {
                        if (p == -1)
                        {
                                FillBuffer();
                        }
                        p++;
                }
                
                public virtual int LA(int i)
                {
                        return adaptor.GetNodeType( LT(i) );
                }

                public virtual int Mark()
                {
                        if ( p == -1 ) 
                        {
                                FillBuffer();
                        }
                        lastMarker = Index();
                        return lastMarker;
                }
                
                public virtual void  Release(int marker)
                {
                        // no resources to release
                }
                
                public virtual void Rewind(int marker)
                {
                        Seek(marker);
                }

                public void Rewind()
                {
                        Seek(lastMarker);
                }

                public virtual void Seek(int index)
                {
                        if ( p == -1 ) 
                        {
                                FillBuffer();
                        }
                        p = index;
                }

                public virtual int Index()
                {
                        return p;
                }
                
                public virtual int Size()
                {
                        if ( p == -1 ) 
                        {
                                FillBuffer();
                        }
                        return nodes.Count;
                }

                #endregion

                public override string ToString()
                {
                        if ( p == -1 ) 
                        {
                                FillBuffer();
                        }
                        StringBuilder buf = new StringBuilder();
                        for (int i = 0; i < nodes.Count; i++) 
                        {
                                object t = (object) nodes[i];
                                buf.Append(" ");
                                buf.Append(adaptor.GetNodeType(t));
                        }
                        return buf.ToString();
                }

                public String ToTokenString(int start, int stop) {
                        if ( p==-1 ) {
                                FillBuffer();
                        }
                        StringBuilder buf = new StringBuilder();
                        for (int i = start; i < nodes.Count && i <= stop; i++) {
                                Object t = (Object) nodes[i];
                                buf.Append(" ");
                                buf.Append(adaptor.GetToken(t));
                        }
                        return buf.ToString();
                }

                public virtual string ToString(object start, object stop)
                {
                        Console.Out.WriteLine("ToString");
                        if ( (start == null) || (stop == null) ) 
                        {
                                return null;
                        }
                        if ( p == -1 ) 
                        {
                                FillBuffer();
                        }
                        //Console.Out.WriteLine("stop: " + stop);
                        if ( start is CommonTree )
                                Console.Out.Write("ToString: " + ((CommonTree)start).Token + ", ");
                        else
                                Console.Out.WriteLine(start);
                        if ( stop is CommonTree )
                                Console.Out.WriteLine(((CommonTree)stop).Token);
                        else
                                Console.Out.WriteLine(stop);
                        // if we have the token stream, use that to dump text in order
                        if ( tokens != null ) 
                        {
                                int beginTokenIndex = adaptor.GetTokenStartIndex(start);
                                int endTokenIndex = adaptor.GetTokenStopIndex(stop);
                                // if it's a tree, use start/stop index from start node
                                // else use token range from start/stop nodes
                                if ( adaptor.GetNodeType(stop) == Token.UP ) 
                                {
                                        endTokenIndex = adaptor.GetTokenStopIndex(start);
                                }
                                else if ( adaptor.GetNodeType(stop) == Token.EOF ) 
                                {
                                        endTokenIndex = Size()-2; // don't use EOF
                                }
                                return tokens.ToString(beginTokenIndex, endTokenIndex);
                        }
                        // walk nodes looking for start
                        object t = null;
                        int i = 0;
                        for (; i < nodes.Count; i++) 
                        {
                                t = nodes[i];
                                if ( t == start ) 
                                {
                                        break;
                                }
                        }
                        // now walk until we see stop, filling string buffer with text
                        StringBuilder buf = new StringBuilder();
                        t = nodes[i];
                        string text;
                        while ( t != stop ) 
                        {
                                text = adaptor.GetNodeText(t);
                                if ( text == null ) 
                                {
                                        text = " " + adaptor.GetNodeType(t);
                                }
                                buf.Append(text);
                                i++;
                                t = nodes[i];
                        }
                        // include stop node too
                        text = adaptor.GetNodeText(stop);
                        if ( text == null ) 
                        {
                                text = " " + adaptor.GetNodeType(stop);
                        }
                        buf.Append(text);
                        return buf.ToString();
                }
                
        }
}

---