DefaultErrorStrategy (ANTLR 4 Runtime 4.0 API)

java.lang.Object
- org.antlr.v4.runtime.DefaultErrorStrategy

All Implemented Interfaces:

ANTLRErrorStrategy

Direct Known Subclasses:

BailErrorStrategy
```
public class DefaultErrorStrategy
extends Object
implements ANTLRErrorStrategy
```
This is the default error handling mechanism for ANTLR parsers and tree parsers.

Field Summary

Fields
Modifier and Type	Field and Description
`protected TokenFactory<?>`	`_factory` How to create token objects
`protected boolean`	`errorRecoveryMode` This is true after we see an error and before having successfully matched a token.
`protected int`	`lastErrorIndex` The index into the input stream where the last error occurred.
`protected IntervalSet`	`lastErrorStates`

Constructor Summary

Constructors
Constructor and Description

DefaultErrorStrategy()

Constructors
Constructor and Description
`DefaultErrorStrategy()`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`beginErrorCondition(Parser recognizer)` Notify handler that parser has entered an error state.
`void`	`consumeUntil(Parser recognizer, IntervalSet set)` Consume tokens until one matches the given token set
`void`	`endErrorCondition(Parser recognizer)` Reset the error handler.
`protected String`	`escapeWSAndQuote(String s)`
`protected IntervalSet`	`getErrorRecoverySet(Parser recognizer)`
`IntervalSet`	`getExpectedTokens(Parser recognizer)`
`protected Token`	`getMissingSymbol(Parser recognizer)` Conjure up a missing token during error recovery.
`protected String`	`getSymbolText(Token symbol)`
`protected int`	`getSymbolType(Token symbol)`
`String`	`getTokenErrorDisplay(Token t)` How should a token be displayed in an error message? The default is to display just the text, but during development you might want to have a lot of information spit out.
`boolean`	`inErrorRecoveryMode(Parser recognizer)` Is the parser in the process of recovering from an error? Upon a syntax error, the parser enters recovery mode and stays there until the next successful match of a token.
`void`	`recover(Parser recognizer, RecognitionException e)` Recover from NoViableAlt errors.
`Token`	`recoverInline(Parser recognizer)` Attempt to recover from a single missing or extra token.
`void`	`reportError(Parser recognizer, RecognitionException e)` Report any kind of RecognitionException.
`void`	`reportFailedPredicate(Parser recognizer, FailedPredicateException e)`
`void`	`reportInputMismatch(Parser recognizer, InputMismatchException e)`
`void`	`reportMissingToken(Parser recognizer)`
`void`	`reportNoViableAlternative(Parser recognizer, NoViableAltException e)`
`void`	`reportUnwantedToken(Parser recognizer)`
`void`	`setTokenFactory(TokenFactory<?> factory)` To create missing tokens, we need a factory
`Token`	`singleTokenDeletion(Parser recognizer)`
`boolean`	`singleTokenInsertion(Parser recognizer)`
`void`	`sync(Parser recognizer)` Make sure that the current lookahead symbol is consistent with what were expecting at this point in the ATN.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - _factory
```
protected TokenFactory<?> _factory
```
    How to create token objects
  - errorRecoveryMode
```
protected boolean errorRecoveryMode
```
    This is true after we see an error and before having successfully matched a token. Prevents generation of more than one error message per error.
  - lastErrorIndex
```
protected int lastErrorIndex
```
    The index into the input stream where the last error occurred. This is used to prevent infinite loops where an error is found but no token is consumed during recovery...another error is found, ad nauseum. This is a failsafe mechanism to guarantee that at least one token/tree node is consumed for two errors.
  - lastErrorStates
```
protected IntervalSet lastErrorStates
```
- Constructor Detail
  - DefaultErrorStrategy
```
public DefaultErrorStrategy()
```
- Method Detail
  - setTokenFactory
```
public void setTokenFactory(TokenFactory<?> factory)
```
    Description copied from interface: ANTLRErrorStrategy
    
    To create missing tokens, we need a factory
    
    Specified by:
    
    setTokenFactory in interface ANTLRErrorStrategy
  - beginErrorCondition
```
public void beginErrorCondition(Parser recognizer)
```
    Description copied from interface: ANTLRErrorStrategy
    
    Notify handler that parser has entered an error state. The parser currently doesn't call this--the handler itself calls this in report error methods. But, for symmetry with endErrorCondition, this method is in the interface.
    
    Specified by:
    
    beginErrorCondition in interface ANTLRErrorStrategy
  - inErrorRecoveryMode
```
public boolean inErrorRecoveryMode(Parser recognizer)
```
    Description copied from interface: ANTLRErrorStrategy
    
    Is the parser in the process of recovering from an error? Upon a syntax error, the parser enters recovery mode and stays there until the next successful match of a token. In this way, we can avoid sending out spurious error messages. We only want one error message per syntax error
    
    Specified by:
    
    inErrorRecoveryMode in interface ANTLRErrorStrategy
  - endErrorCondition
```
public void endErrorCondition(Parser recognizer)
```
    Description copied from interface: ANTLRErrorStrategy
    
    Reset the error handler. Call this when the parser matches a valid token (indicating no longer in recovery mode) and from its own reset method.
    
    Specified by:
    
    endErrorCondition in interface ANTLRErrorStrategy
  - reportError
```
public void reportError(Parser recognizer,
               RecognitionException e)
                 throws RecognitionException
```
    Description copied from interface: ANTLRErrorStrategy
    
    Report any kind of RecognitionException.
    
    Specified by:
    
    reportError in interface ANTLRErrorStrategy
    
    Throws:
    
    RecognitionException
  - recover
