Exemple #1
0
 /** <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;
 }
Exemple #2
0
        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;
        }
Exemple #3
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;
 }
Exemple #4
0
        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;
        }
Exemple #8
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 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);
 }
        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;
        }
Exemple #11
0
        public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            if (IsUrl(text, stream.Current))
            {
                Function = Children.AddCurrentAndAdvance(stream, SassClassifierType.SystemFunction);

                if (stream.Current.Type == TokenType.OpenFunctionBrace)
                    OpenBrace = Children.AddCurrentAndAdvance(stream, SassClassifierType.FunctionBrace);

                if ((stream.Current.Type == TokenType.String || stream.Current.Type == TokenType.BadString))
                {
                    Url = itemFactory.CreateSpecificParsed<StringValue>(this, text, stream);
                    if (Url != null)
                        Children.Add(Url);
                }
                else
                {
                    // not using string, so just consume everything until close of url()
                    while (!IsUrlTerminator(stream.Current.Type))
                    {
                        Children.AddCurrentAndAdvance(stream, SassClassifierType.String);
                    }
                }

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

            return Children.Count > 0;
        }
        public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            if (ParseSelectorToken(itemFactory, text, stream))
                ParseCombinator(itemFactory, text, stream);

            return Children.Count > 0;
        }
Exemple #13
0
        protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            if (stream.Current.Type == TokenType.Identifier)
                Name = Children.AddCurrentAndAdvance(stream, SassClassifierType.ElementName);

            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, "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;
        }
	public FastSimpleExpressionParser(ITokenStream input, RecognizerSharedState state)
		: base(input, state)
	{
		InitializeTreeAdaptor();
		if ( TreeAdaptor == null )
			TreeAdaptor = new CommonTreeAdaptor();
	}
        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 CompilationState(ErrorManager errMgr, string name, ITokenStream tokens)
 {
     this.errMgr = errMgr;
     this.tokens = tokens;
     impl.Name = name;
     impl.Prefix = Utility.GetPrefix(name);
 }
        public MatlabParser(ITokenStream input, Configuration configuration)
            : this(input)
        {
            Checker.CheckNotNull(configuration);

            this.Configuration = configuration;
        }
        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 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;
        }
        protected override bool ParseSelectorToken(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            if (stream.Current.Type == TokenType.Ampersand)
                Ampersand = Children.AddCurrentAndAdvance(stream, SassClassifierType.ParentReference);

            return Children.Count > 0;
        }
        protected override void ParseImport(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            if (stream.Current.Type == TokenType.String || stream.Current.Type == TokenType.BadString)
            {
                Filename = itemFactory.CreateSpecificParsed<StringValue>(this, text, stream);
                if (Filename != null)
                    Children.Add(Filename);
            }
            else if (UrlItem.IsUrl(text, stream.Current))
            {
                var url = new UrlItem();
                if (url.Parse(itemFactory, text, stream))
                {
                    Url = url;
                    Children.Add(url);
                }
            }

            while (!IsTerminator(stream.Current.Type))
            {
                var query = new MediaQuery();
                if (!query.Parse(itemFactory, text, stream))
                    break;

                _MediaQueries.Add(query);
                Children.Add(query);
            }
        }
Exemple #24
0
        public static bool IsValidName(ITokenStream stream)
        {
            if (stream.Current.Type == TokenType.Period)
                return stream.Peek(1).Type == TokenType.Identifier;

            return false;
        }
        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;
        }
Exemple #26
0
        public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
        {
            if (stream.Current.Type == TokenType.String || stream.Current.Type == TokenType.BadString)
                Value = Children.AddCurrentAndAdvance(stream, SassClassifierType.String);

            return Children.Count > 0;
        }
Exemple #27
0
 public virtual object ErrorNode(ITokenStream input, IToken start, IToken stop,
                         RecognitionException e) {
     object node = adaptor.ErrorNode(input, start, stop, e);
     if (node != null) {
         dbg.ErrorNode(node);
     }
     return node;
 }
        public NetworkInterpreter(Network network, ITokenStream input)
        {
            Contract.Requires<ArgumentNullException>(network != null, "network");
            Contract.Requires<ArgumentNullException>(input != null, "input");

            _network = network;
            _input = input;
        }
 public NoViableAltException(IRecognizer recognizer, ITokenStream input, IToken startToken, IToken offendingToken, ATNConfigSet deadEndConfigs, ParserRuleContext ctx)
     : base(recognizer, input, ctx)
 {
     // LL(1) error
     this.deadEndConfigs = deadEndConfigs;
     this.startToken = startToken;
     this.OffendingToken = offendingToken;
 }
 public AutomationErrorNode(ITokenStream input, IToken start, IToken stop, RecognitionException ex)
 {
     var handler = new CommonErrorNode(input, start, stop, ex);
     this.isNil = handler.IsNil;
     this.type = handler.Type;
     this.text = handler.Text;
     this.toString = handler.ToString();
 }
Exemple #31
0
        public ParserInterpreter(string grammarFileName, IVocabulary vocabulary, IEnumerable <string> ruleNames, ATN atn, ITokenStream input)
            : base(input)
        {
            this._grammarFileName = grammarFileName;
            this._atn             = atn;
            this._ruleNames       = ruleNames.ToArray();
            this.vocabulary       = vocabulary;
            // identify the ATN states where pushNewRecursionContext must be called
            this.pushRecursionContextStates = new BitSet(atn.states.Count);
            foreach (ATNState state in atn.states)
            {
                if (!(state is StarLoopEntryState))
                {
                    continue;
                }
                if (((StarLoopEntryState)state).isPrecedenceDecision)
                {
                    this.pushRecursionContextStates.Set(state.stateNumber);
                }
            }

            //init decision DFA
            int numberofDecisions = atn.NumberOfDecisions;

            this._decisionToDFA = new Dfa.DFA[numberofDecisions];
            for (int i = 0; i < numberofDecisions; i++)
            {
                DecisionState decisionState = atn.GetDecisionState(i);
                _decisionToDFA[i] = new Dfa.DFA(decisionState, i);
            }
            // get atn simulator that knows how to do predictions
            Interpreter = new ParserATNSimulator(this, atn, _decisionToDFA, null);
        }
Exemple #32
0
 protected override Parser GetParser(ITokenStream tokens)
 {
     return(new ConditionParser(tokens));
 }
Exemple #33
0
 public Parser(ITokenStream input)
     : base()
 {
     //super(); // highlight that we go to super to set state object
     TokenStream = input;
 }
Exemple #34
0
 public Parser(ITokenStream input, RecognizerSharedState state)
     : base(state)             // share the state object with another parser
 {
     TokenStream = input;
 }
 protected override CParser CreateParser(ITokenStream stream)
 {
     return(new CParser(stream));
 }
Exemple #36
0
 public JavaParser(ITokenStream input) : this(input, Console.Out, Console.Error)
 {
 }
Exemple #37
0
 public final1Parser(ITokenStream input)
     : this(input, new RecognizerSharedState())
 {
 }
        public ParserInterpreter(string grammarFileName, IVocabulary vocabulary, IEnumerable <string> ruleNames, ATN atn, ITokenStream input)
            : base(input)
        {
            this.grammarFileName = grammarFileName;
            this.atn             = atn;
#pragma warning disable 612 // 'fieldName' is obsolete
            this.tokenNames = new string[atn.maxTokenType];
            for (int i = 0; i < tokenNames.Length; i++)
            {
                tokenNames[i] = vocabulary.GetDisplayName(i);
            }
#pragma warning restore 612
            this.ruleNames  = ruleNames.ToArray();
            this.vocabulary = vocabulary;
            // identify the ATN states where pushNewRecursionContext must be called
            this.pushRecursionContextStates = new BitSet(atn.states.Count);
            foreach (ATNState state in atn.states)
            {
                if (!(state is StarLoopEntryState))
                {
                    continue;
                }
                if (((StarLoopEntryState)state).precedenceRuleDecision)
                {
                    this.pushRecursionContextStates.Set(state.stateNumber);
                }
            }
            // get atn simulator that knows how to do predictions
            Interpreter = new ParserATNSimulator(this, atn);
        }
 public ParserInterpreter(string grammarFileName, IEnumerable <string> tokenNames, IEnumerable <string> ruleNames, ATN atn, ITokenStream input)
     : this(grammarFileName, Antlr4.Runtime.Vocabulary.FromTokenNames(tokenNames.ToArray()), ruleNames, atn, input)
 {
 }
Exemple #40
0
 public final1Parser(ITokenStream input, RecognizerSharedState state)
     : base(input, state)
 {
     OnCreated();
 }
 private IToken LT(ITokenStream stream, int k)
 {
     return(stream.Lt(k));
 }
 public OCLSyntaxParser(ITokenStream input, ErrorCollection errColl)
     : this(input) {
     Errors = errColl;
 }
 public SimpleCalc3Parser(ITokenStream input)
     : base(input)
 {
     InitializeCyclicDFAs();
 }
 public CSharpPreprocessorParser(ITokenStream input)
     : base(input)
 {
     Interpreter = new ParserATNSimulator(this, _ATN, decisionToDFA, sharedContextCache);
 }
Exemple #45
0
 protected override Parser GetParser(ITokenStream tokens)
 {
     return(new InputsParser(tokens));
 }
Exemple #46
0
 protected internal RewriteOperation(ITokenStream tokens, int index, object text)
 {
     this.tokens = tokens;
     this.index  = index;
     this.text   = text;
 }
Exemple #47
0
 public Parser(ITokenStream input)
     : base()             // highlight that we go to base class to set state object
 {
     TokenStream = input;
 }
Exemple #48
0
 public InsertBeforeOp(ITokenStream tokens, int index, object text)
     : base(tokens, index, text)
 {
 }
Exemple #49
0
 public ReplaceOp(ITokenStream tokens, int from, int to, object text)
     : base(tokens, from, text)
 {
     lastIndex = to;
 }
 public CountryList(ITokenStream input) : this(input, Console.Out, Console.Error)
 {
 }
Exemple #51
0
 protected GoParserBase(ITokenStream input, TextWriter output, TextWriter errorOutput)
     : base(input, output, errorOutput)
 {
 }
 public CountryList(ITokenStream input, TextWriter output, TextWriter errorOutput)
     : base(input, output, errorOutput)
 {
     Interpreter = new ParserATNSimulator(this, _ATN, decisionToDFA, sharedContextCache);
 }
Exemple #53
0
 public XYZParser(ITokenStream input)
     : base(input)
 {
     _interp = new ParserATNSimulator(this, _ATN);
 }
Exemple #54
0
 public AntlrParser(ITokenStream input)
     : base(input)
 {
     Errors = new List <ParseException>();
 }
Exemple #55
0
        /// <summary>
        /// The default implementation of
        /// <see cref="IAntlrErrorStrategy.Sync(Parser)"/>
        /// makes sure
        /// that the current lookahead symbol is consistent with what were expecting
        /// at this point in the ATN. You can call this anytime but ANTLR only
        /// generates code to check before subrules/loops and each iteration.
        /// <p>Implements Jim Idle's magic sync mechanism in closures and optional
        /// subrules. E.g.,</p>
        /// <pre>
        /// a : sync ( stuff sync )* ;
        /// sync : {consume to what can follow sync} ;
        /// </pre>
        /// At the start of a sub rule upon error,
        /// <see cref="Sync(Parser)"/>
        /// performs single
        /// token deletion, if possible. If it can't do that, it bails on the current
        /// rule and uses the default error recovery, which consumes until the
        /// resynchronization set of the current rule.
        /// <p>If the sub rule is optional (
        /// <c>(...)?</c>
        /// ,
        /// <c>(...)*</c>
        /// , or block
        /// with an empty alternative), then the expected set includes what follows
        /// the subrule.</p>
        /// <p>During loop iteration, it consumes until it sees a token that can start a
        /// sub rule or what follows loop. Yes, that is pretty aggressive. We opt to
        /// stay in the loop as long as possible.</p>
        /// <p><strong>ORIGINS</strong></p>
        /// <p>Previous versions of ANTLR did a poor job of their recovery within loops.
        /// A single mismatch token or missing token would force the parser to bail
        /// out of the entire rules surrounding the loop. So, for rule</p>
        /// <pre>
        /// classDef : 'class' ID '{' member* '}'
        /// </pre>
        /// input with an extra token between members would force the parser to
        /// consume until it found the next class definition rather than the next
        /// member definition of the current class.
        /// <p>This functionality cost a little bit of effort because the parser has to
        /// compare token set at the start of the loop and at each iteration. If for
        /// some reason speed is suffering for you, you can turn off this
        /// functionality by simply overriding this method as a blank { }.</p>
        /// </summary>
        /// <exception cref="Antlr4.Runtime.RecognitionException"/>
        public virtual void Sync(Parser recognizer)
        {
            ATNState s = recognizer.Interpreter.atn.states[recognizer.State];

            //		System.err.println("sync @ "+s.stateNumber+"="+s.getClass().getSimpleName());
            // If already recovering, don't try to sync
            if (InErrorRecoveryMode(recognizer))
            {
                return;
            }
            ITokenStream tokens = ((ITokenStream)recognizer.InputStream);
            int          la     = tokens.La(1);
            // try cheaper subset first; might get lucky. seems to shave a wee bit off
            IntervalSet nextTokens = recognizer.Atn.NextTokens(s);

            //if (nextTokens.Contains(TokenConstants.Epsilon) || nextTokens.Contains(la))
            if (nextTokens.Contains(la))
            {
                // We are sure the token matches
                nextTokensContext = null;
                nextTokensState   = ATNState.InvalidStateNumber;
                return;
            }
            if (nextTokens.Contains(TokenConstants.Epsilon))
            {
                if (nextTokensContext == null)
                {
                    // It's possible the next token won't match; information tracked
                    // by sync is restricted for performance.
                    nextTokensContext = recognizer.Context;
                    nextTokensState   = recognizer.State;
                }
                return;
            }
            switch (s.StateType)
            {
            case StateType.BlockStart:
            case StateType.StarBlockStart:
            case StateType.PlusBlockStart:
            case StateType.StarLoopEntry:
            {
                // report error and recover if possible
                if (SingleTokenDeletion(recognizer) != null)
                {
                    return;
                }
                throw new InputMismatchException(recognizer);
            }

            case StateType.PlusLoopBack:
            case StateType.StarLoopBack:
            {
                //			System.err.println("at loop back: "+s.getClass().getSimpleName());
                ReportUnwantedToken(recognizer);
                IntervalSet expecting = recognizer.GetExpectedTokens();
                IntervalSet whatFollowsLoopIterationOrRule = expecting.Or(GetErrorRecoverySet(recognizer));
                ConsumeUntil(recognizer, whatFollowsLoopIterationOrRule);
                break;
            }

            default:
            {
                // do nothing if we can't identify the exact kind of ATN state
                break;
            }
            }
        }
 public JavaScriptBaseParser(ITokenStream input)
     : base(input)
 {
     _input = input;
 }
Exemple #57
0
 /// <summary>
 /// Constructs a new instance of the
 /// <see cref="AmbiguityInfo"/>
 /// class with the
 /// specified detailed ambiguity information.
 /// </summary>
 /// <param name="decision">The decision number</param>
 /// <param name="state">
 /// The final simulator state identifying the ambiguous
 /// alternatives for the current input
 /// </param>
 /// <param name="ambigAlts">The set of alternatives in the decision that lead to a valid parse.</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 ambiguity was identified during
 /// prediction
 /// </param>
 public AmbiguityInfo(int decision, SimulatorState state, BitSet ambigAlts, ITokenStream input, int startIndex, int stopIndex)
     : base(decision, state, input, startIndex, stopIndex, state.useContext)
 {
     this.ambigAlts = ambigAlts;
 }
Exemple #58
0
 protected internal RewriteOperation(ITokenStream tokens, int index)
 {
     // Define the rewrite operation hierarchy
     this.tokens = tokens;
     this.index  = index;
 }
 protected GoParserBase(ITokenStream input)
     : base(input)
 {
 }
Exemple #60
0
        public IParseTree Parse(string moduleName, string moduleCode, IParseTreeListener[] listeners, out ITokenStream outStream)
        {
            var stream = new AntlrInputStream(moduleCode);
            var lexer  = new VBALexer(stream);
            var tokens = new CommonTokenStream(lexer);
            var parser = new VBAParser(tokens);

            parser.AddErrorListener(new ExceptionErrorListener());
            ParserRuleContext tree = null;

            try
            {
                parser.Interpreter.PredictionMode = PredictionMode.Sll;
                tree = parser.startRule();
            }
            catch (Exception ex)
            {
                _logger.Warn(ex, "SLL mode failed in module {0}. Retrying using LL.", moduleName);
                tokens.Reset();
                parser.Reset();
                parser.Interpreter.PredictionMode = PredictionMode.Ll;
                tree = parser.startRule();
            }
            foreach (var listener in listeners)
            {
                ParseTreeWalker.Default.Walk(listener, tree);
            }
            outStream = tokens;
            return(tree);
        }