ANTLR 4 Runtime 4.13.1 · org.antlr.v4.runtime.DefaultErrorStrategy

Modifier and Type	Field and Description
protected boolean	errorRecoveryMode Indicates whether the error strategy is currently "recovering from an error".
protected int	lastErrorIndex The index into the input stream where the last error occurred.
protected IntervalSet	lastErrorStates
protected ParserRuleContext	nextTokensContext This field is used to propagate information about the lookahead following the previous match.
protected int	nextTokensState

Access	Constructor and Description
public	DefaultErrorStrategy()

Method Summary

Modifier and Type	Method and Description
protected void	beginErrorCondition(Parser the parser instance recognizer) This method is called to enter error recovery mode when a recognition exception is reported.
protected void	consumeUntil(Parser recognizer, IntervalSet set) Consume tokens until one matches the given token set.
protected void	endErrorCondition(Parser recognizer) This method is called to leave error recovery mode after recovering from a recognition exception.
protected String	escapeWSAndQuote(String s)
protected IntervalSet	getErrorRecoverySet(Parser recognizer)
protected 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)
protected String	getTokenErrorDisplay(Token t) How should a token be displayed in an error message?
public boolean	inErrorRecoveryMode(Parser the parser instance recognizer) Implements org.antlr.v4.runtime.ANTLRErrorStrategy.inErrorRecoveryMode. Tests whether or not `recognizer` is in the process of recovering from an error.
public void	recover(Parser the parser instance recognizer, RecognitionException the recognition exception to recover from e) Implements org.antlr.v4.runtime.ANTLRErrorStrategy.recover. This method is called to recover from exception `e`.
public Token	recoverInline(Parser the parser instance recognizer) Implements org.antlr.v4.runtime.ANTLRErrorStrategy.recoverInline. This method is called when an unexpected symbol is encountered during an inline match operation, such as `Parser#match`.
public void	reportError(Parser the parser instance recognizer, RecognitionException the recognition exception to report e) Implements org.antlr.v4.runtime.ANTLRErrorStrategy.reportError. Report any kind of `RecognitionException`.
protected void	reportFailedPredicate(Parser the parser instance recognizer, FailedPredicateException the recognition exception e) This is called by `reportError` when the exception is a `FailedPredicateException`.
protected void	reportInputMismatch(Parser the parser instance recognizer, InputMismatchException the recognition exception e) This is called by `reportError` when the exception is an `InputMismatchException`.
public void	reportMatch(Parser the parser instance recognizer) Implements org.antlr.v4.runtime.ANTLRErrorStrategy.reportMatch. This method is called by when the parser successfully matches an input symbol.
protected void	reportMissingToken(Parser the parser instance recognizer) This method is called to report a syntax error which requires the insertion of a missing token into the input stream.
protected void	reportNoViableAlternative(Parser the parser instance recognizer, NoViableAltException the recognition exception e) This is called by `reportError` when the exception is a `NoViableAltException`.
protected void	reportUnwantedToken(Parser the parser instance recognizer) This method is called to report a syntax error which requires the removal of a token from the input stream.
public void	reset(Parser the parser instance recognizer) Implements org.antlr.v4.runtime.ANTLRErrorStrategy.reset. Reset the error handler state for the specified `recognizer`.
protected Token	Returns: the successfully matched `Token` instance if single-token deletion successfully recovers from the mismatched input, otherwise `null` singleTokenDeletion(Parser the parser instance recognizer) This method implements the single-token deletion inline error recovery strategy.
protected boolean	Returns: `true` if single-token insertion is a viable recovery strategy for the current mismatched input, otherwise `false` singleTokenInsertion(Parser the parser instance recognizer) This method implements the single-token insertion inline error recovery strategy.
public void	sync(Parser the parser instance recognizer) Implements org.antlr.v4.runtime.ANTLRErrorStrategy.sync. The default implementation of `ANTLRErrorStrategy#sync` makes sure that the current lookahead symbol is consistent with what were expecting at this point in the ATN.

Inherited from java.lang.Object:: clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

errorRecoveryMode	back to summary
protected boolean errorRecoveryMode Indicates whether the error strategy is currently "recovering from an error". This is used to suppress reporting multiple error messages while attempting to recover from a detected syntax error. See Also `inErrorRecoveryMode`

