public TreePatternParser( TreePatternLexer tokenizer, TreeWizard wizard, ITreeAdaptor adaptor )
 {
     this.tokenizer = tokenizer;
     this.wizard = wizard;
     this.adaptor = adaptor;
     ttype = tokenizer.NextToken(); // kickstart
 }

 protected static bool EqualsCore(object t1, object t2, ITreeAdaptor adaptor)
 {
     if ((t1 == null) || (t2 == null))
     {
         return false;
     }
     if (adaptor.GetType(t1) != adaptor.GetType(t2))
     {
         return false;
     }
     if (!adaptor.GetText(t1).Equals(adaptor.GetText(t2)))
     {
         return false;
     }
     int childCount = adaptor.GetChildCount(t1);
     int num2 = adaptor.GetChildCount(t2);
     if (childCount != num2)
     {
         return false;
     }
     for (int i = 0; i < childCount; i++)
     {
         object child = adaptor.GetChild(t1, i);
         object obj3 = adaptor.GetChild(t2, i);
         if (!EqualsCore(child, obj3, adaptor))
         {
             return false;
         }
     }
     return true;
 }

        /// <summary>
        /// The worker for <see cref="InContext(TreeParser, string)"/>. It's <see langword="static"/> and full of
        /// parameters for testing purposes.
        /// </summary>
        private static bool InContext(
            ITreeAdaptor adaptor,
            string[] tokenNames,
            object t,
            string context)
        {
            if (Regex.IsMatch(context, DotDot))
            {
                // don't allow "..", must be "..."
                throw new ArgumentException("invalid syntax: ..");
            }

            if (Regex.IsMatch(context, DoubleEtc))
            {
                // don't allow double "..."
                throw new ArgumentException("invalid syntax: ... ...");
            }

            context = context.Replace("...", " ... "); // ensure spaces around ...
            context = context.Trim();
            string[] nodes = context.Split(new[] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
            int ni = nodes.Length - 1;
            t = adaptor.GetParent(t);
            while (ni >= 0 && t != null)
            {
                if (nodes[ni].Equals("..."))
                {
                    // walk upwards until we see nodes[ni-1] then continue walking
                    if (ni == 0)
                    {
                        // ... at start is no-op
                        return true;
                    }

                    string goal = nodes[ni - 1];
                    object ancestor = GetAncestor(adaptor, tokenNames, t, goal);
                    if (ancestor == null)
                        return false;

                    t = ancestor;
                    ni--;
                }

                string name = tokenNames[adaptor.GetType(t)];
                if (!name.Equals(nodes[ni]))
                {
                    //System.Console.Error.WriteLine("not matched: " + nodes[ni] + " at " + t);
                    return false;
                }

                // advance to parent and to previous element in context node list
                ni--;
                t = adaptor.GetParent(t);
            }

            if (t == null && ni >= 0)
                return false; // at root but more nodes to match
            return true;
        }

        public TreeViewModel(ITreeAdaptor adaptor, object tree)
        {
            if (adaptor == null)
                throw new ArgumentNullException("adaptor");
            if (tree == null)
                throw new ArgumentNullException("tree");

            _adaptor = adaptor;
            _tree = tree;
        }

        // Private interface
        private static string Concatenate_Depth2_Subtree_Name( ITreeAdaptor tree_adapter, object node )
        {
            StringBuilder builder = new StringBuilder();

            builder.Append( tree_adapter.GetText( node ) );

            for ( int i = 0; i < tree_adapter.GetChildCount( node ); i++ )
            {
                object child_node = tree_adapter.GetChild( node, i );
                builder.Append( tree_adapter.GetText( child_node ) );
            }

            return builder.ToString();
        }

        public TreeVisualizerViewModel(ITreeAdaptor adaptor, object tree, ITokenStream tokenStream, string sourceText)
        {
            if (adaptor == null)
                throw new ArgumentNullException("adaptor");
            if (tree == null)
                throw new ArgumentNullException("tree");

            _adaptor = adaptor;
            _tree = tree;
            _tokenStream = tokenStream;
            _sourceText = sourceText;

            object root = adaptor.Nil();
            adaptor.AddChild(root, tree);
            _treeViewModel = new TreeViewModel(_adaptor, root);
        }

 protected virtual IEnumerable<string> DefineNodes(object tree, ITreeAdaptor adaptor)
 {
     if (tree != null)
     {
         int childCount = adaptor.GetChildCount(tree);
         if (childCount != 0)
         {
             yield return this.GetNodeText(adaptor, tree);
             for (int i = 0; i < childCount; i++)
             {
                 object child = adaptor.GetChild(tree, i);
                 yield return this.GetNodeText(adaptor, child);
                 foreach (string iteratorVariable3 in this.DefineNodes(child, adaptor))
                 {
                     yield return iteratorVariable3;
                 }
             }
         }
     }
 }

 protected virtual IEnumerable<string> DefineEdges(object tree, ITreeAdaptor adaptor)
 {
     if (tree != null)
     {
         int childCount = adaptor.GetChildCount(tree);
         if (childCount != 0)
         {
             string iteratorVariable1 = "n" + this.GetNodeNumber(tree);
             string text = adaptor.GetText(tree);
             for (int i = 0; i < childCount; i++)
             {
                 object child = adaptor.GetChild(tree, i);
                 string iteratorVariable5 = adaptor.GetText(child);
                 string iteratorVariable6 = "n" + this.GetNodeNumber(child);
                 yield return string.Format("  {0} -> {1} // \"{2}\" -> \"{3}\"", new object[] { iteratorVariable1, iteratorVariable6, this.FixString(text), this.FixString(iteratorVariable5) });
                 foreach (string iteratorVariable7 in this.DefineEdges(child, adaptor))
                 {
                     yield return iteratorVariable7;
                 }
             }
         }
     }
 }

 public TreeWizard( ITreeAdaptor adaptor, IDictionary<string, int> tokenNameToTypeMap )
 {
     this.adaptor = adaptor;
     this.tokenNameToTypeMap = tokenNameToTypeMap;
 }

		/// <summary>Create a stream, but feed off an existing list</summary>
		public RewriteRuleNodeStream(
			ITreeAdaptor adaptor,
			string elementDescription,
            IList<object> elements
		) : base(adaptor, elementDescription, elements) {
		}

 protected static bool _Equals( object t1, object t2, ITreeAdaptor adaptor )
 {
     // make sure both are non-null
     if ( t1 == null || t2 == null )
     {
         return false;
     }
     // check roots
     if ( adaptor.GetType( t1 ) != adaptor.GetType( t2 ) )
     {
         return false;
     }
     if ( !adaptor.GetText( t1 ).Equals( adaptor.GetText( t2 ) ) )
     {
         return false;
     }
     // check children
     int n1 = adaptor.GetChildCount( t1 );
     int n2 = adaptor.GetChildCount( t2 );
     if ( n1 != n2 )
     {
         return false;
     }
     for ( int i = 0; i < n1; i++ )
     {
         object child1 = adaptor.GetChild( t1, i );
         object child2 = adaptor.GetChild( t2, i );
         if ( !_Equals( child1, child2, adaptor ) )
         {
             return false;
         }
     }
     return true;
 }

 public RewriteRuleElementStream( ITreeAdaptor adaptor, string elementDescription )
 {
     this.elementDescription = elementDescription;
     this.adaptor = adaptor;
 }

 public RewriteRuleSubtreeStream(ITreeAdaptor adaptor, string elementDescription, IList elements)            : base(adaptor, elementDescription, elements) { }

 public ReadOnlyTreeVisitor(ITreeAdaptor adaptor)
     {
     this.adaptor = adaptor;
     }

 public UnBufferedTreeNodeStream(ITreeAdaptor adaptor, object tree)
 {
     this.root = tree;
     this.adaptor = adaptor;
     Reset();
     down = adaptor.Create(Token.DOWN, "DOWN");
     up = adaptor.Create(Token.UP, "UP");
     eof = adaptor.Create(Token.EOF, "EOF");
 }

        /** Generate DOT (graphviz) for a whole tree not just a node.
         *  For example, 3+4*5 should generate:
         *
         * digraph {
         *   node [shape=plaintext, fixedsize=true, fontsize=11, fontname="Courier",
         *         width=.4, height=.2];
         *   edge [arrowsize=.7]
         *   "+"->3
         *   "+"->"*"
         *   "*"->4
         *   "*"->5
         * }
         *
         * Takes a Tree interface object.
         */
        public virtual string ToDot(object tree, ITreeAdaptor adaptor) {
            StringBuilder builder = new StringBuilder();
            foreach (string line in HeaderLines)
                builder.AppendLine(line);

            nodeNumber = 0;
            var nodes = DefineNodes(tree, adaptor);
            nodeNumber = 0;
            var edges = DefineEdges(tree, adaptor);

            foreach (var s in nodes)
                builder.AppendLine(s);

            builder.AppendLine();

            foreach (var s in edges)
                builder.AppendLine(s);

            builder.AppendLine();

            builder.AppendLine(Footer);
            return builder.ToString();
        }

		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");
		}

 public ModifiableTreeVisitor(ITreeAdaptor adaptor)
     {
     this.adaptor = adaptor;
     }

 /** <summary>
  *  Compare t1 and t2; return true if token types/text, structure match exactly.
  *  The trees are examined in their entirety so that (A B) does not match
  *  (A B C) nor (A (B C)). 
  *  </summary>
  *
  *  <remarks>
  *  TODO: allow them to pass in a comparator
  *  TODO: have a version that is nonstatic so it can use instance adaptor
  *
  *  I cannot rely on the tree node's equals() implementation as I make
  *  no constraints at all on the node types nor interface etc... 
  *  </remarks>
  */
 public static bool Equals( object t1, object t2, ITreeAdaptor adaptor )
 {
     return _Equals( t1, t2, adaptor );
 }

    ///////////////////////////////////////////
    //
    // Construction
    //
    ///////////////////////////////////////////

    public NadirTreePatternMatcher(ITreeNodeStream input, RecognizerSharedState state) : base(input, state)
        {
        originalAdaptor     = (ITreeAdaptor)input.TreeAdaptor;
        originalTokenStream = input.TokenStream;
        }