Antlr4.Runtime.ParserInterpreter.Parse C# (CSharp) Method

        public virtual ParserRuleContext Parse(int startRuleIndex)
        {
            RuleStartState startRuleStartState = _atn.ruleToStartState[startRuleIndex];
            InterpreterRuleContext rootContext = new InterpreterRuleContext(null, ATNState.InvalidStateNumber, startRuleIndex);
            if (startRuleStartState.isPrecedenceRule)
            {
                EnterRecursionRule(rootContext, startRuleStartState.stateNumber, startRuleIndex, 0);
            }
            else
            {
                EnterRule(rootContext, startRuleStartState.stateNumber, startRuleIndex);
            }
            while (true)
            {
                ATNState p = AtnState;
                switch (p.StateType)
                {
                    case StateType.RuleStop:
                    {
                        // pop; return from rule
                        if (RuleContext.IsEmpty)
                        {
                            if (startRuleStartState.isPrecedenceRule)
                            {
                                ParserRuleContext result = RuleContext;
                                Tuple<ParserRuleContext, int> parentContext = _parentContextStack.Pop();
                                UnrollRecursionContexts(parentContext.Item1);
                                return result;
                            }
                            else
                            {
                                ExitRule();
                                return rootContext;
                            }
                        }
                        VisitRuleStopState(p);
                        break;
                    }

                    default:
                    {
                        try
                        {
                            VisitState(p);
                        }
                        catch (RecognitionException e)
                        {
                            State = _atn.ruleToStopState[p.ruleIndex].stateNumber;
                            Context.exception = e;
                            ErrorHandler.ReportError(this, e);
                            ErrorHandler.Recover(this, e);
                        }
                        break;
                    }
                }
            }
        }

 /// <summary>
 /// For repeated use of a tree pattern, compile it to a
 /// <see cref="ParseTreePattern"/>
 /// using this method.
 /// </summary>
 public virtual ParseTreePattern Compile(string pattern, int patternRuleIndex)
 {
     IList<IToken> tokenList = Tokenize(pattern);
     ListTokenSource tokenSrc = new ListTokenSource(tokenList);
     CommonTokenStream tokens = new CommonTokenStream(tokenSrc);
     ParserInterpreter parserInterp = new ParserInterpreter(parser.GrammarFileName, Arrays.AsList(parser.TokenNames), Arrays.AsList(parser.RuleNames), parser.GetATNWithBypassAlts(), tokens);
     IParseTree tree = null;
     try
     {
         parserInterp.ErrorHandler = new BailErrorStrategy();
         tree = parserInterp.Parse(patternRuleIndex);
     }
     catch (ParseCanceledException e)
     {
         //			System.out.println("pattern tree = "+tree.toStringTree(parserInterp));
         throw (RecognitionException)e.InnerException;
     }
     catch (RecognitionException)
     {
         throw;
     }
     catch (Exception e)
     {
         throw new ParseTreePatternMatcher.CannotInvokeStartRule(e);
     }
     // Make sure tree pattern compilation checks for a complete parse
     if (tokens.La(1) != TokenConstants.Eof)
     {
         throw new ParseTreePatternMatcher.StartRuleDoesNotConsumeFullPattern();
     }
     return new ParseTreePattern(this, pattern, patternRuleIndex, tree);
 }