lastErrorIndex	back to summary
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	back to summary
protected IntervalSet lastErrorStates

nextTokensContext	back to summary
protected ParserRuleContext nextTokensContext This field is used to propagate information about the lookahead following the previous match. Since prediction prefers completing the current rule to error recovery efforts, error reporting may occur later than the original point where it was discoverable. The original context is used to compute the true expected sets as though the reporting occurred as early as possible.

nextTokensState	back to summary
protected int nextTokensState See Also `nextTokensContext`

DefaultErrorStrategy	back to summary
public DefaultErrorStrategy()

Method Detail

beginErrorCondition	back to summary
protected void beginErrorCondition(Parser recognizer) This method is called to enter error recovery mode when a recognition exception is reported. Parameters recognizer:Parser the parser instance

beginErrorCondition

back to summary

protected void beginErrorCondition(Parser recognizer)

This method is called to enter error recovery mode when a recognition exception is reported.

Parameters

recognizer:Parser: the parser instance

consumeUntil	back to summary
protected void consumeUntil(Parser recognizer, IntervalSet set) Consume tokens until one matches the given token set.

endErrorCondition	back to summary
protected void endErrorCondition(Parser recognizer) This method is called to leave error recovery mode after recovering from a recognition exception.

escapeWSAndQuote	back to summary
protected String escapeWSAndQuote(String s)

getErrorRecoverySet	back to summary
protected IntervalSet getErrorRecoverySet(Parser recognizer)

getExpectedTokens	back to summary
protected IntervalSet getExpectedTokens(Parser recognizer)

getMissingSymbol	back to summary
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.

getMissingSymbol

back to summary

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.

getSymbolText	back to summary
protected String getSymbolText(Token symbol)

getSymbolType	back to summary
protected int getSymbolType(Token symbol)

getTokenErrorDisplay	back to summary
protected 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.

getTokenErrorDisplay

back to summary

protected 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.

inErrorRecoveryMode back to summary

inErrorRecoveryMode	back to summary
public boolean inErrorRecoveryMode(Parser recognizer) Implements org.antlr.v4.runtime.ANTLRErrorStrategy.inErrorRecoveryMode. Doc from org.antlr.v4.runtime.ANTLRErrorStrategy.inErrorRecoveryMode. Tests whether or not `recognizer` is in the process of recovering from an error. In error recovery mode, `Parser#consume` adds symbols to the parse tree by calling `Parser#createErrorNode(ParserRuleContext, Token)` then `ParserRuleContext#addErrorNode(ErrorNode)` instead of `Parser#createTerminalNode(ParserRuleContext, Token)`. Parameters recognizer:Parser the parser instance Returns:boolean `true` if the parser is currently recovering from a parse error, otherwise `false` Annotations @Override

public boolean inErrorRecoveryMode(Parser recognizer)

Implements org.antlr.v4.runtime.ANTLRErrorStrategy.inErrorRecoveryMode.

Doc from org.antlr.v4.runtime.ANTLRErrorStrategy.inErrorRecoveryMode.

Tests whether or not recognizer is in the process of recovering from an error. In error recovery mode, Parser#consume adds symbols to the parse tree by calling Parser#createErrorNode(ParserRuleContext, Token) then ParserRuleContext#addErrorNode(ErrorNode) instead of Parser#createTerminalNode(ParserRuleContext, Token).

Parameters

recognizer:Parser: the parser instance

Returns:boolean

true if the parser is currently recovering from a parse error, otherwise false

Annotations

@Override

recover back to summary

recover	back to summary
public void recover(Parser recognizer, RecognitionException e) Implements org.antlr.v4.runtime.ANTLRErrorStrategy.recover. Doc from org.antlr.v4.runtime.ANTLRErrorStrategy.recover. This method is called to recover from exception `e`. This method is called after `reportError` by the default exception handler generated for a rule method. The default implementation resynchronizes the parser by consuming tokens until we find one in the resynchronization set--loosely the set of tokens that can follow the current rule. Parameters recognizer:Parser the parser instance e:RecognitionException the recognition exception to recover from Annotations @Override

public void recover(Parser recognizer, RecognitionException e)

Implements org.antlr.v4.runtime.ANTLRErrorStrategy.recover.

