static ParseItem CreateSimpleSelector(ComplexItem parent, IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            switch (stream.Current.Type)
            {
                case TokenType.Ampersand: return new ParentReferenceSelector();
                case TokenType.Asterisk: return new UniversalSelector();
                case TokenType.Period: return new ClassSelector();
                case TokenType.Hash: return new IdSelector();
                case TokenType.Identifier: return new TypeSelector();
                case TokenType.OpenBrace: return new AttributeSelector();
                case TokenType.DoubleColon: return new PseudoElementSelector();
                case TokenType.PercentSign: return new ExtendOnlySelector();
            }

            if (stream.Current.Type == TokenType.Colon)
            {
                var next = stream.Peek(1);
                switch (next.Type)
                {
                    case TokenType.Identifier: return new PseudoClassSelector();
                    case TokenType.Function: return new PseudoFunctionSelector();
                }
            }

            return null;
        }

        protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            if (stream.Current.Type == TokenType.OpenBrace)
            {
                OpenBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.SquareBrace);
                if (stream.Current.Type == TokenType.Identifier)
                    Attribute = Children.AddCurrentAndAdvance(stream);

                if (IsAttributeOperator(stream.Current.Type))
                    Operator = Children.AddCurrentAndAdvance(stream);

                if (stream.Current.Type == TokenType.String || stream.Current.Type == TokenType.BadString)
                {
                    Value = itemFactory.CreateSpecificParsed<StringValue>(this, text, stream);
                    if (Value != null)
                        Children.Add(Value);
                } else if (stream.Current.Type == TokenType.Identifier)
                {
                    Value = Children.AddCurrentAndAdvance(stream, SassClassifierType.String);
                }

                if (stream.Current.Type == TokenType.CloseBrace)
                    CloseBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.SquareBrace);
            }

            return Children.Count > 0;
        }

	public FastSimpleExpressionParser(ITokenStream input, RecognizerSharedState state)
		: base(input, state)
	{
		InitializeTreeAdaptor();
		if ( TreeAdaptor == null )
			TreeAdaptor = new CommonTreeAdaptor();
	}

        public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            if (AtRule.IsRule(text, stream, "media"))
            {
                Rule = AtRule.CreateParsed(itemFactory, text, stream);
                if (Rule != null)
                    Children.Add(Rule);

                while (!IsTerminator(stream.Current.Type))
                {
                    var query = itemFactory.CreateSpecific<MediaQuery>(this, text, stream);
                    if (query.Parse(itemFactory, text, stream))
                    {
                        _Queries.Add(query);
                        Children.Add(query);
                    }
                    else
                    {
                        Children.AddCurrentAndAdvance(stream);
                    }
                }

                var block = itemFactory.CreateSpecific<MediaQueryBlock>(this, text, stream);
                if (block.Parse(itemFactory, text, stream))
                {
                    Body = block;
                    Children.Add(block);
                }
            }

            return Children.Count > 0;
        }

        protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            if (stream.Current.Type == TokenType.Asterisk)
                Asterisk = Children.AddCurrentAndAdvance(stream);

            return Children.Count > 0;
        }

        public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            if (AtRule.IsRule(text, stream, "each"))
            {
                ParseRule(itemFactory, text, stream);
                while (!IsListTerminator(stream.Current.Type))
                {
                    var item = itemFactory.CreateSpecific<ListItem>(this, text, stream);
                    if (item != null && item.Parse(itemFactory, text, stream))
                    {
                        _Items.Add(item);
                        Children.Add(item);
                    }
                    else
                    {
                        // bad news bears
                        Children.AddCurrentAndAdvance(stream);
                    }
                }

                ParseBody(itemFactory, text, stream);
            }

            return Children.Count > 0;
        }

 public DebugTokenStream(ITokenStream input, IDebugEventListener dbg) {
     this.input = input;
     DebugListener = dbg;
     // force TokenStream to get at least first valid token
     // so we know if there are any hidden tokens first in the stream
     input.LT(1);
 }

        public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            if (stream.Current.Type == TokenType.Identifier && IsModifier(text.GetText(stream.Current.Start, stream.Current.Length)))
                Modifier = Children.AddCurrentAndAdvance(stream);

            ParseItem mediaType;
            if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out mediaType))
            {
                MediaType = mediaType;
                Children.Add(mediaType);
            }

            while (!IsTerminator(text, stream))
            {
                var expression = itemFactory.CreateSpecific<MediaQueryExpression>(this, text, stream);
                if (expression.Parse(itemFactory, text, stream))
                {
                    _Expressions.Add(expression);
                    Children.Add(expression);
                }
                else
                {
                    Children.AddCurrentAndAdvance(stream);
                }
            }

            if (stream.Current.Type == TokenType.Comma)
                Comma = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);

            return Children.Count > 0;
        }

 /// <summary>
 /// Constructs a new instance of the
 /// <see cref="PredicateEvalInfo"/>
 /// class with the
 /// specified detailed predicate evaluation information.
 /// </summary>
 /// <param name="state">The simulator state</param>
 /// <param name="decision">The decision number</param>
 /// <param name="input">The input token stream</param>
 /// <param name="startIndex">The start index for the current prediction</param>
 /// <param name="stopIndex">
 /// The index at which the predicate evaluation was
 /// triggered. Note that the input stream may be reset to other positions for
 /// the actual evaluation of individual predicates.
 /// </param>
 /// <param name="semctx">The semantic context which was evaluated</param>
 /// <param name="evalResult">The results of evaluating the semantic context</param>
 /// <param name="predictedAlt">
 /// The alternative number for the decision which is
 /// guarded by the semantic context
 /// <paramref name="semctx"/>
 /// . See
 /// <see cref="predictedAlt"/>
 /// for more information.
 /// </param>
 /// <seealso cref="ParserATNSimulator.EvalSemanticContext(SemanticContext, ParserRuleContext, int)"/>
 /// <seealso cref="SemanticContext.Eval"/>
 public PredicateEvalInfo(SimulatorState state, int decision, ITokenStream input, int startIndex, int stopIndex, SemanticContext semctx, bool evalResult, int predictedAlt)
     : base(decision, state, input, startIndex, stopIndex, state.useContext)
 {
     this.semctx = semctx;
     this.evalResult = evalResult;
     this.predictedAlt = predictedAlt;
 }

        public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            while (!IsSelectorTerminator(stream.Current.Type))
            {
                var selector = itemFactory.CreateSpecific<SelectorGroup>(this, text, stream);
                if (!selector.Parse(itemFactory, text, stream))
                    break;

                _Selectors.Add(selector);
                Children.Add(selector);

                if (stream.Current.Type == TokenType.Comma)
                    Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
            }

            if (stream.Current.Type == TokenType.OpenCurlyBrace)
            {
                var block = itemFactory.CreateSpecific<RuleBlock>(this, text, stream);
                if (block.Parse(itemFactory, text, stream))
                {
                    Block = block;
                    Children.Add(block);
                }
            }

            return Children.Count > 0;
        }

        public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            if (stream.Current.Type == TokenType.XmlDocumentationComment)
            {
                Opening = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);

                // look for <reference
                if (stream.Current.Type == TokenType.LessThan)
                {
                    var tag = itemFactory.CreateSpecific<XmlDocumentationTag>(this, text, stream);
                    if (tag.Parse(itemFactory, text, stream))
                    {
                        Tag = tag;
                        Children.Add(tag);
                    }
                    else
                    {
                        Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationComment);
                    }
                }
                else
                {
                    while (!IsCommentTerminator(stream.Current.Type))
                    {
                        Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationComment);
                    }
                }

                //if (stream.Current.Type == TokenType.NewLine)
                //    NewLine = Children.AddCurrentAndAdvance(stream);
            }

            return Children.Count > 0;
        }

        public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            if (AtRule.IsRule(text, stream, "extend"))
            {
                Rule = AtRule.CreateParsed(itemFactory, text, stream);
                if (Rule != null)
                    Children.Add(Rule);

                var selector = itemFactory.CreateSpecific<SelectorGroup>(this, text, stream);
                if (selector.Parse(itemFactory, text, stream))
                {
                    Selector = selector;
                    Children.Add(selector);
                }

                if (stream.Current.Type == TokenType.Bang)
                {
                    var modifier = new OptionalModifier();
                    if (modifier.Parse(itemFactory, text, stream))
                    {
                        Modifier = modifier;
                        Children.Add(modifier);
                    }
                }

                if (stream.Current.Type == TokenType.Semicolon)
                    Semicolon = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
            }

            return Children.Count > 0;
        }

        public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            if (stream.Current.Type == TokenType.LessThan)
            {
                OpenTag = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);
                if (stream.Current.Type == TokenType.Identifier)
                {
                    Name = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);

                    while (!IsTagTerminator(stream.Current.Type))
                    {
                        var attribute = itemFactory.CreateSpecific<XmlAttribute>(this, text, stream);
                        if (!attribute.Parse(itemFactory, text, stream))
                            break;

                        Children.Add(attribute);
                        _Attributes.Add(attribute);
                        OnAttributeParsed(attribute, text);
                    }
                }

                if (stream.Current.Type == TokenType.Slash)
                    CloseSlash = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);

                if (stream.Current.Type == TokenType.GreaterThan)
                    CloseTag = Children.AddCurrentAndAdvance(stream, SassClassifierType.XmlDocumentationTag);
            }

            return Children.Count > 0;
        }

        private ParseItemList Parse(ITextProvider text, IItemFactory itemFactory, ITokenStream stream, IParsingExecutionContext context)
        {
            var results = new ParseItemList();
            while (!context.IsCancellationRequested && stream.Current.Type != TokenType.EndOfFile)
            {
                int position = stream.Position;

                ParseItem item;
                if (!itemFactory.TryCreate(null, text, stream, out item))
                    break;

                if (item.Parse(itemFactory, text, stream))
                    results.Add(item);

                // guard against infinite loop (in case token couldn't be handled)
                if (stream.Position == position)
                    stream.Advance();
            }

            // freeze everything
            if (!context.IsCancellationRequested)
                foreach (var item in results)
                    item.Freeze();

            return results;
        }

 public CompilationState(ErrorManager errMgr, string name, ITokenStream tokens)
 {
     this.errMgr = errMgr;
     this.tokens = tokens;
     impl.Name = name;
     impl.Prefix = Utility.GetPrefix(name);
 }

 /** <summary>
  *  Create tree node that holds the start and stop tokens associated
  *  with an error.
  *  </summary>
  *
  *  <remarks>
  *  If you specify your own kind of tree nodes, you will likely have to
  *  override this method. CommonTree returns Token.INVALID_TOKEN_TYPE
  *  if no token payload but you might have to set token type for diff
  *  node type.
  *
  *  You don't have to subclass CommonErrorNode; you will likely need to
  *  subclass your own tree node class to avoid class cast exception.
  *  </remarks>
  */
 public virtual object ErrorNode( ITokenStream input, IToken start, IToken stop,
                         RecognitionException e )
 {
     CommonErrorNode t = new CommonErrorNode( input, start, stop, e );
     //System.out.println("returning error node '"+t+"' @index="+input.index());
     return t;
 }

        public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            if ((IsConditionalDirective(text, stream) || IsConditionalContinuationDirective(text, stream)))
            {
                ParseRule(itemFactory, text, stream);

                while (!IsConditionTerminator(stream.Current.Type))
                {
                    ParseItem item;
                    if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out item))
                    {
                        Children.Add(item);
                        ConditionStatements.Add(item);
                    }
                    else
                    {
                        Children.AddCurrentAndAdvance(stream);
                    }
                }

                ParseBody(itemFactory, text, stream);

                while (IsConditionalContinuationDirective(text, stream))
                {
                    var subsequentConditional = itemFactory.CreateSpecific<ConditionalControlDirective>(this, text, stream);
                    if (!subsequentConditional.Parse(itemFactory, text, stream))
                        break;

                    ElseStatements.Add(subsequentConditional);
                    Children.Add(subsequentConditional);
                }
            }

            return Children.Count > 0;
        }

        public MatlabParser(ITokenStream input, Configuration configuration)
            : this(input)
        {
            Checker.CheckNotNull(configuration);

            this.Configuration = configuration;
        }

        protected virtual bool ParseCombinator(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            SelectorCombinator combinator = null;
            switch (stream.Current.Type)
            {
                case TokenType.GreaterThan:
                    combinator = new ChildCombinator();
                    break;
                case TokenType.Plus:
                    combinator = new AdjacentSiblingCombinator();
                    break;
                case TokenType.Tilde:
                    combinator = new GeneralSiblingCombinator();
                    break;
            }

            if (combinator != null)
            {
                if (combinator.Parse(itemFactory, text, stream))
                {
                    Children.Add(combinator);
                    Combinator = combinator;
                }
            }
            else if (stream.Current.Type != TokenType.OpenCurlyBrace)
            {
                // whitespace only combinator means no adding to children or parsing
                // we just want to know that there was a combinator
                if (stream.Current.Start >= (stream.Peek(-1).End + 1))
                    Combinator = new DescendantCombinator();
            }

            return Combinator != null;
        }

        public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            if (ParseSelectorToken(itemFactory, text, stream))
                ParseCombinator(itemFactory, text, stream);

            return Children.Count > 0;
        }