/** <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 (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 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; }
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; }
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); } }
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; }
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; }
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(); }
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); }
protected override Parser GetParser(ITokenStream tokens) { return(new ConditionParser(tokens)); }
public Parser(ITokenStream input) : base() { //super(); // highlight that we go to super to set state object TokenStream = input; }
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)); }
public JavaParser(ITokenStream input) : this(input, Console.Out, Console.Error) { }
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) { }
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); }
protected override Parser GetParser(ITokenStream tokens) { return(new InputsParser(tokens)); }
protected internal RewriteOperation(ITokenStream tokens, int index, object text) { this.tokens = tokens; this.index = index; this.text = text; }
public Parser(ITokenStream input) : base() // highlight that we go to base class to set state object { TokenStream = input; }
public InsertBeforeOp(ITokenStream tokens, int index, object text) : base(tokens, index, text) { }
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) { }
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); }
public XYZParser(ITokenStream input) : base(input) { _interp = new ParserATNSimulator(this, _ATN); }
public AntlrParser(ITokenStream input) : base(input) { Errors = new List <ParseException>(); }
/// <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; }
/// <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; }
protected internal RewriteOperation(ITokenStream tokens, int index) { // Define the rewrite operation hierarchy this.tokens = tokens; this.index = index; }
protected GoParserBase(ITokenStream input) : base(input) { }
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); }