Doc from org.antlr.v4.runtime.ANTLRErrorStrategy.recover.

This method is called to recover from exception e. This method is called after reportError by the default exception handler generated for a rule method.

The default implementation resynchronizes the parser by consuming tokens until we find one in the resynchronization set--loosely the set of tokens that can follow the current rule.

Parameters

recognizer:Parser: the parser instance
e:RecognitionException: the recognition exception to recover from

Annotations

@Override

recoverInline back to summary

recoverInline	back to summary
public Token recoverInline(Parser recognizer) throws RecognitionException Implements org.antlr.v4.runtime.ANTLRErrorStrategy.recoverInline. Doc from org.antlr.v4.runtime.ANTLRErrorStrategy.recoverInline. This method is called when an unexpected symbol is encountered during an inline match operation, such as `Parser#match`. If the error strategy successfully recovers from the match failure, this method returns the `Token` instance which should be treated as the successful result of the match. This method handles the consumption of any tokens - the caller should not call `Parser#consume` after a successful recovery. Note that the calling code will not report an error if this method returns successfully. The error strategy implementation is responsible for calling `Parser#notifyErrorListeners` as appropriate. The default implementation attempts to recover from the mismatched input by using single token insertion and deletion as described below. If the recovery attempt fails, this method throws an `InputMismatchException`. EXTRA TOKEN (single token deletion) `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 and delete it. Then consume and return the next token (which was the `LA(2)` token) as the successful result of the match operation. This recovery strategy is implemented by `singleTokenDeletion`. MISSING TOKEN (single token insertion) If current token (at `LA(1)`) is consistent with what could come after the expected `LA(1)` token, then assume the token is missing and use the parser's `TokenFactory` to create it on the fly. The "insertion" is performed by returning the created token as the successful result of the match operation. This recovery strategy is implemented by `singleTokenInsertion`. EXAMPLE 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)* ';' ^ The attempt to match `')'` will fail when it sees `';'` and call `recoverInline`. 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 `')'`. Parameters recognizer:Parser the parser instance Annotations @Override Exceptions RecognitionException: if the error strategy was not able to recover from the unexpected input symbol

public Token recoverInline(Parser recognizer) throws RecognitionException

Implements org.antlr.v4.runtime.ANTLRErrorStrategy.recoverInline.

Doc from org.antlr.v4.runtime.ANTLRErrorStrategy.recoverInline.

This method is called when an unexpected symbol is encountered during an inline match operation, such as Parser#match. If the error strategy successfully recovers from the match failure, this method returns the Token instance which should be treated as the successful result of the match.

This method handles the consumption of any tokens - the caller should not call Parser#consume after a successful recovery.

Note that the calling code will not report an error if this method returns successfully. The error strategy implementation is responsible for calling Parser#notifyErrorListeners as appropriate.

The default implementation attempts to recover from the mismatched input by using single token insertion and deletion as described below. If the recovery attempt fails, this method throws an InputMismatchException.

EXTRA TOKEN (single token deletion)

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 and delete it. Then consume and return the next token (which was the LA(2) token) as the successful result of the match operation.

This recovery strategy is implemented by singleTokenDeletion.

MISSING TOKEN (single token insertion)

If current token (at LA(1)) is consistent with what could come after the expected LA(1) token, then assume the token is missing and use the parser's TokenFactory to create it on the fly. The "insertion" is performed by returning the created token as the successful result of the match operation.

This recovery strategy is implemented by singleTokenInsertion.

EXAMPLE

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)* ';'
                   ^

The attempt to match ')' will fail when it sees ';' and call recoverInline. 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 ')'.

Parameters

recognizer:Parser: the parser instance

Annotations

@Override

Exceptions

RecognitionException:: if the error strategy was not able to recover from the unexpected input symbol

reportError back to summary

reportError	back to summary
public void reportError(Parser recognizer, RecognitionException e) Implements org.antlr.v4.runtime.ANTLRErrorStrategy.reportError. Doc from org.antlr.v4.runtime.ANTLRErrorStrategy.reportError. Report any kind of `RecognitionException`. This method is called by the default exception handler generated for a rule method. The default implementation returns immediately if the handler is already in error recovery mode. Otherwise, it calls `beginErrorCondition` and dispatches the reporting task based on the runtime type of `e` according to the following table. `NoViableAltException`: Dispatches the call to `reportNoViableAlternative` `InputMismatchException`: Dispatches the call to `reportInputMismatch` `FailedPredicateException`: Dispatches the call to `reportFailedPredicate` All other types: calls `Parser#notifyErrorListeners` to report the exception Parameters recognizer:Parser the parser instance e:RecognitionException the recognition exception to report Annotations @Override

