1324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver/* 2324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * [The "BSD licence"] 3324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Copyright (c) 2005-2008 Terence Parr 4324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * All rights reserved. 5324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 6324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Conversion to C#: 7324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Copyright (c) 2008-2009 Sam Harwell, Pixel Mine, Inc. 8324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * All rights reserved. 9324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 10324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Redistribution and use in source and binary forms, with or without 11324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * modification, are permitted provided that the following conditions 12324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * are met: 13324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 1. Redistributions of source code must retain the above copyright 14324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * notice, this list of conditions and the following disclaimer. 15324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 2. Redistributions in binary form must reproduce the above copyright 16324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * notice, this list of conditions and the following disclaimer in the 17324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * documentation and/or other materials provided with the distribution. 18324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 3. The name of the author may not be used to endorse or promote products 19324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * derived from this software without specific prior written permission. 20324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 21324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 25324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 26324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 30324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 32324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 33324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruvernamespace Antlr.Runtime { 34324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver using System.Collections.Generic; 35324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 36324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver using ArgumentNullException = System.ArgumentNullException; 37324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver using Array = System.Array; 38324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver using Conditional = System.Diagnostics.ConditionalAttribute; 39324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver using Exception = System.Exception; 40324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver using IDebugEventListener = Antlr.Runtime.Debug.IDebugEventListener; 41324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver using MethodBase = System.Reflection.MethodBase; 42324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver using NotSupportedException = System.NotSupportedException; 43324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver using Regex = System.Text.RegularExpressions.Regex; 44324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver using StackFrame = System.Diagnostics.StackFrame; 45324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver using StackTrace = System.Diagnostics.StackTrace; 46324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver using TextWriter = System.IO.TextWriter; 47324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver using Type = System.Type; 48324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 49324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary> 50324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * A generic recognizer that can handle recognizers generated from 51324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * lexer, parser, and tree grammars. This is all the parsing 52324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * support code essentially; most of it is error recovery stuff and 53324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * backtracking. 54324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </summary> 55324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 56324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public abstract class BaseRecognizer { 57324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public const int MemoRuleFailed = -2; 58324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public const int MemoRuleUnknown = -1; 59324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public const int InitialFollowStackSize = 100; 60324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 61324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // copies from Token object for convenience in actions 62324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public const int DefaultTokenChannel = TokenChannels.Default; 63324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public const int Hidden = TokenChannels.Hidden; 64324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 65324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public const string NextTokenRuleName = "nextToken"; 66324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 67324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary> 68324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * State of a lexer, parser, or tree parser are collected into a state 69324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * object so the state can be shared. This sharing is needed to 70324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * have one grammar import others and share same error variables 71324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * and other state variables. It's a kind of explicit multiple 72324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * inheritance via delegation of methods and shared state. 73324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </summary> 74324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 75324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected internal RecognizerSharedState state; 76324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 77324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public BaseRecognizer() 78324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver : this(new RecognizerSharedState()) { 79324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 80324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 81324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public BaseRecognizer(RecognizerSharedState state) { 82324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (state == null) { 83324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state = new RecognizerSharedState(); 84324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 85324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver this.state = state; 86324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver InitDFAs(); 87324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 88324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 89324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public TextWriter TraceDestination { 90324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver get; 91324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver set; 92324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 93324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 94324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual void InitDFAs() { 95324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 96324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 97324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary>reset the parser's state; subclasses must rewinds the input stream</summary> */ 98324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual void Reset() { 99324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // wack everything related to error recovery 100324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (state == null) { 101324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return; // no shared state work to do 102324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 103324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state._fsp = -1; 104324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.errorRecovery = false; 105324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.lastErrorIndex = -1; 106324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.failed = false; 107324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.syntaxErrors = 0; 108324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // wack everything related to backtracking and memoization 109324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.backtracking = 0; 110324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver for (int i = 0; state.ruleMemo != null && i < state.ruleMemo.Length; i++) { // wipe cache 111324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.ruleMemo[i] = null; 112324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 113324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 114324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 115324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 116324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary> 117324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Match current input symbol against ttype. Attempt 118324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * single token insertion or deletion error recovery. If 119324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * that fails, throw MismatchedTokenException. 120324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </summary> 121324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 122324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * <remarks> 123324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * To turn off single token insertion or deletion error 124324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * recovery, override recoverFromMismatchedToken() and have it 125324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * throw an exception. See TreeParser.recoverFromMismatchedToken(). 126324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * This way any error in a rule will cause an exception and 127324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * immediate exit from rule. Rule would recover by resynchronizing 128324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * to the set of symbols that can follow rule ref. 129324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </remarks> 130324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 131324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual object Match(IIntStream input, int ttype, BitSet follow) { 132324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver //System.out.println("match "+((TokenStream)input).LT(1)); 133324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver object matchedSymbol = GetCurrentInputSymbol(input); 134324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (input.LA(1) == ttype) { 135324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver input.Consume(); 136324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.errorRecovery = false; 137324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.failed = false; 138324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return matchedSymbol; 139324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 140324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (state.backtracking > 0) { 141324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.failed = true; 142324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return matchedSymbol; 143324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 144324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver matchedSymbol = RecoverFromMismatchedToken(input, ttype, follow); 145324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return matchedSymbol; 146324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 147324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 148324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary>Match the wildcard: in a symbol</summary> */ 149324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual void MatchAny(IIntStream input) { 150324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.errorRecovery = false; 151324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.failed = false; 152324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver input.Consume(); 153324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 154324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 155324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual bool MismatchIsUnwantedToken(IIntStream input, int ttype) { 156324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return input.LA(2) == ttype; 157324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 158324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 159324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual bool MismatchIsMissingToken(IIntStream input, BitSet follow) { 160324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (follow == null) { 161324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // we have no information about the follow; we can only consume 162324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // a single token and hope for the best 163324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return false; 164324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 165324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // compute what can follow this grammar element reference 166324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (follow.Member(TokenTypes.EndOfRule)) { 167324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver BitSet viableTokensFollowingThisRule = ComputeContextSensitiveRuleFOLLOW(); 168324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver follow = follow.Or(viableTokensFollowingThisRule); 169324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (state._fsp >= 0) { // remove EOR if we're not the start symbol 170324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver follow.Remove(TokenTypes.EndOfRule); 171324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 172324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 173324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // if current token is consistent with what could come after set 174324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // then we know we're missing a token; error recovery is free to 175324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // "insert" the missing token 176324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 177324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver //System.out.println("viable tokens="+follow.toString(getTokenNames())); 178324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver //System.out.println("LT(1)="+((TokenStream)input).LT(1)); 179324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 180324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // BitSet cannot handle negative numbers like -1 (EOF) so I leave EOR 181324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // in follow set to indicate that the fall of the start symbol is 182324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // in the set (EOF can follow). 183324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (follow.Member(input.LA(1)) || follow.Member(TokenTypes.EndOfRule)) { 184324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver //System.out.println("LT(1)=="+((TokenStream)input).LT(1)+" is consistent with what follows; inserting..."); 185324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return true; 186324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 187324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return false; 188324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 189324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 190324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary>Report a recognition problem.</summary> 191324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 192324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * <remarks> 193324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * This method sets errorRecovery to indicate the parser is recovering 194324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * not parsing. Once in recovery mode, no errors are generated. 195324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * To get out of recovery mode, the parser must successfully match 196324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * a token (after a resync). So it will go: 197324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 198324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 1. error occurs 199324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 2. enter recovery mode, report error 200324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 3. consume until token found in resynch set 201324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 4. try to resume parsing 202324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 5. next match() will reset errorRecovery mode 203324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 204324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * If you override, make sure to update syntaxErrors if you care about that. 205324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </remarks> 206324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 207324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual void ReportError(RecognitionException e) { 208324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // if we've already reported an error and have not matched a token 209324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // yet successfully, don't report any errors. 210324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (state.errorRecovery) { 211324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver //System.err.print("[SPURIOUS] "); 212324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return; 213324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 214324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.syntaxErrors++; // don't count spurious 215324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.errorRecovery = true; 216324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 217324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver DisplayRecognitionError(this.TokenNames, e); 218324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 219324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 220324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual void DisplayRecognitionError(string[] tokenNames, 221324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver RecognitionException e) { 222324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver string hdr = GetErrorHeader(e); 223324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver string msg = GetErrorMessage(e, tokenNames); 224324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver EmitErrorMessage(hdr + " " + msg); 225324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 226324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 227324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary>What error message should be generated for the various exception types?</summary> 228324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 229324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * <remarks> 230324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Not very object-oriented code, but I like having all error message 231324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * generation within one method rather than spread among all of the 232324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * exception classes. This also makes it much easier for the exception 233324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * handling because the exception classes do not have to have pointers back 234324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * to this object to access utility routines and so on. Also, changing 235324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * the message for an exception type would be difficult because you 236324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * would have to subclassing exception, but then somehow get ANTLR 237324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * to make those kinds of exception objects instead of the default. 238324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * This looks weird, but trust me--it makes the most sense in terms 239324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * of flexibility. 240324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 241324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * For grammar debugging, you will want to override this to add 242324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * more information such as the stack frame with 243324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * getRuleInvocationStack(e, this.getClass().getName()) and, 244324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * for no viable alts, the decision description and state etc... 245324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 246324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Override this to change the message generated for one or more 247324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * exception types. 248324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </remarks> 249324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 250324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual string GetErrorMessage(RecognitionException e, string[] tokenNames) { 251324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver string msg = e.Message; 252324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (e is UnwantedTokenException) { 253324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver UnwantedTokenException ute = (UnwantedTokenException)e; 254324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver string tokenName = "<unknown>"; 255324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (ute.Expecting == TokenTypes.EndOfFile) { 256324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver tokenName = "EndOfFile"; 257324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } else { 258324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver tokenName = tokenNames[ute.Expecting]; 259324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 260324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver msg = "extraneous input " + GetTokenErrorDisplay(ute.UnexpectedToken) + 261324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver " expecting " + tokenName; 262324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } else if (e is MissingTokenException) { 263324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver MissingTokenException mte = (MissingTokenException)e; 264324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver string tokenName = "<unknown>"; 265324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (mte.Expecting == TokenTypes.EndOfFile) { 266324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver tokenName = "EndOfFile"; 267324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } else { 268324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver tokenName = tokenNames[mte.Expecting]; 269324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 270324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver msg = "missing " + tokenName + " at " + GetTokenErrorDisplay(e.Token); 271324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } else if (e is MismatchedTokenException) { 272324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver MismatchedTokenException mte = (MismatchedTokenException)e; 273324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver string tokenName = "<unknown>"; 274324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (mte.Expecting == TokenTypes.EndOfFile) { 275324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver tokenName = "EndOfFile"; 276324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } else { 277324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver tokenName = tokenNames[mte.Expecting]; 278324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 279324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver msg = "mismatched input " + GetTokenErrorDisplay(e.Token) + 280324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver " expecting " + tokenName; 281324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } else if (e is MismatchedTreeNodeException) { 282324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver MismatchedTreeNodeException mtne = (MismatchedTreeNodeException)e; 283324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver string tokenName = "<unknown>"; 284324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (mtne.Expecting == TokenTypes.EndOfFile) { 285324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver tokenName = "EndOfFile"; 286324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } else { 287324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver tokenName = tokenNames[mtne.Expecting]; 288324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 289324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // workaround for a .NET framework bug (NullReferenceException) 290324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver string nodeText = (mtne.Node != null) ? mtne.Node.ToString() ?? string.Empty : string.Empty; 291324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver msg = "mismatched tree node: " + nodeText + " expecting " + tokenName; 292324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } else if (e is NoViableAltException) { 293324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver //NoViableAltException nvae = (NoViableAltException)e; 294324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // for development, can add "decision=<<"+nvae.grammarDecisionDescription+">>" 295324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // and "(decision="+nvae.decisionNumber+") and 296324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // "state "+nvae.stateNumber 297324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver msg = "no viable alternative at input " + GetTokenErrorDisplay(e.Token); 298324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } else if (e is EarlyExitException) { 299324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver //EarlyExitException eee = (EarlyExitException)e; 300324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // for development, can add "(decision="+eee.decisionNumber+")" 301324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver msg = "required (...)+ loop did not match anything at input " + 302324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver GetTokenErrorDisplay(e.Token); 303324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } else if (e is MismatchedSetException) { 304324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver MismatchedSetException mse = (MismatchedSetException)e; 305324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver msg = "mismatched input " + GetTokenErrorDisplay(e.Token) + 306324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver " expecting set " + mse.Expecting; 307324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } else if (e is MismatchedNotSetException) { 308324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver MismatchedNotSetException mse = (MismatchedNotSetException)e; 309324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver msg = "mismatched input " + GetTokenErrorDisplay(e.Token) + 310324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver " expecting set " + mse.Expecting; 311324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } else if (e is FailedPredicateException) { 312324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver FailedPredicateException fpe = (FailedPredicateException)e; 313324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver msg = "rule " + fpe.RuleName + " failed predicate: {" + 314324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver fpe.PredicateText + "}?"; 315324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 316324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return msg; 317324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 318324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 319324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary> 320324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Get number of recognition errors (lexer, parser, tree parser). Each 321324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * recognizer tracks its own number. So parser and lexer each have 322324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * separate count. Does not count the spurious errors found between 323324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * an error and next valid token match 324324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </summary> 325324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 326324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * <seealso cref="reportError()"/> 327324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 328324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual int NumberOfSyntaxErrors { 329324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver get { 330324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return state.syntaxErrors; 331324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 332324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 333324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 334324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary>What is the error header, normally line/character position information?</summary> */ 335324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual string GetErrorHeader(RecognitionException e) { 336324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return "line " + e.Line + ":" + (e.CharPositionInLine + 1); 337324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 338324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 339324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary> 340324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * How should a token be displayed in an error message? The default 341324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * is to display just the text, but during development you might 342324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * want to have a lot of information spit out. Override in that case 343324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * to use t.ToString() (which, for CommonToken, dumps everything about 344324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * the token). This is better than forcing you to override a method in 345324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * your token objects because you don't have to go modify your lexer 346324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * so that it creates a new Java type. 347324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </summary> 348324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 349324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual string GetTokenErrorDisplay(IToken t) { 350324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver string s = t.Text; 351324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (s == null) { 352324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (t.Type == TokenTypes.EndOfFile) { 353324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver s = "<EOF>"; 354324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } else { 355324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver s = "<" + t.Type + ">"; 356324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 357324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 358324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver s = Regex.Replace(s, "\n", "\\\\n"); 359324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver s = Regex.Replace(s, "\r", "\\\\r"); 360324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver s = Regex.Replace(s, "\t", "\\\\t"); 361324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return "'" + s + "'"; 362324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 363324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 364324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary>Override this method to change where error messages go</summary> */ 365324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual void EmitErrorMessage(string msg) { 366324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (TraceDestination != null) 367324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver TraceDestination.WriteLine(msg); 368324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 369324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 370324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary> 371324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Recover from an error found on the input stream. This is 372324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * for NoViableAlt and mismatched symbol exceptions. If you enable 373324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * single token insertion and deletion, this will usually not 374324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * handle mismatched symbol exceptions but there could be a mismatched 375324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * token that the match() routine could not recover from. 376324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </summary> 377324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 378324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual void Recover(IIntStream input, RecognitionException re) { 379324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (state.lastErrorIndex == input.Index) { 380324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // uh oh, another error at same token index; must be a case 381324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // where LT(1) is in the recovery token set so nothing is 382324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // consumed; consume a single token so at least to prevent 383324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // an infinite loop; this is a failsafe. 384324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver input.Consume(); 385324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 386324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.lastErrorIndex = input.Index; 387324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver BitSet followSet = ComputeErrorRecoverySet(); 388324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver BeginResync(); 389324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ConsumeUntil(input, followSet); 390324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver EndResync(); 391324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 392324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 393324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary> 394324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * A hook to listen in on the token consumption during error recovery. 395324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * The DebugParser subclasses this to fire events to the listenter. 396324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </summary> 397324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 398324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual void BeginResync() { 399324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 400324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 401324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual void EndResync() { 402324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 403324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 404324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /* Compute the error recovery set for the current rule. During 405324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * rule invocation, the parser pushes the set of tokens that can 406324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * follow that rule reference on the stack; this amounts to 407324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * computing FIRST of what follows the rule reference in the 408324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * enclosing rule. This local follow set only includes tokens 409324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * from within the rule; i.e., the FIRST computation done by 410324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * ANTLR stops at the end of a rule. 411324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 412324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * EXAMPLE 413324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 414324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * When you find a "no viable alt exception", the input is not 415324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * consistent with any of the alternatives for rule r. The best 416324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * thing to do is to consume tokens until you see something that 417324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * can legally follow a call to r *or* any rule that called r. 418324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * You don't want the exact set of viable next tokens because the 419324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * input might just be missing a token--you might consume the 420324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * rest of the input looking for one of the missing tokens. 421324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 422324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Consider grammar: 423324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 424324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * a : '[' b ']' 425324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * | '(' b ')' 426324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * ; 427324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * b : c '^' INT ; 428324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * c : ID 429324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * | INT 430324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * ; 431324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 432324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * At each rule invocation, the set of tokens that could follow 433324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * that rule is pushed on a stack. Here are the various "local" 434324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * follow sets: 435324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 436324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * FOLLOW(b1_in_a) = FIRST(']') = ']' 437324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * FOLLOW(b2_in_a) = FIRST(')') = ')' 438324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * FOLLOW(c_in_b) = FIRST('^') = '^' 439324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 440324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Upon erroneous input "[]", the call chain is 441324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 442324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * a -> b -> c 443324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 444324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * and, hence, the follow context stack is: 445324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 446324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * depth local follow set after call to rule 447324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 0 <EOF> a (from main()) 448324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 1 ']' b 449324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 3 '^' c 450324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 451324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Notice that ')' is not included, because b would have to have 452324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * been called from a different context in rule a for ')' to be 453324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * included. 454324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 455324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * For error recovery, we cannot consider FOLLOW(c) 456324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * (context-sensitive or otherwise). We need the combined set of 457324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * all context-sensitive FOLLOW sets--the set of all tokens that 458324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * could follow any reference in the call chain. We need to 459324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * resync to one of those tokens. Note that FOLLOW(c)='^' and if 460324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * we resync'd to that token, we'd consume until EOF. We need to 461324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * sync to context-sensitive FOLLOWs for a, b, and c: {']','^'}. 462324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * In this case, for input "[]", LA(1) is in this set so we would 463324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * not consume anything and after printing an error rule c would 464324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * return normally. It would not find the required '^' though. 465324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * At this point, it gets a mismatched token error and throws an 466324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * exception (since LA(1) is not in the viable following token 467324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * set). The rule exception handler tries to recover, but finds 468324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * the same recovery set and doesn't consume anything. Rule b 469324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * exits normally returning to rule a. Now it finds the ']' (and 470324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * with the successful match exits errorRecovery mode). 471324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 472324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * So, you cna see that the parser walks up call chain looking 473324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * for the token that was a member of the recovery set. 474324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 475324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Errors are not generated in errorRecovery mode. 476324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 477324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * ANTLR's error recovery mechanism is based upon original ideas: 478324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 479324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * "Algorithms + Data Structures = Programs" by Niklaus Wirth 480324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 481324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * and 482324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 483324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * "A note on error recovery in recursive descent parsers": 484324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * http://portal.acm.org/citation.cfm?id=947902.947905 485324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 486324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Later, Josef Grosch had some good ideas: 487324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 488324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * "Efficient and Comfortable Error Recovery in Recursive Descent 489324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Parsers": 490324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * ftp://www.cocolab.com/products/cocktail/doca4.ps/ell.ps.zip 491324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 492324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Like Grosch I implemented local FOLLOW sets that are combined 493324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * at run-time upon error to avoid overhead during parsing. 494324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 495324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual BitSet ComputeErrorRecoverySet() { 496324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return CombineFollows(false); 497324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 498324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 499324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary> 500324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Compute the context-sensitive FOLLOW set for current rule. 501324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * This is set of token types that can follow a specific rule 502324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * reference given a specific call chain. You get the set of 503324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * viable tokens that can possibly come next (lookahead depth 1) 504324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * given the current call chain. Contrast this with the 505324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * definition of plain FOLLOW for rule r: 506324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </summary> 507324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 508324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * FOLLOW(r)={x | S=>*alpha r beta in G and x in FIRST(beta)} 509324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 510324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * where x in T* and alpha, beta in V*; T is set of terminals and 511324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * V is the set of terminals and nonterminals. In other words, 512324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * FOLLOW(r) is the set of all tokens that can possibly follow 513324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * references to r in *any* sentential form (context). At 514324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * runtime, however, we know precisely which context applies as 515324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * we have the call chain. We may compute the exact (rather 516324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * than covering superset) set of following tokens. 517324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 518324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * For example, consider grammar: 519324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 520324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * stat : ID '=' expr ';' // FOLLOW(stat)=={EOF} 521324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * | "return" expr '.' 522324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * ; 523324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * expr : atom ('+' atom)* ; // FOLLOW(expr)=={';','.',')'} 524324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * atom : INT // FOLLOW(atom)=={'+',')',';','.'} 525324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * | '(' expr ')' 526324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * ; 527324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 528324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * The FOLLOW sets are all inclusive whereas context-sensitive 529324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * FOLLOW sets are precisely what could follow a rule reference. 530324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * For input input "i=(3);", here is the derivation: 531324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 532324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * stat => ID '=' expr ';' 533324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * => ID '=' atom ('+' atom)* ';' 534324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * => ID '=' '(' expr ')' ('+' atom)* ';' 535324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * => ID '=' '(' atom ')' ('+' atom)* ';' 536324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * => ID '=' '(' INT ')' ('+' atom)* ';' 537324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * => ID '=' '(' INT ')' ';' 538324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 539324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * At the "3" token, you'd have a call chain of 540324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 541324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * stat -> expr -> atom -> expr -> atom 542324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 543324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * What can follow that specific nested ref to atom? Exactly ')' 544324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * as you can see by looking at the derivation of this specific 545324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * input. Contrast this with the FOLLOW(atom)={'+',')',';','.'}. 546324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 547324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * You want the exact viable token set when recovering from a 548324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * token mismatch. Upon token mismatch, if LA(1) is member of 549324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * the viable next token set, then you know there is most likely 550324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * a missing token in the input stream. "Insert" one by just not 551324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * throwing an exception. 552324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 553324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual BitSet ComputeContextSensitiveRuleFOLLOW() { 554324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return CombineFollows(true); 555324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 556324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 557324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // what is exact? it seems to only add sets from above on stack 558324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // if EOR is in set i. When it sees a set w/o EOR, it stops adding. 559324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Why would we ever want them all? Maybe no viable alt instead of 560324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // mismatched token? 561324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual BitSet CombineFollows(bool exact) { 562324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver int top = state._fsp; 563324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver BitSet followSet = new BitSet(); 564324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver for (int i = top; i >= 0; i--) { 565324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver BitSet localFollowSet = (BitSet)state.following[i]; 566324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /* 567324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver System.out.println("local follow depth "+i+"="+ 568324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver localFollowSet.toString(getTokenNames())+")"); 569324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 570324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver followSet.OrInPlace(localFollowSet); 571324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (exact) { 572324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // can we see end of rule? 573324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (localFollowSet.Member(TokenTypes.EndOfRule)) { 574324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // Only leave EOR in set if at top (start rule); this lets 575324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // us know if have to include follow(start rule); i.e., EOF 576324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (i > 0) { 577324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver followSet.Remove(TokenTypes.EndOfRule); 578324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 579324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } else { // can't see end of rule, quit 580324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver break; 581324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 582324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 583324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 584324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return followSet; 585324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 586324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 587324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary>Attempt to recover from a single missing or extra token.</summary> 588324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 589324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * EXTRA TOKEN 590324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 591324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * LA(1) is not what we are looking for. If LA(2) has the right token, 592324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * however, then assume LA(1) is some extra spurious token. Delete it 593324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * and LA(2) as if we were doing a normal match(), which advances the 594324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * input. 595324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 596324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * MISSING TOKEN 597324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 598324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * If current token is consistent with what could come after 599324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * ttype then it is ok to "insert" the missing token, else throw 600324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * exception For example, Input "i=(3;" is clearly missing the 601324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * ')'. When the parser returns from the nested call to expr, it 602324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * will have call chain: 603324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 604324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * stat -> expr -> atom 605324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 606324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * and it will be trying to match the ')' at this point in the 607324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * derivation: 608324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 609324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * => ID '=' '(' INT ')' ('+' atom)* ';' 610324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * ^ 611324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * match() will see that ';' doesn't match ')' and report a 612324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * mismatched token error. To recover, it sees that LA(1)==';' 613324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * is in the set of tokens that can follow the ')' token 614324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * reference in rule atom. It can assume that you forgot the ')'. 615324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 616324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual object RecoverFromMismatchedToken(IIntStream input, int ttype, BitSet follow) { 617324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver RecognitionException e = null; 618324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // if next token is what we are looking for then "delete" this token 619324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (MismatchIsUnwantedToken(input, ttype)) { 620324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver e = new UnwantedTokenException(ttype, input, TokenNames); 621324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /* 622324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver System.err.println("recoverFromMismatchedToken deleting "+ 623324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ((TokenStream)input).LT(1)+ 624324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver " since "+((TokenStream)input).LT(2)+" is what we want"); 625324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 626324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver BeginResync(); 627324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver input.Consume(); // simply delete extra token 628324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver EndResync(); 629324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ReportError(e); // report after consuming so AW sees the token in the exception 630324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // we want to return the token we're actually matching 631324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver object matchedSymbol = GetCurrentInputSymbol(input); 632324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver input.Consume(); // move past ttype token as if all were ok 633324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return matchedSymbol; 634324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 635324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // can't recover with single token deletion, try insertion 636324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (MismatchIsMissingToken(input, follow)) { 637324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver object inserted = GetMissingSymbol(input, e, ttype, follow); 638324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver e = new MissingTokenException(ttype, input, inserted); 639324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ReportError(e); // report after inserting so AW sees the token in the exception 640324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return inserted; 641324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 642324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // even that didn't work; must throw the exception 643324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver e = new MismatchedTokenException(ttype, input, TokenNames); 644324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver throw e; 645324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 646324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 647324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** Not currently used */ 648324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual object RecoverFromMismatchedSet(IIntStream input, 649324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver RecognitionException e, 650324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver BitSet follow) { 651324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (MismatchIsMissingToken(input, follow)) { 652324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // System.out.println("missing token"); 653324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ReportError(e); 654324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // we don't know how to conjure up a token for sets yet 655324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return GetMissingSymbol(input, e, TokenTypes.Invalid, follow); 656324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 657324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver // TODO do single token deletion like above for Token mismatch 658324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver throw e; 659324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 660324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 661324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary> 662324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Match needs to return the current input symbol, which gets put 663324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * into the label for the associated token ref; e.g., x=ID. Token 664324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * and tree parsers need to return different objects. Rather than test 665324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * for input stream type or change the IntStream interface, I use 666324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * a simple method to ask the recognizer to tell me what the current 667324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * input symbol is. 668324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </summary> 669324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 670324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * <remarks>This is ignored for lexers.</remarks> 671324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 672324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual object GetCurrentInputSymbol(IIntStream input) { 673324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return null; 674324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 675324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 676324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary>Conjure up a missing token during error recovery.</summary> 677324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 678324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * <remarks> 679324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * The recognizer attempts to recover from single missing 680324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * symbols. But, actions might refer to that missing symbol. 681324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * For example, x=ID {f($x);}. The action clearly assumes 682324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * that there has been an identifier matched previously and that 683324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * $x points at that token. If that token is missing, but 684324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * the next token in the stream is what we want we assume that 685324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * this token is missing and we keep going. Because we 686324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * have to return some token to replace the missing token, 687324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * we have to conjure one up. This method gives the user control 688324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * over the tokens returned for missing tokens. Mostly, 689324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * you will want to create something special for identifier 690324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * tokens. For literals such as '{' and ',', the default 691324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * action in the parser or tree parser works. It simply creates 692324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * a CommonToken of the appropriate type. The text will be the token. 693324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * If you change what tokens must be created by the lexer, 694324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * override this method to create the appropriate tokens. 695324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </remarks> 696324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 697324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual object GetMissingSymbol(IIntStream input, 698324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver RecognitionException e, 699324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver int expectedTokenType, 700324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver BitSet follow) { 701324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return null; 702324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 703324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 704324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual void ConsumeUntil(IIntStream input, int tokenType) { 705324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver //System.out.println("consumeUntil "+tokenType); 706324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver int ttype = input.LA(1); 707324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver while (ttype != TokenTypes.EndOfFile && ttype != tokenType) { 708324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver input.Consume(); 709324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ttype = input.LA(1); 710324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 711324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 712324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 713324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary>Consume tokens until one matches the given token set</summary> */ 714324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual void ConsumeUntil(IIntStream input, BitSet set) { 715324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver //System.out.println("consumeUntil("+set.toString(getTokenNames())+")"); 716324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver int ttype = input.LA(1); 717324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver while (ttype != TokenTypes.EndOfFile && !set.Member(ttype)) { 718324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver //System.out.println("consume during recover LA(1)="+getTokenNames()[input.LA(1)]); 719324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver input.Consume(); 720324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver ttype = input.LA(1); 721324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 722324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 723324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 724324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary>Push a rule's follow set using our own hardcoded stack</summary> */ 725324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected void PushFollow(BitSet fset) { 726324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if ((state._fsp + 1) >= state.following.Length) { 727324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver Array.Resize(ref state.following, state.following.Length * 2); 728324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 729324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.following[++state._fsp] = fset; 730324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 731324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 732324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected void PopFollow() { 733324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state._fsp--; 734324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 735324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 736324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary> 737324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Return List<String> of the rules in your parser instance 738324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * leading up to a call to this method. You could override if 739324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * you want more details such as the file/line info of where 740324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * in the parser java code a rule is invoked. 741324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </summary> 742324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 743324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * <remarks> 744324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * This is very useful for error messages and for context-sensitive 745324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * error recovery. 746324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </remarks> 747324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 748324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual IList<string> GetRuleInvocationStack() { 749324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return GetRuleInvocationStack(new StackTrace(true)); 750324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 751324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 752324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary> 753324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * A more general version of GetRuleInvocationStack where you can 754324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * pass in the StackTrace of, for example, a RecognitionException 755324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * to get it's rule stack trace. 756324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </summary> 757324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 758324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public static IList<string> GetRuleInvocationStack(StackTrace trace) { 759324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (trace == null) 760324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver throw new ArgumentNullException("trace"); 761324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 762324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver List<string> rules = new List<string>(); 763324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver StackFrame[] stack = trace.GetFrames() ?? new StackFrame[0]; 764324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 765324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver for (int i = stack.Length - 1; i >= 0; i--) { 766324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver StackFrame frame = stack[i]; 767324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver MethodBase method = frame.GetMethod(); 768324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver GrammarRuleAttribute[] attributes = (GrammarRuleAttribute[])method.GetCustomAttributes(typeof(GrammarRuleAttribute), true); 769324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (attributes != null && attributes.Length > 0) 770324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver rules.Add(attributes[0].Name); 771324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 772324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 773324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return rules; 774324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 775324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 776324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual int BacktrackingLevel { 777324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver get { 778324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return state.backtracking; 779324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 780324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver set { 781324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.backtracking = value; 782324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 783324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 784324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 785324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary>Return whether or not a backtracking attempt failed.</summary> */ 786324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual bool Failed { 787324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver get { 788324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return state.failed; 789324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 790324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 791324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 792324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary> 793324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Used to print out token names like ID during debugging and 794324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * error reporting. The generated parsers implement a method 795324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * that overrides this to point to their String[] tokenNames. 796324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </summary> 797324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 798324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual string[] TokenNames { 799324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver get { 800324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return null; 801324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 802324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 803324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 804324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary> 805324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * For debugging and other purposes, might want the grammar name. 806324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Have ANTLR generate an implementation for this method. 807324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </summary> 808324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 809324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual string GrammarFileName { 810324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver get { 811324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return null; 812324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 813324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 814324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 815324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public abstract string SourceName { 816324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver get; 817324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 818324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 819324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary> 820324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * A convenience method for use most often with template rewrites. 821324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Convert a List<Token> to List<String> 822324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </summary> 823324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 824324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual List<string> ToStrings(ICollection<IToken> tokens) { 825324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (tokens == null) 826324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return null; 827324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 828324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver List<string> strings = new List<string>(tokens.Count); 829324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver foreach (IToken token in tokens) { 830324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver strings.Add(token.Text); 831324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 832324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 833324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return strings; 834324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 835324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 836324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary> 837324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Given a rule number and a start token index number, return 838324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * MEMO_RULE_UNKNOWN if the rule has not parsed input starting from 839324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * start index. If this rule has parsed input starting from the 840324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * start index before, then return where the rule stopped parsing. 841324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * It returns the index of the last token matched by the rule. 842324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </summary> 843324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 844324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * <remarks> 845324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * For now we use a hashtable and just the slow Object-based one. 846324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Later, we can make a special one for ints and also one that 847324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * tosses out data after we commit past input position i. 848324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </remarks> 849324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 850324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual int GetRuleMemoization(int ruleIndex, int ruleStartIndex) { 851324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (state.ruleMemo[ruleIndex] == null) { 852324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.ruleMemo[ruleIndex] = new Dictionary<int, int>(); 853324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 854324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 855324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver int stopIndex; 856324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (!state.ruleMemo[ruleIndex].TryGetValue(ruleStartIndex, out stopIndex)) 857324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return MemoRuleUnknown; 858324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 859324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return stopIndex; 860324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 861324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 862324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary> 863324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Has this rule already parsed input at the current index in the 864324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * input stream? Return the stop token index or MEMO_RULE_UNKNOWN. 865324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * If we attempted but failed to parse properly before, return 866324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * MEMO_RULE_FAILED. 867324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </summary> 868324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 869324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * <remarks> 870324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * This method has a side-effect: if we have seen this input for 871324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * this rule and successfully parsed before, then seek ahead to 872324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * 1 past the stop token matched for this rule last time. 873324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </remarks> 874324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 875324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual bool AlreadyParsedRule(IIntStream input, int ruleIndex) { 876324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver int stopIndex = GetRuleMemoization(ruleIndex, input.Index); 877324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stopIndex == MemoRuleUnknown) { 878324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return false; 879324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 880324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (stopIndex == MemoRuleFailed) { 881324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver //System.out.println("rule "+ruleIndex+" will never succeed"); 882324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.failed = true; 883324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } else { 884324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver //System.out.println("seen rule "+ruleIndex+" before; skipping ahead to @"+(stopIndex+1)+" failed="+state.failed); 885324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver input.Seek(stopIndex + 1); // jump to one past stop token 886324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 887324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return true; 888324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 889324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 890324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary> 891324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * Record whether or not this rule parsed the input at this position 892324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * successfully. Use a standard java hashtable for now. 893324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * </summary> 894324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 895324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual void Memoize(IIntStream input, 896324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver int ruleIndex, 897324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver int ruleStartIndex) { 898324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver int stopTokenIndex = state.failed ? MemoRuleFailed : input.Index - 1; 899324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (state.ruleMemo == null) { 900324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (TraceDestination != null) 901324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver TraceDestination.WriteLine("!!!!!!!!! memo array is null for " + GrammarFileName); 902324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 903324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (ruleIndex >= state.ruleMemo.Length) { 904324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (TraceDestination != null) 905324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver TraceDestination.WriteLine("!!!!!!!!! memo size is " + state.ruleMemo.Length + ", but rule index is " + ruleIndex); 906324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 907324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (state.ruleMemo[ruleIndex] != null) { 908324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver state.ruleMemo[ruleIndex][ruleStartIndex] = stopTokenIndex; 909324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 910324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 911324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 912324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver /** <summary>return how many rule/input-index pairs there are in total.</summary> 913324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver * TODO: this includes synpreds. :( 914324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver */ 915324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual int GetRuleMemoizationCacheSize() { 916324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver int n = 0; 917324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver for (int i = 0; state.ruleMemo != null && i < state.ruleMemo.Length; i++) { 918324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver var ruleMap = state.ruleMemo[i]; 919324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (ruleMap != null) { 920324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver n += ruleMap.Count; // how many input indexes are recorded? 921324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 922324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 923324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return n; 924324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 925324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 926324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver [Conditional("ANTLR_TRACE")] 927324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual void TraceIn(string ruleName, int ruleIndex, object inputSymbol) { 928324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (TraceDestination == null) 929324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return; 930324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 931324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver TraceDestination.Write("enter " + ruleName + " " + inputSymbol); 932324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (state.backtracking > 0) { 933324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver TraceDestination.Write(" backtracking=" + state.backtracking); 934324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 935324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver TraceDestination.WriteLine(); 936324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 937324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 938324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver [Conditional("ANTLR_TRACE")] 939324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual void TraceOut(string ruleName, int ruleIndex, object inputSymbol) { 940324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (TraceDestination == null) 941324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return; 942324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 943324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver TraceDestination.Write("exit " + ruleName + " " + inputSymbol); 944324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (state.backtracking > 0) { 945324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver TraceDestination.Write(" backtracking=" + state.backtracking); 946324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (state.failed) 947324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver TraceDestination.Write(" failed"); 948324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver else 949324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver TraceDestination.Write(" succeeded"); 950324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 951324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver TraceDestination.WriteLine(); 952324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 953324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 954324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver #region Debugging support 955324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver public virtual IDebugEventListener DebugListener { 956324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver get { 957324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver return null; 958324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 959324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 960324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 961324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver [Conditional("ANTLR_DEBUG")] 962324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual void DebugEnterRule(string grammarFileName, string ruleName) { 963324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver IDebugEventListener dbg = DebugListener; 964324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (dbg != null) 965324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver dbg.EnterRule(grammarFileName, ruleName); 966324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 967324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 968324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver [Conditional("ANTLR_DEBUG")] 969324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual void DebugExitRule(string grammarFileName, string ruleName) { 970324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver IDebugEventListener dbg = DebugListener; 971324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (dbg != null) 972324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver dbg.ExitRule(grammarFileName, ruleName); 973324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 974324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 975324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver [Conditional("ANTLR_DEBUG")] 976324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual void DebugEnterSubRule(int decisionNumber) { 977324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver IDebugEventListener dbg = DebugListener; 978324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (dbg != null) 979324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver dbg.EnterSubRule(decisionNumber); 980324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 981324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 982324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver [Conditional("ANTLR_DEBUG")] 983324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual void DebugExitSubRule(int decisionNumber) { 984324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver IDebugEventListener dbg = DebugListener; 985324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (dbg != null) 986324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver dbg.ExitSubRule(decisionNumber); 987324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 988324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 989324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver [Conditional("ANTLR_DEBUG")] 990324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual void DebugEnterAlt(int alt) { 991324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver IDebugEventListener dbg = DebugListener; 992324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (dbg != null) 993324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver dbg.EnterAlt(alt); 994324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 995324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 996324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver [Conditional("ANTLR_DEBUG")] 997324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual void DebugEnterDecision(int decisionNumber, bool couldBacktrack) { 998324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver IDebugEventListener dbg = DebugListener; 999324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (dbg != null) 1000324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver dbg.EnterDecision(decisionNumber, couldBacktrack); 1001324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 1002324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 1003324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver [Conditional("ANTLR_DEBUG")] 1004324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual void DebugExitDecision(int decisionNumber) { 1005324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver IDebugEventListener dbg = DebugListener; 1006324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (dbg != null) 1007324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver dbg.ExitDecision(decisionNumber); 1008324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 1009324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 1010324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver [Conditional("ANTLR_DEBUG")] 1011324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual void DebugLocation(int line, int charPositionInLine) { 1012324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver IDebugEventListener dbg = DebugListener; 1013324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (dbg != null) 1014324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver dbg.Location(line, charPositionInLine); 1015324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 1016324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 1017324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver [Conditional("ANTLR_DEBUG")] 1018324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual void DebugSemanticPredicate(bool result, string predicate) { 1019324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver IDebugEventListener dbg = DebugListener; 1020324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (dbg != null) 1021324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver dbg.SemanticPredicate(result, predicate); 1022324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 1023324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 1024324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver [Conditional("ANTLR_DEBUG")] 1025324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual void DebugBeginBacktrack(int level) { 1026324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver IDebugEventListener dbg = DebugListener; 1027324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (dbg != null) 1028324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver dbg.BeginBacktrack(level); 1029324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 1030324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 1031324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver [Conditional("ANTLR_DEBUG")] 1032324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual void DebugEndBacktrack(int level, bool successful) { 1033324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver IDebugEventListener dbg = DebugListener; 1034324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (dbg != null) 1035324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver dbg.EndBacktrack(level, successful); 1036324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 1037324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver 1038324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver [Conditional("ANTLR_DEBUG")] 1039324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver protected virtual void DebugRecognitionException(RecognitionException ex) { 1040324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver IDebugEventListener dbg = DebugListener; 1041324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver if (dbg != null) 1042324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver dbg.RecognitionException(ex); 1043324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 1044324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver #endregion 1045324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver } 1046324c4644fee44b9898524c09511bd33c3f12e2dfBen Gruver} 1047