public SqlGenerator(ISessionFactoryImplementor sfi, ITreeNodeStream input)
     : this(input)
 {
     parseErrorHandler = new ErrorCounter();
     sessionFactory = sfi;
     writer = new DefaultWriter(this);
 }

 private AlloyOutliningTaggerWalker(ITreeNodeStream input, ReadOnlyCollection<IToken> tokens, AlloyOutliningTaggerProvider provider, ITextSnapshot snapshot)
     : base(input, snapshot, provider.OutputWindowService)
 {
     _tokens = tokens;
     _provider = provider;
     _snapshot = snapshot;
 }

 public CodeGenerator(ITreeNodeStream input, TemplateCompiler compiler, string name, string template, IToken templateToken)
     : this(input, new RecognizerSharedState())
 {
     this._compiler = compiler;
     this.outermostTemplateName = name;
     this._template = template;
     this.templateToken = templateToken;
 }

 public TreeRewriter( ITreeNodeStream input, RecognizerSharedState state )
     : base( input, state )
 {
     originalAdaptor = input.TreeAdaptor;
     originalTokenStream = input.TokenStream;
     topdown_func = () => Topdown();
     bottomup_func = () => Bottomup();
 }

        private AlloyEditorNavigationSourceWalker(ITreeNodeStream input, ITextSnapshot snapshot, ReadOnlyCollection<IToken> tokens, IEditorNavigationTypeRegistryService editorNavigationTypeRegistryService, IGlyphService glyphService, IOutputWindowService outputWindowService)
            : base(input, snapshot, outputWindowService)
        {
            Contract.Requires<ArgumentNullException>(editorNavigationTypeRegistryService != null, "editorNavigationTypeRegistryService");
            Contract.Requires<ArgumentNullException>(glyphService != null, "glyphService");

            _tokens = tokens;
            _editorNavigationTypeRegistryService = editorNavigationTypeRegistryService;
            _glyphService = glyphService;
        }

 public LeftRecursiveRuleAnalyzer(ITreeNodeStream input, Grammar g, string ruleName)
     : base(input)
 {
     this.g = g;
     this.ruleName = ruleName;
     language = (string)g.GetOption("language");
     generator = new CodeGenerator(g.Tool, g, language);
     generator.LoadTemplates(language);
     recRuleTemplates = LoadPrecRuleTemplates(g.Tool);
 }

		public HqlSqlWalker(QueryTranslatorImpl qti,
					  ISessionFactoryImplementor sfi,
					  ITreeNodeStream input, 
					  IDictionary<string, string> tokenReplacements,
					  string collectionRole)
			: this(input)
		{
			_sessionFactoryHelper = new SessionFactoryHelperExtensions(sfi);
			_qti = qti;
			_literalProcessor = new LiteralProcessor(this);
			_tokenReplacements = tokenReplacements;
			_collectionFilterRole = collectionRole;
		}

		public DebugTreeGrammar( ITreeNodeStream input, int port, RecognizerSharedState state )
			: base( input, state )
		{
			DebugEventSocketProxy proxy = new DebugEventSocketProxy( this, port, input.TreeAdaptor );
			DebugListener = proxy;
			try
			{
				proxy.Handshake();
			}
			catch ( IOException ioe )
			{
				ReportError( ioe );
			}
		}

 public TreeRewriter(ITreeNodeStream input, RecognizerSharedState state) : base(input, state)
 {
     Func<IAstRuleReturnScope> func = null;
     Func<IAstRuleReturnScope> func2 = null;
     this.originalAdaptor = input.TreeAdaptor;
     this.originalTokenStream = input.TokenStream;
     if (func == null)
     {
         func = () => this.Topdown();
     }
     this.topdown_func = func;
     if (func2 == null)
     {
         func2 = () => this.Bottomup();
     }
     this.bottomup_func = func2;
 }

        public NadirASTOptimizer(ITreeNodeStream input, RecognizerSharedState state)
    		: base(input, state) {
            InitializeCyclicDFAs();

             
        }

		public TreeParser(ITreeNodeStream input)
			: base() // highlight that we go to super to set state object
		{
			TreeNodeStream = input;
		}

 public string ToNodesOnlyString( ITreeNodeStream nodes )
 {
     ITreeAdaptor adaptor = nodes.TreeAdaptor;
     StringBuilder buf = new StringBuilder();
     object o = nodes.LT( 1 );
     int type = adaptor.GetType( o );
     while ( o != null && type != TokenTypes.EndOfFile )
     {
         if ( !( type == TokenTypes.Down || type == TokenTypes.Up ) )
         {
             buf.Append( " " );
             buf.Append( type );
         }
         nodes.Consume();
         o = nodes.LT( 1 );
         type = adaptor.GetType( o );
     }
     return buf.ToString();
 }

    // delegates
    // delegators



        public BonsaiTree(ITreeNodeStream input)
    		: this(input, new RecognizerSharedState()) {
        }

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

    public NadirTreeFilter(ITreeNodeStream input) 
        : this(input, new RecognizerSharedState())
        {
        }

 public override string ToTokenTypeString( ITreeNodeStream stream )
 {
     return ( (BufferedTreeNodeStream)stream ).ToTokenTypeString();
 }

        public SqlGenerator(ITreeNodeStream input, RecognizerSharedState state)
    		: base(input, state) {
            InitializeCyclicDFAs();

             
        }

		void PrepareFromClauseInputTree(IASTNode fromClauseInput, ITreeNodeStream input)
		{
			if (IsFilter())
			{
				// Handle collection-fiter compilation.
				// IMPORTANT NOTE: This is modifying the INPUT (HQL) tree, not the output tree!
				IQueryableCollection persister = _sessionFactoryHelper.GetCollectionPersister(_collectionFilterRole);
				IType collectionElementType = persister.ElementType;
				if (!collectionElementType.IsEntityType)
				{
					throw new QueryException("collection of values in filter: this");
				}

				string collectionElementEntityName = persister.ElementPersister.EntityName;

				IASTNode fromElement = (IASTNode)adaptor.Create(FILTER_ENTITY, collectionElementEntityName);
				IASTNode alias = (IASTNode)adaptor.Create(ALIAS, "this");

                ((HqlSqlWalkerTreeNodeStream)input).InsertChild(fromClauseInput, fromElement);
                ((HqlSqlWalkerTreeNodeStream)input).InsertChild(fromClauseInput, alias);

//				fromClauseInput.AddChild(fromElement);
//				fromClauseInput.AddChild(alias);

				// Show the modified AST.
				if (log.IsDebugEnabled)
				{
					log.Debug("prepareFromClauseInputTree() : Filter - Added 'this' as a from element...");
				}
				
				// Create a parameter specification for the collection filter...
				IType collectionFilterKeyType = _sessionFactoryHelper.RequireQueryableCollection(_collectionFilterRole).KeyType;
				ParameterNode collectionFilterKeyParameter = (ParameterNode)adaptor.Create(PARAM, "?");
				CollectionFilterKeyParameterSpecification collectionFilterKeyParameterSpec = new CollectionFilterKeyParameterSpecification(
						_collectionFilterRole, collectionFilterKeyType, _positionalParameterCount++
				);
				collectionFilterKeyParameter.HqlParameterSpecification = collectionFilterKeyParameterSpec;
				_parameters.Add(collectionFilterKeyParameterSpec);
			}
		}

        protected virtual void ExtractInformationFromTreeNodeStream(ITreeNodeStream input, int k)
        {
            int mark = input.Mark();
            try
            {
                for (int i = 0; i < k - 1; i++)
                    input.Consume();

                ExtractInformationFromTreeNodeStream(input);
            }
            finally
            {
                input.Rewind(mark);
            }
        }

 public virtual string ToTokenTypeString( ITreeNodeStream stream )
 {
     return ( (CommonTreeNodeStream)stream ).ToTokenTypeString();
 }

 public NadirTreeParserBase(ITreeNodeStream input, RecognizerSharedState state) : base(input, state)
     {
     }