public void reportError(Parser recognizer, RecognitionException e)

Implements org.antlr.v4.runtime.ANTLRErrorStrategy.reportError.

Doc from org.antlr.v4.runtime.ANTLRErrorStrategy.reportError.

Report any kind of RecognitionException. This method is called by the default exception handler generated for a rule method.

The default implementation returns immediately if the handler is already in error recovery mode. Otherwise, it calls beginErrorCondition and dispatches the reporting task based on the runtime type of e according to the following table.

NoViableAltException: Dispatches the call to reportNoViableAlternative
InputMismatchException: Dispatches the call to reportInputMismatch
FailedPredicateException: Dispatches the call to reportFailedPredicate
All other types: calls Parser#notifyErrorListeners to report the exception

Parameters

recognizer:Parser: the parser instance
e:RecognitionException: the recognition exception to report

Annotations

@Override

reportFailedPredicate back to summary

reportFailedPredicate	back to summary
protected void reportFailedPredicate(Parser recognizer, FailedPredicateException e) This is called by `reportError` when the exception is a `FailedPredicateException`. Parameters recognizer:Parser the parser instance e:FailedPredicateException the recognition exception See Also `reportError`

protected void reportFailedPredicate(Parser recognizer, FailedPredicateException e)

This is called by reportError when the exception is a FailedPredicateException.

Parameters

recognizer:Parser: the parser instance
e:FailedPredicateException: the recognition exception

See Also

reportError

reportInputMismatch back to summary

reportInputMismatch	back to summary
protected void reportInputMismatch(Parser recognizer, InputMismatchException e) This is called by `reportError` when the exception is an `InputMismatchException`. Parameters recognizer:Parser the parser instance e:InputMismatchException the recognition exception See Also `reportError`

protected void reportInputMismatch(Parser recognizer, InputMismatchException e)

This is called by reportError when the exception is an InputMismatchException.

Parameters

recognizer:Parser: the parser instance
e:InputMismatchException: the recognition exception

See Also

reportError

reportMatch back to summary

reportMatch	back to summary
public void reportMatch(Parser recognizer) Implements org.antlr.v4.runtime.ANTLRErrorStrategy.reportMatch. Doc from org.antlr.v4.runtime.ANTLRErrorStrategy.reportMatch. This method is called by when the parser successfully matches an input symbol. The default implementation simply calls `endErrorCondition`. Parameters recognizer:Parser the parser instance Annotations @Override

public void reportMatch(Parser recognizer)

Implements org.antlr.v4.runtime.ANTLRErrorStrategy.reportMatch.

Doc from org.antlr.v4.runtime.ANTLRErrorStrategy.reportMatch.

This method is called by when the parser successfully matches an input symbol.

The default implementation simply calls endErrorCondition.

Parameters

recognizer:Parser: the parser instance

Annotations

@Override

reportMissingToken back to summary

reportMissingToken	back to summary
protected void reportMissingToken(Parser recognizer) This method is called to report a syntax error which requires the insertion of a missing token into the input stream. At the time this method is called, the missing token has not yet been inserted. When this method returns, `recognizer` is in error recovery mode. This method is called when `singleTokenInsertion` identifies single-token insertion as a viable recovery strategy for a mismatched input error. The default implementation simply returns if the handler is already in error recovery mode. Otherwise, it calls `beginErrorCondition` to enter error recovery mode, followed by calling `Parser#notifyErrorListeners`. Parameters recognizer:Parser the parser instance

protected void reportMissingToken(Parser recognizer)

This method is called to report a syntax error which requires the insertion of a missing token into the input stream. At the time this method is called, the missing token has not yet been inserted. When this method returns, recognizer is in error recovery mode.

This method is called when singleTokenInsertion identifies single-token insertion as a viable recovery strategy for a mismatched input error.