```
public void recover(Parser recognizer,
           RecognitionException e)
```
    Recover from NoViableAlt errors. Also there could be a mismatched token that the match() routine could not recover from.
    
    Specified by:
    
    recover in interface ANTLRErrorStrategy
  - sync
```
public void sync(Parser recognizer)
```
    Make sure that the current lookahead symbol is consistent with what were expecting at this point in the ATN. At the start of a sub rule upon error, sync() performs single token deletion, if possible. If it can't do that, it bails on the current rule and uses the default error recovery, which consumes until the resynchronization set of the current rule. If the sub rule is optional, ()? or ()* or optional alternative, then the expected set includes what follows the subrule. During loop iteration, it consumes until it sees a token that can start a sub rule or what follows loop. Yes, that is pretty aggressive. We opt to stay in the loop as long as possible.
    
    Specified by:
    
    sync in interface ANTLRErrorStrategy
  - reportNoViableAlternative
```
public void reportNoViableAlternative(Parser recognizer,
                             NoViableAltException e)
                               throws RecognitionException
```
    Throws:
    
    RecognitionException
  - reportInputMismatch
```
public void reportInputMismatch(Parser recognizer,
                       InputMismatchException e)
                         throws RecognitionException
```
    Throws:
    
    RecognitionException
  - reportFailedPredicate
```
public void reportFailedPredicate(Parser recognizer,
                         FailedPredicateException e)
                           throws RecognitionException
```
    Throws:
    
    RecognitionException
  - reportUnwantedToken
```
public void reportUnwantedToken(Parser recognizer)
```
  - reportMissingToken
```
public void reportMissingToken(Parser recognizer)
```
  - recoverInline
```
public Token recoverInline(Parser recognizer)
                    throws RecognitionException
```
    Attempt to recover from a single missing or extra token. EXTRA TOKEN LA(1) is not what we are looking for. If LA(2) has the right token, however, then assume LA(1) is some extra spurious token. Delete it and LA(2) as if we were doing a normal match(), which advances the input. MISSING TOKEN If current token is consistent with what could come after ttype then it is ok to "insert" the missing token, else throw exception For example, Input "i=(3;" is clearly missing the ')'. When the parser returns from the nested call to expr, it will have call chain: stat -> expr -> atom and it will be trying to match the ')' at this point in the derivation: => ID '=' '(' INT ')' ('+' atom)* ';' ^ match() will see that ';' doesn't match ')' and report a mismatched token error. To recover, it sees that LA(1)==';' is in the set of tokens that can follow the ')' token reference in rule atom. It can assume that you forgot the ')'.
    
    Specified by:
    
    recoverInline in interface ANTLRErrorStrategy
    
    Throws:
    
    RecognitionException
  - singleTokenInsertion
```
public boolean singleTokenInsertion(Parser recognizer)
```
  - singleTokenDeletion
```
public Token singleTokenDeletion(Parser recognizer)
```
  - getMissingSymbol
```
protected Token getMissingSymbol(Parser recognizer)
```
    Conjure up a missing token during error recovery. The recognizer attempts to recover from single missing symbols. But, actions might refer to that missing symbol. For example, x=ID {f($x);}. The action clearly assumes that there has been an identifier matched previously and that $x points at that token. If that token is missing, but the next token in the stream is what we want we assume that this token is missing and we keep going. Because we have to return some token to replace the missing token, we have to conjure one up. This method gives the user control over the tokens returned for missing tokens. Mostly, you will want to create something special for identifier tokens. For literals such as '{' and ',', the default action in the parser or tree parser works. It simply creates a CommonToken of the appropriate type. The text will be the token. If you change what tokens must be created by the lexer, override this method to create the appropriate tokens.
  - getExpectedTokens
```
public IntervalSet getExpectedTokens(Parser recognizer)
```
  - getTokenErrorDisplay
```
public String getTokenErrorDisplay(Token t)
```
    How should a token be displayed in an error message? The default is to display just the text, but during development you might want to have a lot of information spit out. Override in that case to use t.toString() (which, for CommonToken, dumps everything about the token). This is better than forcing you to override a method in your token objects because you don't have to go modify your lexer so that it creates a new Java type.
  - getSymbolText
```
protected String getSymbolText(@NotNull
                   Token symbol)
```
  - getSymbolType
```
protected int getSymbolType(@NotNull
                Token symbol)
```
  - escapeWSAndQuote
```
protected String escapeWSAndQuote(String s)
```
  - getErrorRecoverySet
```
protected IntervalSet getErrorRecoverySet(Parser recognizer)
```
  - consumeUntil
```
public void consumeUntil(Parser recognizer,
                IntervalSet set)
```
    Consume tokens until one matches the given token set

Class DefaultErrorStrategy

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

_factory

errorRecoveryMode

lastErrorIndex

lastErrorStates

Constructor Detail

DefaultErrorStrategy

Method Detail

setTokenFactory

beginErrorCondition

inErrorRecoveryMode

endErrorCondition

reportError

recover

sync

reportNoViableAlternative

reportInputMismatch

reportFailedPredicate

reportUnwantedToken

reportMissingToken

recoverInline

singleTokenInsertion

singleTokenDeletion

getMissingSymbol

getExpectedTokens

getTokenErrorDisplay

getSymbolText

getSymbolType

escapeWSAndQuote

getErrorRecoverySet

consumeUntil