The default implementation simply returns if the handler is already in error recovery mode. Otherwise, it calls beginErrorCondition to enter error recovery mode, followed by calling Parser#notifyErrorListeners.

Parameters

recognizer:Parser: the parser instance

reportNoViableAlternative back to summary

reportNoViableAlternative	back to summary
protected void reportNoViableAlternative(Parser recognizer, NoViableAltException e) This is called by `reportError` when the exception is a `NoViableAltException`. Parameters recognizer:Parser the parser instance e:NoViableAltException the recognition exception See Also `reportError`

protected void reportNoViableAlternative(Parser recognizer, NoViableAltException e)

This is called by reportError when the exception is a NoViableAltException.

Parameters

recognizer:Parser: the parser instance
e:NoViableAltException: the recognition exception

See Also

reportError

reportUnwantedToken back to summary

reportUnwantedToken	back to summary
protected void reportUnwantedToken(Parser recognizer) This method is called to report a syntax error which requires the removal of a token from the input stream. At the time this method is called, the erroneous symbol is current `LT(1)` symbol and has not yet been removed from the input stream. When this method returns, `recognizer` is in error recovery mode. This method is called when `singleTokenDeletion` identifies single-token deletion as a viable recovery strategy for a mismatched input error. The default implementation simply returns if the handler is already in error recovery mode. Otherwise, it calls `beginErrorCondition` to enter error recovery mode, followed by calling `Parser#notifyErrorListeners`. Parameters recognizer:Parser the parser instance

protected void reportUnwantedToken(Parser recognizer)

This method is called to report a syntax error which requires the removal of a token from the input stream. At the time this method is called, the erroneous symbol is current LT(1) symbol and has not yet been removed from the input stream. When this method returns, recognizer is in error recovery mode.

This method is called when singleTokenDeletion identifies single-token deletion as a viable recovery strategy for a mismatched input error.

Parameters

recognizer:Parser: the parser instance

reset back to summary

reset	back to summary
public void reset(Parser recognizer) Implements org.antlr.v4.runtime.ANTLRErrorStrategy.reset. Doc from org.antlr.v4.runtime.ANTLRErrorStrategy.reset. Reset the error handler state for the specified `recognizer`. The default implementation simply calls `endErrorCondition` to ensure that the handler is not in error recovery mode. Parameters recognizer:Parser the parser instance Annotations @Override

public void reset(Parser recognizer)

Implements org.antlr.v4.runtime.ANTLRErrorStrategy.reset.

Doc from org.antlr.v4.runtime.ANTLRErrorStrategy.reset.

Reset the error handler state for the specified recognizer.

The default implementation simply calls endErrorCondition to ensure that the handler is not in error recovery mode.

Parameters

recognizer:Parser: the parser instance

Annotations

@Override

singleTokenDeletion back to summary

singleTokenDeletion	back to summary
protected Token singleTokenDeletion(Parser recognizer) This method implements the single-token deletion inline error recovery strategy. It is called by `recoverInline` to attempt to recover from mismatched input. If this method returns null, the parser and error handler state will not have changed. If this method returns non-null, `recognizer` will not be in error recovery mode since the returned token was a successful match. If the single-token deletion is successful, this method calls `reportUnwantedToken` to report the error, followed by `Parser#consume` to actually "delete" the extraneous token. Then, before returning `reportMatch` is called to signal a successful match. Parameters recognizer:Parser the parser instance Returns:Token the successfully matched `Token` instance if single-token deletion successfully recovers from the mismatched input, otherwise `null`

protected Token singleTokenDeletion(Parser recognizer)

This method implements the single-token deletion inline error recovery strategy. It is called by recoverInline to attempt to recover from mismatched input. If this method returns null, the parser and error handler state will not have changed. If this method returns non-null, recognizer will not be in error recovery mode since the returned token was a successful match.

If the single-token deletion is successful, this method calls reportUnwantedToken to report the error, followed by Parser#consume to actually "delete" the extraneous token. Then, before returning reportMatch is called to signal a successful match.

Parameters

recognizer:Parser: the parser instance

Returns:Token

the successfully matched Token instance if single-token deletion successfully recovers from the mismatched input, otherwise null

singleTokenInsertion back to summary

singleTokenInsertion	back to summary
protected boolean singleTokenInsertion(Parser recognizer) This method implements the single-token insertion inline error recovery strategy. It is called by `recoverInline` if the single-token deletion strategy fails to recover from the mismatched input. If this method returns `true`, `recognizer` will be in error recovery mode. This method determines whether or not single-token insertion is viable by checking if the `LA(1)` input symbol could be successfully matched if it were instead the `LA(2)` symbol. If this method returns `true`, the caller is responsible for creating and inserting a token with the correct type to produce this behavior. Parameters recognizer:Parser the parser instance Returns:boolean `true` if single-token insertion is a viable recovery strategy for the current mismatched input, otherwise `false`

protected boolean singleTokenInsertion(Parser recognizer)

This method implements the single-token insertion inline error recovery strategy. It is called by recoverInline if the single-token deletion strategy fails to recover from the mismatched input. If this method returns true, recognizer will be in error recovery mode.

This method determines whether or not single-token insertion is viable by checking if the LA(1) input symbol could be successfully matched if it were instead the LA(2) symbol. If this method returns true, the caller is responsible for creating and inserting a token with the correct type to produce this behavior.

Parameters

recognizer:Parser: the parser instance

Returns:boolean

true if single-token insertion is a viable recovery strategy for the current mismatched input, otherwise false

sync back to summary

sync	back to summary
public void sync(Parser recognizer) throws RecognitionException Implements org.antlr.v4.runtime.ANTLRErrorStrategy.sync. The default implementation of `ANTLRErrorStrategy#sync` makes sure that the current lookahead symbol is consistent with what were expecting at this point in the ATN. You can call this anytime but ANTLR only generates code to check before subrules/loops and each iteration. Implements Jim Idle's magic sync mechanism in closures and optional subrules. E.g., a : sync ( stuff sync )* ; sync : {consume to what can follow sync} ; 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 block with an empty 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. ORIGINS* Previous versions of ANTLR did a poor job of their recovery within loops. A single mismatch token or missing token would force the parser to bail out of the entire rules surrounding the loop. So, for rule classDef : 'class' ID '{' member* '}' input with an extra token between members would force the parser to consume until it found the next class definition rather than the next member definition of the current class. This functionality cost a little bit of effort because the parser has to compare token set at the start of the loop and at each iteration. If for some reason speed is suffering for you, you can turn off this functionality by simply overriding this method as a blank { }. Parameters recognizer:Parser Doc from org.antlr.v4.runtime.ANTLRErrorStrategy.sync. the parser instance Annotations @Override Exceptions RecognitionException: Doc from org.antlr.v4.runtime.ANTLRErrorStrategy.sync. if an error is detected by the error strategy but cannot be automatically recovered at the current state in the parsing process

public void sync(Parser recognizer) throws RecognitionException

Implements org.antlr.v4.runtime.ANTLRErrorStrategy.sync.

The default implementation of ANTLRErrorStrategy#sync makes sure that the current lookahead symbol is consistent with what were expecting at this point in the ATN. You can call this anytime but ANTLR only generates code to check before subrules/loops and each iteration.

Implements Jim Idle's magic sync mechanism in closures and optional subrules. E.g.,

a : sync ( stuff sync )* ;
sync : {consume to what can follow sync} ;

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 block with an empty 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.

ORIGINS

Previous versions of ANTLR did a poor job of their recovery within loops. A single mismatch token or missing token would force the parser to bail out of the entire rules surrounding the loop. So, for rule

classDef : 'class' ID '{' member* '}'

input with an extra token between members would force the parser to consume until it found the next class definition rather than the next member definition of the current class.

This functionality cost a little bit of effort because the parser has to compare token set at the start of the loop and at each iteration. If for some reason speed is suffering for you, you can turn off this functionality by simply overriding this method as a blank { }.

Parameters

recognizer:Parser

Doc from org.antlr.v4.runtime.ANTLRErrorStrategy.sync.

the parser instance

Annotations

@Override

Exceptions

RecognitionException:

Doc from org.antlr.v4.runtime.ANTLRErrorStrategy.sync.

if an error is detected by the error strategy but cannot be automatically recovered at the current state in the parsing process

public Class DefaultErrorStrategy

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail