Uses of Class
org.antlr.v4.runtime.misc.NotNull

Packages that use NotNull

Package	Description
org.antlr.v4.runtime
org.antlr.v4.runtime.atn
org.antlr.v4.runtime.dfa
org.antlr.v4.runtime.misc
org.antlr.v4.runtime.tree
org.antlr.v4.runtime.tree.gui
org.antlr.v4.runtime.tree.pattern

Uses of NotNull in org.antlr.v4.runtime

Fields in org.antlr.v4.runtime with annotations of type NotNull

Modifier and Type	Field and Description
protected ANTLRErrorStrategy	Parser._errHandler The error handling strategy for the parser.
String	RuntimeMetaData.VersionMismatchException.compileTimeRuntimeVersion The version of the ANTLR 4 Runtime library the parser and/or user code was compiled against.
protected Pair<TokenSource,CharStream>	CommonToken.source This is the backing field for CommonToken.getTokenSource() and CommonToken.getInputStream().
protected TokenSource	BufferedTokenStream.tokenSource The TokenSource from which tokens for this stream are fetched.

Methods in org.antlr.v4.runtime with annotations of type NotNull

Modifier and Type	Method and Description
Symbol	TokenFactory.create(int type, String text) Generically useful
Symbol	TokenFactory.create(Pair<TokenSource,CharStream> source, int type, String text, int channel, int start, int stop, int line, int charPositionInLine) This is the method used to create tokens in the lexer and in the error handling strategy.
protected String	DefaultErrorStrategy.escapeWSAndQuote(String s)
Token	TokenStream.get(int index) Gets the Token at the specified index in the stream.
abstract ATN	Recognizer.getATN() Get the ATN used by the recognizer for prediction.
ATN	Parser.getATNWithBypassAlts() The ATN with bypass alternatives is expensive to create so we create it lazily.
protected BitSet	DiagnosticErrorListener.getConflictingAlts(BitSet reportedAlts, ATNConfigSet configs) Computes the set of conflicting or ambiguous alternatives from a configuration set, if that information was not already provided by the parser.
Token	Parser.getCurrentToken() Match needs to return the current input symbol, which gets put into the label for the associated token ref; e.g., x=ID.
ANTLRErrorStrategy	Parser.getErrorHandler()
String	Recognizer.getErrorHeader(RecognitionException e) What is the error header, normally line/character position information?
List<? extends ANTLRErrorListener>	Recognizer.getErrorListeners()
protected IntervalSet	DefaultErrorStrategy.getErrorRecoverySet(Parser recognizer)
IntervalSet	Parser.getExpectedTokens() Computes the set of input symbols which could follow the current parser state and context, as given by Recognizer.getState() and Parser.getContext(), respectively.
protected IntervalSet	DefaultErrorStrategy.getExpectedTokens(Parser recognizer)
IntervalSet	Parser.getExpectedTokensWithinCurrentRule()
ATNInterpreter	Recognizer.getInterpreter() Get the ATN interpreter used by the recognizer for prediction.
protected String	RuntimeMetaData.DefaultListener.getMajorMinorVersion(String version) Gets the major and minor version numbers from a version string.
protected Token	DefaultErrorStrategy.getMissingSymbol(Parser recognizer) Conjure up a missing token during error recovery.
List<ParseTreeListener>	Parser.getParseListeners()
Map<String,Integer>	Recognizer.getRuleIndexMap() Get a map from rule names to rule indexes.
static String	RuntimeMetaData.getRuntimeVersion() Gets the currently executing version of the ANTLR 4 runtime library.
String	Recognizer.getSerializedATN() If this recognizer was generated, it will have a serialized ATN representation of the grammar.
String	IntStream.getSourceName() Gets the name of the underlying symbol source.
Token	NoViableAltException.getStartToken()
String	UnbufferedTokenStream.getText()
String	TokenStream.getText() Return the text of all tokens in the stream.
String	BufferedTokenStream.getText() Get the text of all tokens in this buffer.
String	UnbufferedTokenStream.getText(Interval interval)
String	TokenStream.getText(Interval interval) Return the text of all tokens within the specified interval.
String	CharStream.getText(Interval interval) This method returns the text for a range of characters within this input stream.
String	BufferedTokenStream.getText(Interval interval)
String	UnbufferedTokenStream.getText(RuleContext ctx)
String	TokenStream.getText(RuleContext ctx) Return the text of all tokens in the source interval of the specified context.
String	BufferedTokenStream.getText(RuleContext ctx)
String	UnbufferedTokenStream.getText(Token start, Token stop)
String	TokenStream.getText(Token start, Token stop) Return the text of all tokens in this stream between start and stop (inclusive).
String	BufferedTokenStream.getText(Token start, Token stop)
TokenFactory<?>	TokenSource.getTokenFactory() Gets the TokenFactory this token source is currently using for creating Token objects from the input.
abstract TokenFactory<?>	Recognizer.getTokenFactory()
TokenFactory<?>	ListTokenSource.getTokenFactory() Gets the TokenFactory this token source is currently using for creating Token objects from the input.
TokenSource	TokenStream.getTokenSource() Gets the underlying TokenSource which provides tokens for this stream.
Map<String,Integer>	Recognizer.getTokenTypeMap() Get a map from token names to token types.
Token	TokenStream.LT(int k) Get the Token instance associated with the value returned by LA(k).
Token	BufferedTokenStream.LT(int k)
Token	Parser.match(int ttype) Match current input symbol against ttype.
Token	Parser.matchWildcard() Match current input symbol as a wildcard.
Token	TokenSource.nextToken() Return a Token object from your input stream (usually a CharStream).
Token	ANTLRErrorStrategy.recoverInline(Parser recognizer) This method is called when an unexpected symbol is encountered during an inline match operation, such as Parser.match(int).

Method parameters in org.antlr.v4.runtime with annotations of type NotNull

Modifier and Type	Method and Description
protected void	UnbufferedTokenStream.add(Token t)
void	Recognizer.addErrorListener(ANTLRErrorListener listener)
static void	RuntimeMetaData.addListener(RuntimeMetaData.Listener listener) Register a listener to receive notifications of mismatched ANTLR versions.
void	Parser.addParseListener(ParseTreeListener listener) Registers listener to receive events during the parsing process.
protected void	DefaultErrorStrategy.beginErrorCondition(Parser recognizer) This method is called to enter error recovery mode when a recognition exception is reported.
static void	RuntimeMetaData.checkVersion(String toolVersion, String compileTimeVersion) This method provides the ability to detect mismatches between the version of ANTLR 4 used to generate a parser, the version of the ANTLR runtime a parser was compiled against, and the version of the ANTLR runtime which is currently executing.
protected void	DefaultErrorStrategy.consumeUntil(Parser recognizer, IntervalSet set) Consume tokens until one matches the given token set.
protected void	DefaultErrorStrategy.consumeUntil(Parser recognizer, IntervalSet set) Consume tokens until one matches the given token set.
Symbol	TokenFactory.create(Pair<TokenSource,CharStream> source, int type, String text, int channel, int start, int stop, int line, int charPositionInLine) This is the method used to create tokens in the lexer and in the error handling strategy.
protected void	DefaultErrorStrategy.endErrorCondition(Parser recognizer) This method is called to leave error recovery mode after recovering from a recognition exception.
void	Parser.enterRule(ParserRuleContext localctx, int state, int ruleIndex) Always called by generated parsers upon entry to a rule.
protected String	DefaultErrorStrategy.escapeWSAndQuote(String s)
protected BitSet	DiagnosticErrorListener.getConflictingAlts(BitSet reportedAlts, ATNConfigSet configs) Computes the set of conflicting or ambiguous alternatives from a configuration set, if that information was not already provided by the parser.
protected String	DiagnosticErrorListener.getDecisionDescription(Parser recognizer, DFA dfa)
protected String	DiagnosticErrorListener.getDecisionDescription(Parser recognizer, DFA dfa)
String	Recognizer.getErrorHeader(RecognitionException e) What is the error header, normally line/character position information?
protected IntervalSet	DefaultErrorStrategy.getErrorRecoverySet(Parser recognizer)
protected IntervalSet	DefaultErrorStrategy.getExpectedTokens(Parser recognizer)
protected String	RuntimeMetaData.DefaultListener.getMajorMinorVersion(String version) Gets the major and minor version numbers from a version string.
protected Token	DefaultErrorStrategy.getMissingSymbol(Parser recognizer) Conjure up a missing token during error recovery.
protected String	DefaultErrorStrategy.getSymbolText(Token symbol)
protected int	DefaultErrorStrategy.getSymbolType(Token symbol)
String	TokenStream.getText(Interval interval) Return the text of all tokens within the specified interval.
String	CharStream.getText(Interval interval) This method returns the text for a range of characters within this input stream.
String	TokenStream.getText(RuleContext ctx) Return the text of all tokens in the source interval of the specified context.
String	TokenStream.getText(Token start, Token stop) Return the text of all tokens in this stream between start and stop (inclusive).
String	TokenStream.getText(Token start, Token stop) Return the text of all tokens in this stream between start and stop (inclusive).
boolean	ANTLRErrorStrategy.inErrorRecoveryMode(Parser recognizer) Tests whether or not recognizer is in the process of recovering from an error.
protected boolean	RuntimeMetaData.DefaultListener.isMinorVersionMatch(RuntimeMetaData.VersionMismatchException ex) Determines if the reported version mismatch are a match when considering only the major and minor version components of the version strings.
void	Parser.notifyErrorListeners(String msg)
void	Parser.notifyErrorListeners(Token offendingToken, String msg, RecognitionException e)
void	Parser.notifyErrorListeners(Token offendingToken, String msg, RecognitionException e)
void	ANTLRErrorStrategy.recover(Parser recognizer, RecognitionException e) This method is called to recover from exception e.
void	ANTLRErrorStrategy.recover(Parser recognizer, RecognitionException e) This method is called to recover from exception e.
Token	ANTLRErrorStrategy.recoverInline(Parser recognizer) This method is called when an unexpected symbol is encountered during an inline match operation, such as Parser.match(int).
void	Recognizer.removeErrorListener(ANTLRErrorListener listener)
static boolean	RuntimeMetaData.removeListener(RuntimeMetaData.Listener listener) Remove a specific listener registered to receive notifications of mismatched ANTLR versions.
void	ProxyErrorListener.reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs)
void	ProxyErrorListener.reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs)
void	ProxyErrorListener.reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs)
void	DiagnosticErrorListener.reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs)
void	DiagnosticErrorListener.reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs)
void	DiagnosticErrorListener.reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs)
void	BaseErrorListener.reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs)
void	BaseErrorListener.reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs)
void	BaseErrorListener.reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs)
void	ANTLRErrorListener.reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs) This method is called by the parser when a full-context prediction results in an ambiguity.
void	ANTLRErrorListener.reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs) This method is called by the parser when a full-context prediction results in an ambiguity.
void	ANTLRErrorListener.reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs) This method is called by the parser when a full-context prediction results in an ambiguity.
void	ProxyErrorListener.reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, ATNConfigSet configs)
void	ProxyErrorListener.reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, ATNConfigSet configs)
void	ProxyErrorListener.reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, ATNConfigSet configs)
void	DiagnosticErrorListener.reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, ATNConfigSet configs)
void	DiagnosticErrorListener.reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, ATNConfigSet configs)
void	DiagnosticErrorListener.reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, ATNConfigSet configs)
void	BaseErrorListener.reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, ATNConfigSet configs)
void	BaseErrorListener.reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, ATNConfigSet configs)
void	BaseErrorListener.reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, ATNConfigSet configs)
void	ANTLRErrorListener.reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, ATNConfigSet configs) This method is called when an SLL conflict occurs and the parser is about to use the full context information to make an LL decision.
void	ANTLRErrorListener.reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, ATNConfigSet configs) This method is called when an SLL conflict occurs and the parser is about to use the full context information to make an LL decision.
void	ANTLRErrorListener.reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, BitSet conflictingAlts, ATNConfigSet configs) This method is called when an SLL conflict occurs and the parser is about to use the full context information to make an LL decision.
void	ProxyErrorListener.reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, ATNConfigSet configs)
void	ProxyErrorListener.reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, ATNConfigSet configs)
void	ProxyErrorListener.reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, ATNConfigSet configs)
void	DiagnosticErrorListener.reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, ATNConfigSet configs)
void	DiagnosticErrorListener.reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, ATNConfigSet configs)
void	DiagnosticErrorListener.reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, ATNConfigSet configs)
void	BaseErrorListener.reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, ATNConfigSet configs)
void	BaseErrorListener.reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, ATNConfigSet configs)
void	BaseErrorListener.reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, ATNConfigSet configs)
void	ANTLRErrorListener.reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, ATNConfigSet configs) This method is called by the parser when a full-context prediction has a unique result.
void	ANTLRErrorListener.reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, ATNConfigSet configs) This method is called by the parser when a full-context prediction has a unique result.
void	ANTLRErrorListener.reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, ATNConfigSet configs) This method is called by the parser when a full-context prediction has a unique result.
void	ANTLRErrorStrategy.reportError(Parser recognizer, RecognitionException e) Report any kind of RecognitionException.
void	ANTLRErrorStrategy.reportError(Parser recognizer, RecognitionException e) Report any kind of RecognitionException.
protected void	DefaultErrorStrategy.reportFailedPredicate(Parser recognizer, FailedPredicateException e) This is called by DefaultErrorStrategy.reportError(org.antlr.v4.runtime.Parser, org.antlr.v4.runtime.RecognitionException) when the exception is a FailedPredicateException.
protected void	DefaultErrorStrategy.reportFailedPredicate(Parser recognizer, FailedPredicateException e) This is called by DefaultErrorStrategy.reportError(org.antlr.v4.runtime.Parser, org.antlr.v4.runtime.RecognitionException) when the exception is a FailedPredicateException.
protected void	DefaultErrorStrategy.reportInputMismatch(Parser recognizer, InputMismatchException e) This is called by DefaultErrorStrategy.reportError(org.antlr.v4.runtime.Parser, org.antlr.v4.runtime.RecognitionException) when the exception is an InputMismatchException.
protected void	DefaultErrorStrategy.reportInputMismatch(Parser recognizer, InputMismatchException e) This is called by DefaultErrorStrategy.reportError(org.antlr.v4.runtime.Parser, org.antlr.v4.runtime.RecognitionException) when the exception is an InputMismatchException.
void	ANTLRErrorStrategy.reportMatch(Parser recognizer) This method is called by when the parser successfully matches an input symbol.
protected void	DefaultErrorStrategy.reportMissingToken(Parser recognizer) This method is called to report a syntax error which requires the insertion of a missing token into the input stream.
protected void	DefaultErrorStrategy.reportNoViableAlternative(Parser recognizer, NoViableAltException e) This is called by DefaultErrorStrategy.reportError(org.antlr.v4.runtime.Parser, org.antlr.v4.runtime.RecognitionException) when the exception is a NoViableAltException.
protected void	DefaultErrorStrategy.reportNoViableAlternative(Parser recognizer, NoViableAltException e) This is called by DefaultErrorStrategy.reportError(org.antlr.v4.runtime.Parser, org.antlr.v4.runtime.RecognitionException) when the exception is a NoViableAltException.
protected void	DefaultErrorStrategy.reportUnwantedToken(Parser recognizer) This method is called to report a syntax error which requires the removal of a token from the input stream.
void	RuntimeMetaData.Listener.reportVersionMismatch(RuntimeMetaData.VersionMismatchException ex) Report a version mismatch which was detected by RuntimeMetaData.checkVersion(java.lang.String, java.lang.String).
void	RuntimeMetaData.DefaultListener.reportVersionMismatch(RuntimeMetaData.VersionMismatchException ex) Report a version mismatch which was detected by RuntimeMetaData.checkVersion(java.lang.String, java.lang.String).
void	ANTLRErrorStrategy.reset(Parser recognizer) Reset the error handler state for the specified recognizer.
void	Parser.setErrorHandler(ANTLRErrorStrategy handler)
void	Recognizer.setInterpreter(ATNInterpreter interpreter) Set the ATN interpreter used by the recognizer for prediction.
void	TokenSource.setTokenFactory(TokenFactory<?> factory) Set the TokenFactory this token source should use for creating Token objects from the input.
abstract void	Recognizer.setTokenFactory(TokenFactory<?> input)
void	ListTokenSource.setTokenFactory(TokenFactory<?> factory) Set the TokenFactory this token source should use for creating Token objects from the input.
protected Token	DefaultErrorStrategy.singleTokenDeletion(Parser recognizer) This method implements the single-token deletion inline error recovery strategy.
protected boolean	DefaultErrorStrategy.singleTokenInsertion(Parser recognizer) This method implements the single-token insertion inline error recovery strategy.
void	ANTLRErrorStrategy.sync(Parser recognizer) This method provides the error handler with an opportunity to handle syntactic or semantic errors in the input stream before they result in a RecognitionException.
void	ProxyErrorListener.syntaxError(Recognizer<?,?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e)
void	ProxyErrorListener.syntaxError(Recognizer<?,?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e)
void	BaseErrorListener.syntaxError(Recognizer<?,?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e)
void	BaseErrorListener.syntaxError(Recognizer<?,?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e)
void	ANTLRErrorListener.syntaxError(Recognizer<?,?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) Upon syntax error, notify any interested parties.
void	ANTLRErrorListener.syntaxError(Recognizer<?,?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) Upon syntax error, notify any interested parties.

Constructor parameters in org.antlr.v4.runtime with annotations of type NotNull

Constructor and Description
BufferedTokenStream(TokenSource tokenSource)
CommonToken(Pair<TokenSource,CharStream> source, int type, int channel, int start, int stop)
CommonToken(Token oldToken) Constructs a new CommonToken as a copy of another Token.
CommonTokenStream(TokenSource tokenSource) Constructs a new CommonTokenStream using the specified token source and the default token channel (Token.DEFAULT_CHANNEL).
CommonTokenStream(TokenSource tokenSource, int channel) Constructs a new CommonTokenStream using the specified token source and filtering tokens to the specified channel.
FailedPredicateException(Parser recognizer)
FailedPredicateException(Parser recognizer, String predicate)
FailedPredicateException(Parser recognizer, String predicate, String message)
InputMismatchException(Parser recognizer)
LexerNoViableAltException(Lexer lexer, CharStream input, int startIndex, ATNConfigSet deadEndConfigs)
ListTokenSource(List<? extends Token> tokens) Constructs a new ListTokenSource instance from the specified collection of Token objects.
ListTokenSource(List<? extends Token> tokens, String sourceName) Constructs a new ListTokenSource instance from the specified collection of Token objects and source name.
NoViableAltException(Parser recognizer)
NoViableAltException(Parser recognizer, TokenStream input, Token startToken, Token offendingToken, ATNConfigSet deadEndConfigs, ParserRuleContext ctx)
NoViableAltException(Parser recognizer, TokenStream input, Token startToken, Token offendingToken, ATNConfigSet deadEndConfigs, ParserRuleContext ctx)
NoViableAltException(Parser recognizer, TokenStream input, Token startToken, Token offendingToken, ATNConfigSet deadEndConfigs, ParserRuleContext ctx)
NoViableAltException(Parser recognizer, TokenStream input, Token startToken, Token offendingToken, ATNConfigSet deadEndConfigs, ParserRuleContext ctx)
NoViableAltException(Parser recognizer, TokenStream input, Token startToken, Token offendingToken, ATNConfigSet deadEndConfigs, ParserRuleContext ctx)

Uses of NotNull in org.antlr.v4.runtime.atn

Fields in org.antlr.v4.runtime.atn with annotations of type NotNull

Modifier and Type	Field and Description
ATN	LL1Analyzer.atn
ATN	ATNSimulator.atn
DFA[]	ParserATNSimulator.decisionToDFA
DFA[]	LexerATNSimulator.decisionToDFA
List<DecisionState>	ATN.decisionToState Each subrule/rule is a decision point and we must track them so we can go back later and build DFA predictors for them.
static DFAState	ATNSimulator.ERROR Must distinguish between missing edge and edge we know leads nowhere
ATNState	RuleTransition.followState What node to begin computations following ref to rule
TokenStream	DecisionEventInfo.input The input token stream which is being parsed.
Map<String,TokensStartState>	ATN.modeNameToStartState
List<TokensStartState>	ATN.modeToStartState
SemanticContext[]	SemanticContext.AND.opnds
SemanticContext[]	SemanticContext.OR.opnds
protected LexerATNSimulator.SimState	LexerATNSimulator.prevAccept Used during DFA/ATN exec to record the most recent accept configuration info
SemanticContext	ATNConfig.semanticContext
IntervalSet	SetTransition.set
ATNState	ATNConfig.state The ATN state associated with this configuration
List<ATNState>	ATN.states
ATNState	Transition.target The target of this transition.

Methods in org.antlr.v4.runtime.atn with annotations of type NotNull

Modifier and Type	Method and Description
protected ATNConfig	ParserATNSimulator.actionTransition(ATNConfig config, ActionTransition t)
protected DFAState	LexerATNSimulator.addDFAEdge(DFAState from, int t, ATNConfigSet q)
protected DFAState	LexerATNSimulator.addDFAState(ATNConfigSet configs) Add a new DFA state if there isn't one with this set of configurations already.
protected DFAState	ParserATNSimulator.addDFAState(DFA dfa, DFAState D) Add state D to the DFA if it is not already present, and return the actual instance stored in the DFA.
static LexerActionExecutor	LexerActionExecutor.append(LexerActionExecutor lexerActionExecutor, LexerAction lexerAction) Creates a LexerActionExecutor which executes the actions for the input lexerActionExecutor followed by a specified lexerAction.
protected ATNConfigSet	ParserATNSimulator.applyPrecedenceFilter(ATNConfigSet configs) This method transforms the start state computed by ParserATNSimulator.computeStartState(org.antlr.v4.runtime.atn.ATNState, org.antlr.v4.runtime.RuleContext, boolean) to the special start state used by a precedence DFA for a particular precedence value.
protected ATNConfigSet	ParserATNSimulator.computeStartState(ATNState p, RuleContext ctx, boolean fullCtx)
protected ATNConfigSet	LexerATNSimulator.computeStartState(CharStream input, ATNState p)
protected DFAState	LexerATNSimulator.computeTargetState(CharStream input, DFAState s, int t) Compute a target state for an edge in the DFA, and attempt to add the computed state and corresponding edge to the DFA.
protected DFAState	ParserATNSimulator.computeTargetState(DFA dfa, DFAState previousD, int t) Compute a target state for an edge in the DFA, and attempt to add the computed state and corresponding edge to the DFA.
static Transition	ATNSimulator.edgeFactory(ATN atn, int type, int src, int trg, int arg1, int arg2, int arg3, List<IntervalSet> sets) Deprecated. Use ATNDeserializer.edgeFactory(org.antlr.v4.runtime.atn.ATN, int, int, int, int, int, int, java.util.List<org.antlr.v4.runtime.misc.IntervalSet>) instead.
protected Transition	ATNDeserializer.edgeFactory(ATN atn, int type, int src, int trg, int arg1, int arg2, int arg3, List<IntervalSet> sets)
LexerAction	LexerIndexedCustomAction.getAction() Gets the lexer action to execute.
LexerActionType	LexerAction.getActionType() Gets the serialization type of the lexer action.
BitSet	ATNConfigSet.getAlts() Gets the complete set of represented alternatives for the configuration set.
protected BitSet	ParserATNSimulator.getConflictingAlts(ATNConfigSet configs) Gets a BitSet containing the alternatives in configs which are part of one or more conflicting alternative subsets.
static Collection<BitSet>	PredictionMode.getConflictingAltSubsets(ATNConfigSet configs) This function gets the conflicting alt subsets from a configuration set.
DecisionInfo[]	ParseInfo.getDecisionInfo() Gets an array of DecisionInfo instances containing the profiling information gathered for each decision in the ATN.
static ATNDeserializationOptions	ATNDeserializationOptions.getDefaultOptions()
DFA	LexerATNSimulator.getDFA(int mode)
IntervalSet	ATN.getExpectedTokens(int stateNumber, RuleContext context) Computes the set of input symbols which could follow ATN state number stateNumber in the specified full context.
LexerAction[]	LexerActionExecutor.getLexerActions() Gets the lexer actions to be executed by this executor.
List<Integer>	ParseInfo.getLLDecisions() Gets the decision numbers for decisions that required one or more full-context predictions during parsing.
abstract Collection<SemanticContext>	SemanticContext.Operator.getOperands() Gets the operands for the semantic context operator.
PredictionMode	ParserATNSimulator.getPredictionMode()
String	ParserATNSimulator.getRuleName(int index)
static Map<ATNState,BitSet>	PredictionMode.getStateToAltMap(ATNConfigSet configs) Get a map from state to alt subset from a configuration set.
String	LexerATNSimulator.getText(CharStream input) Get the text matched so far for the current token.
String	ParserATNSimulator.getTokenName(int t)
String	LexerATNSimulator.getTokenName(int t)
IntervalSet	SetTransition.label()
IntervalSet	RangeTransition.label()
IntervalSet	AtomTransition.label()
IntervalSet	LL1Analyzer.LOOK(ATNState s, ATNState stopState, RuleContext ctx) Compute set of tokens that can follow s in the ATN in the specified ctx.
IntervalSet	LL1Analyzer.LOOK(ATNState s, RuleContext ctx) Compute set of tokens that can follow s in the ATN in the specified ctx.
IntervalSet	ATN.nextTokens(ATNState s) Compute the set of valid tokens that can occur starting in s and staying in same rule.
IntervalSet	ATN.nextTokens(ATNState s, RuleContext ctx) Compute the set of valid tokens that can occur starting in state s.
protected NoViableAltException	ParserATNSimulator.noViableAlt(TokenStream input, ParserRuleContext outerContext, ATNConfigSet configs, int startIndex)
protected ATNConfigSet	ParserATNSimulator.removeAllConfigsNotInRuleStopState(ATNConfigSet configs, boolean lookToEndOfRule) Return a configuration set containing only the configurations from configs which are in a RuleStopState.
protected ATNConfig	ParserATNSimulator.ruleTransition(ATNConfig config, RuleTransition t)
String	WildcardTransition.toString()
String	SetTransition.toString()
String	RangeTransition.toString()
String	PredicateTransition.toString()
String	EpsilonTransition.toString()
String	AtomTransition.toString()

Method parameters in org.antlr.v4.runtime.atn with annotations of type NotNull

Modifier and Type	Method and Description
protected void	LL1Analyzer._LOOK(ATNState s, ATNState stopState, PredictionContext ctx, IntervalSet look, Set<ATNConfig> lookBusy, BitSet calledRuleStack, boolean seeThruPreds, boolean addEOF) Compute set of tokens that can follow s in the ATN in the specified ctx.
protected void	LL1Analyzer._LOOK(ATNState s, ATNState stopState, PredictionContext ctx, IntervalSet look, Set<ATNConfig> lookBusy, BitSet calledRuleStack, boolean seeThruPreds, boolean addEOF) Compute set of tokens that can follow s in the ATN in the specified ctx.
protected void	LL1Analyzer._LOOK(ATNState s, ATNState stopState, PredictionContext ctx, IntervalSet look, Set<ATNConfig> lookBusy, BitSet calledRuleStack, boolean seeThruPreds, boolean addEOF) Compute set of tokens that can follow s in the ATN in the specified ctx.
protected void	LL1Analyzer._LOOK(ATNState s, ATNState stopState, PredictionContext ctx, IntervalSet look, Set<ATNConfig> lookBusy, BitSet calledRuleStack, boolean seeThruPreds, boolean addEOF) Compute set of tokens that can follow s in the ATN in the specified ctx.
protected void	LexerATNSimulator.accept(CharStream input, LexerActionExecutor lexerActionExecutor, int startIndex, int index, int line, int charPos)
protected ATNConfig	ParserATNSimulator.actionTransition(ATNConfig config, ActionTransition t)
protected ATNConfig	ParserATNSimulator.actionTransition(ATNConfig config, ActionTransition t)
int	ParserATNSimulator.adaptivePredict(TokenStream input, int decision, ParserRuleContext outerContext)
boolean	ATNConfigSet.add(ATNConfig config, DoubleKeyMap<PredictionContext,PredictionContext,PredictionContext> mergeCache) Adding a new config means merging contexts with existing configs for (s, i, pi, _), where s is the ATNConfig.state, i is the ATNConfig.alt, and pi is the ATNConfig.semanticContext.
protected DFAState	ParserATNSimulator.addDFAEdge(DFA dfa, DFAState from, int t, DFAState to) Add an edge to the DFA, if possible.
protected DFAState	LexerATNSimulator.addDFAEdge(DFAState from, int t, ATNConfigSet q)
protected DFAState	LexerATNSimulator.addDFAEdge(DFAState from, int t, ATNConfigSet q)
protected void	LexerATNSimulator.addDFAEdge(DFAState p, int t, DFAState q)
protected void	LexerATNSimulator.addDFAEdge(DFAState p, int t, DFAState q)
protected DFAState	LexerATNSimulator.addDFAState(ATNConfigSet configs) Add a new DFA state if there isn't one with this set of configurations already.
protected DFAState	ParserATNSimulator.addDFAState(DFA dfa, DFAState D) Add state D to the DFA if it is not already present, and return the actual instance stored in the DFA.
protected DFAState	ParserATNSimulator.addDFAState(DFA dfa, DFAState D) Add state D to the DFA if it is not already present, and return the actual instance stored in the DFA.
static boolean	PredictionMode.allConfigsInRuleStopStates(ATNConfigSet configs) Checks if all configurations in configs are in a RuleStopState.
static boolean	PredictionMode.allSubsetsConflict(Collection<BitSet> altsets) Determines if every alternative subset in altsets contains more than one alternative.
static boolean	PredictionMode.allSubsetsEqual(Collection<BitSet> altsets) Determines if every alternative subset in altsets is equivalent.
static LexerActionExecutor	LexerActionExecutor.append(LexerActionExecutor lexerActionExecutor, LexerAction lexerAction) Creates a LexerActionExecutor which executes the actions for the input lexerActionExecutor followed by a specified lexerAction.
protected ATNConfigSet	ParserATNSimulator.applyPrecedenceFilter(ATNConfigSet configs) This method transforms the start state computed by ParserATNSimulator.computeStartState(org.antlr.v4.runtime.atn.ATNState, org.antlr.v4.runtime.RuleContext, boolean) to the special start state used by a precedence DFA for a particular precedence value.
protected void	LexerATNSimulator.captureSimState(LexerATNSimulator.SimState settings, CharStream input, DFAState dfaState)
protected void	LexerATNSimulator.captureSimState(LexerATNSimulator.SimState settings, CharStream input, DFAState dfaState)
protected void	LexerATNSimulator.captureSimState(LexerATNSimulator.SimState settings, CharStream input, DFAState dfaState)
protected void	ParserATNSimulator.closure_(ATNConfig config, ATNConfigSet configs, Set<ATNConfig> closureBusy, boolean collectPredicates, boolean fullCtx, int depth, boolean treatEofAsEpsilon) Do the actual work of walking epsilon edges
protected void	ParserATNSimulator.closure_(ATNConfig config, ATNConfigSet configs, Set<ATNConfig> closureBusy, boolean collectPredicates, boolean fullCtx, int depth, boolean treatEofAsEpsilon) Do the actual work of walking epsilon edges
protected void	ParserATNSimulator.closure_(ATNConfig config, ATNConfigSet configs, Set<ATNConfig> closureBusy, boolean collectPredicates, boolean fullCtx, int depth, boolean treatEofAsEpsilon) Do the actual work of walking epsilon edges
protected void	ParserATNSimulator.closure(ATNConfig config, ATNConfigSet configs, Set<ATNConfig> closureBusy, boolean collectPredicates, boolean fullCtx, boolean treatEofAsEpsilon)
protected void	ParserATNSimulator.closure(ATNConfig config, ATNConfigSet configs, Set<ATNConfig> closureBusy, boolean collectPredicates, boolean fullCtx, boolean treatEofAsEpsilon)
protected void	ParserATNSimulator.closure(ATNConfig config, ATNConfigSet configs, Set<ATNConfig> closureBusy, boolean collectPredicates, boolean fullCtx, boolean treatEofAsEpsilon)
protected boolean	LexerATNSimulator.closure(CharStream input, LexerATNConfig config, ATNConfigSet configs, boolean currentAltReachedAcceptState, boolean speculative, boolean treatEofAsEpsilon) Since the alternatives within any lexer decision are ordered by preference, this method stops pursuing the closure as soon as an accept state is reached.
protected boolean	LexerATNSimulator.closure(CharStream input, LexerATNConfig config, ATNConfigSet configs, boolean currentAltReachedAcceptState, boolean speculative, boolean treatEofAsEpsilon) Since the alternatives within any lexer decision are ordered by preference, this method stops pursuing the closure as soon as an accept state is reached.
protected boolean	LexerATNSimulator.closure(CharStream input, LexerATNConfig config, ATNConfigSet configs, boolean currentAltReachedAcceptState, boolean speculative, boolean treatEofAsEpsilon) Since the alternatives within any lexer decision are ordered by preference, this method stops pursuing the closure as soon as an accept state is reached.
protected void	ParserATNSimulator.closureCheckingStopState(ATNConfig config, ATNConfigSet configs, Set<ATNConfig> closureBusy, boolean collectPredicates, boolean fullCtx, int depth, boolean treatEofAsEpsilon)
protected void	ParserATNSimulator.closureCheckingStopState(ATNConfig config, ATNConfigSet configs, Set<ATNConfig> closureBusy, boolean collectPredicates, boolean fullCtx, int depth, boolean treatEofAsEpsilon)
protected void	ParserATNSimulator.closureCheckingStopState(ATNConfig config, ATNConfigSet configs, Set<ATNConfig> closureBusy, boolean collectPredicates, boolean fullCtx, int depth, boolean treatEofAsEpsilon)
protected ATNConfigSet	ParserATNSimulator.computeStartState(ATNState p, RuleContext ctx, boolean fullCtx)
protected ATNConfigSet	LexerATNSimulator.computeStartState(CharStream input, ATNState p)
protected ATNConfigSet	LexerATNSimulator.computeStartState(CharStream input, ATNState p)
protected DFAState	LexerATNSimulator.computeTargetState(CharStream input, DFAState s, int t) Compute a target state for an edge in the DFA, and attempt to add the computed state and corresponding edge to the DFA.
protected DFAState	LexerATNSimulator.computeTargetState(CharStream input, DFAState s, int t) Compute a target state for an edge in the DFA, and attempt to add the computed state and corresponding edge to the DFA.
protected DFAState	ParserATNSimulator.computeTargetState(DFA dfa, DFAState previousD, int t) Compute a target state for an edge in the DFA, and attempt to add the computed state and corresponding edge to the DFA.
protected DFAState	ParserATNSimulator.computeTargetState(DFA dfa, DFAState previousD, int t) Compute a target state for an edge in the DFA, and attempt to add the computed state and corresponding edge to the DFA.
void	LexerATNSimulator.consume(CharStream input)
void	LexerATNSimulator.copyState(LexerATNSimulator simulator)
int	ATN.defineDecisionState(DecisionState s)
static ATN	ATNSimulator.deserialize(char[] data) Deprecated. Use ATNDeserializer.deserialize(char[]) instead.
ATN	ATNDeserializer.deserialize(char[] data)
void	ParserATNSimulator.dumpDeadEndConfigs(NoViableAltException nvae) Used for debugging in adaptivePredict around execATN but I cut it out for clarity now that alg.
static Transition	ATNSimulator.edgeFactory(ATN atn, int type, int src, int trg, int arg1, int arg2, int arg3, List<IntervalSet> sets) Deprecated. Use ATNDeserializer.edgeFactory(org.antlr.v4.runtime.atn.ATN, int, int, int, int, int, int, java.util.List<org.antlr.v4.runtime.misc.IntervalSet>) instead.
protected Transition	ATNDeserializer.edgeFactory(ATN atn, int type, int src, int trg, int arg1, int arg2, int arg3, List<IntervalSet> sets)
protected BitSet	ParserATNSimulator.evalSemanticContext(DFAState.PredPrediction[] predPredictions, ParserRuleContext outerContext, boolean complete) Look through a list of predicate/alt pairs, returning alts for the pairs that win.
protected boolean	ParserATNSimulator.evalSemanticContext(SemanticContext pred, ParserRuleContext parserCallStack, int alt, boolean fullCtx) Evaluate a semantic context within a specific parser context.
protected boolean	LexerATNSimulator.evaluatePredicate(CharStream input, int ruleIndex, int predIndex, boolean speculative) Evaluate a predicate specified in the lexer.
protected int	LexerATNSimulator.execATN(CharStream input, DFAState ds0)
protected int	LexerATNSimulator.execATN(CharStream input, DFAState ds0)
protected int	ParserATNSimulator.execATN(DFA dfa, DFAState s0, TokenStream input, int startIndex, ParserRuleContext outerContext) Performs ATN simulation to compute a predicted alternative based upon the remaining input, but also updates the DFA cache to avoid having to traverse the ATN again for the same input sequence.
protected int	ParserATNSimulator.execATN(DFA dfa, DFAState s0, TokenStream input, int startIndex, ParserRuleContext outerContext) Performs ATN simulation to compute a predicted alternative based upon the remaining input, but also updates the DFA cache to avoid having to traverse the ATN again for the same input sequence.
protected int	ParserATNSimulator.execATN(DFA dfa, DFAState s0, TokenStream input, int startIndex, ParserRuleContext outerContext) Performs ATN simulation to compute a predicted alternative based upon the remaining input, but also updates the DFA cache to avoid having to traverse the ATN again for the same input sequence.
protected int	ParserATNSimulator.execATNWithFullContext(DFA dfa, DFAState D, ATNConfigSet s0, TokenStream input, int startIndex, ParserRuleContext outerContext)
protected int	ParserATNSimulator.execATNWithFullContext(DFA dfa, DFAState D, ATNConfigSet s0, TokenStream input, int startIndex, ParserRuleContext outerContext)
void	LexerTypeAction.execute(Lexer lexer) Execute the lexer action in the context of the specified Lexer.
void	LexerSkipAction.execute(Lexer lexer) Execute the lexer action in the context of the specified Lexer.
void	LexerPushModeAction.execute(Lexer lexer) Execute the lexer action in the context of the specified Lexer.
void	LexerPopModeAction.execute(Lexer lexer) Execute the lexer action in the context of the specified Lexer.
void	LexerMoreAction.execute(Lexer lexer) Execute the lexer action in the context of the specified Lexer.
void	LexerModeAction.execute(Lexer lexer) Execute the lexer action in the context of the specified Lexer.
void	LexerCustomAction.execute(Lexer lexer) Execute the lexer action in the context of the specified Lexer.
void	LexerChannelAction.execute(Lexer lexer) Execute the lexer action in the context of the specified Lexer.
void	LexerAction.execute(Lexer lexer) Execute the lexer action in the context of the specified Lexer.
void	LexerActionExecutor.execute(Lexer lexer, CharStream input, int startIndex) Execute the actions encapsulated by this executor within the context of a particular Lexer.
static PredictionContext	PredictionContext.fromRuleContext(ATN atn, RuleContext outerContext) Convert a RuleContext tree to a PredictionContext graph.
static BitSet	PredictionMode.getAlts(Collection<BitSet> altsets) Gets the complete set of represented alternatives for a collection of alternative subsets.
static PredictionContext	PredictionContext.getCachedContext(PredictionContext context, PredictionContextCache contextCache, IdentityHashMap<PredictionContext,PredictionContext> visited)
static PredictionContext	PredictionContext.getCachedContext(PredictionContext context, PredictionContextCache contextCache, IdentityHashMap<PredictionContext,PredictionContext> visited)
static PredictionContext	PredictionContext.getCachedContext(PredictionContext context, PredictionContextCache contextCache, IdentityHashMap<PredictionContext,PredictionContext> visited)
protected BitSet	ParserATNSimulator.getConflictingAlts(ATNConfigSet configs) Gets a BitSet containing the alternatives in configs which are part of one or more conflicting alternative subsets.
static Collection<BitSet>	PredictionMode.getConflictingAltSubsets(ATNConfigSet configs) This function gets the conflicting alt subsets from a configuration set.
protected ATNConfig	ParserATNSimulator.getEpsilonTarget(ATNConfig config, Transition t, boolean collectPredicates, boolean inContext, boolean fullCtx, boolean treatEofAsEpsilon)
protected ATNConfig	ParserATNSimulator.getEpsilonTarget(ATNConfig config, Transition t, boolean collectPredicates, boolean inContext, boolean fullCtx, boolean treatEofAsEpsilon)
protected LexerATNConfig	LexerATNSimulator.getEpsilonTarget(CharStream input, LexerATNConfig config, Transition t, ATNConfigSet configs, boolean speculative, boolean treatEofAsEpsilon)
protected LexerATNConfig	LexerATNSimulator.getEpsilonTarget(CharStream input, LexerATNConfig config, Transition t, ATNConfigSet configs, boolean speculative, boolean treatEofAsEpsilon)
protected LexerATNConfig	LexerATNSimulator.getEpsilonTarget(CharStream input, LexerATNConfig config, Transition t, ATNConfigSet configs, boolean speculative, boolean treatEofAsEpsilon)
protected LexerATNConfig	LexerATNSimulator.getEpsilonTarget(CharStream input, LexerATNConfig config, Transition t, ATNConfigSet configs, boolean speculative, boolean treatEofAsEpsilon)
protected DFAState	ParserATNSimulator.getExistingTargetState(DFAState previousD, int t) Get an existing target state for an edge in the DFA.
protected DFAState	LexerATNSimulator.getExistingTargetState(DFAState s, int t) Get an existing target state for an edge in the DFA.
protected SemanticContext[]	ParserATNSimulator.getPredsForAmbigAlts(BitSet ambigAlts, ATNConfigSet configs, int nalts)
protected SemanticContext[]	ParserATNSimulator.getPredsForAmbigAlts(BitSet ambigAlts, ATNConfigSet configs, int nalts)
protected void	LexerATNSimulator.getReachableConfigSet(CharStream input, ATNConfigSet closure, ATNConfigSet reach, int t) Given a starting configuration set, figure out all ATN configurations we can reach upon input t.
protected void	LexerATNSimulator.getReachableConfigSet(CharStream input, ATNConfigSet closure, ATNConfigSet reach, int t) Given a starting configuration set, figure out all ATN configurations we can reach upon input t.
protected void	LexerATNSimulator.getReachableConfigSet(CharStream input, ATNConfigSet closure, ATNConfigSet reach, int t) Given a starting configuration set, figure out all ATN configurations we can reach upon input t.
protected ATNState	ParserATNSimulator.getReachableTarget(Transition trans, int ttype)
static int	PredictionMode.getSingleViableAlt(Collection<BitSet> altsets)
static Map<ATNState,BitSet>	PredictionMode.getStateToAltMap(ATNConfigSet configs) Get a map from state to alt subset from a configuration set.
String	LexerATNSimulator.getText(CharStream input) Get the text matched so far for the current token.
protected static int	ParserATNSimulator.getUniqueAlt(ATNConfigSet configs)
static int	PredictionMode.getUniqueAlt(Collection<BitSet> altsets) Returns the unique alternative predicted by all alternative subsets in altsets.
static boolean	PredictionMode.hasConflictingAltSet(Collection<BitSet> altsets) Determines if any single alternative subset in altsets contains more than one alternative.
static boolean	PredictionMode.hasNonConflictingAltSet(Collection<BitSet> altsets) Determines if any single alternative subset in altsets contains exactly one alternative.
static boolean	PredictionMode.hasSLLConflictTerminatingPrediction(PredictionMode mode, ATNConfigSet configs) Computes the SLL prediction termination condition.
static boolean	PredictionMode.hasStateAssociatedWithOneAlt(ATNConfigSet configs)
IntervalSet	LL1Analyzer.LOOK(ATNState s, ATNState stopState, RuleContext ctx) Compute set of tokens that can follow s in the ATN in the specified ctx.
IntervalSet	LL1Analyzer.LOOK(ATNState s, RuleContext ctx) Compute set of tokens that can follow s in the ATN in the specified ctx.
protected void	ATNDeserializer.markPrecedenceDecisions(ATN atn) Analyze the StarLoopEntryState states in the specified ATN to set the StarLoopEntryState.precedenceRuleDecision field to the correct value.
int	LexerATNSimulator.match(CharStream input, int mode)
protected int	LexerATNSimulator.matchATN(CharStream input)
IntervalSet	ATN.nextTokens(ATNState s) Compute the set of valid tokens that can occur starting in s and staying in same rule.
protected NoViableAltException	ParserATNSimulator.noViableAlt(TokenStream input, ParserRuleContext outerContext, ATNConfigSet configs, int startIndex)
protected NoViableAltException	ParserATNSimulator.noViableAlt(TokenStream input, ParserRuleContext outerContext, ATNConfigSet configs, int startIndex)
protected NoViableAltException	ParserATNSimulator.noViableAlt(TokenStream input, ParserRuleContext outerContext, ATNConfigSet configs, int startIndex)
ATNConfig	ParserATNSimulator.precedenceTransition(ATNConfig config, PrecedencePredicateTransition pt, boolean collectPredicates, boolean inContext, boolean fullCtx)
ATNConfig	ParserATNSimulator.precedenceTransition(ATNConfig config, PrecedencePredicateTransition pt, boolean collectPredicates, boolean inContext, boolean fullCtx)
protected ATNConfig	ParserATNSimulator.predTransition(ATNConfig config, PredicateTransition pt, boolean collectPredicates, boolean inContext, boolean fullCtx)
protected ATNConfig	ParserATNSimulator.predTransition(ATNConfig config, PredicateTransition pt, boolean collectPredicates, boolean inContext, boolean fullCtx)
protected ATNConfigSet	ParserATNSimulator.removeAllConfigsNotInRuleStopState(ATNConfigSet configs, boolean lookToEndOfRule) Return a configuration set containing only the configurations from configs which are in a RuleStopState.
void	ATN.removeState(ATNState state)
protected void	ProfilingATNSimulator.reportAmbiguity(DFA dfa, DFAState D, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs)
protected void	ProfilingATNSimulator.reportAmbiguity(DFA dfa, DFAState D, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs)
protected void	ParserATNSimulator.reportAmbiguity(DFA dfa, DFAState D, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs) If context sensitive parsing, we know it's ambiguity not conflict
protected void	ParserATNSimulator.reportAmbiguity(DFA dfa, DFAState D, int startIndex, int stopIndex, boolean exact, BitSet ambigAlts, ATNConfigSet configs) If context sensitive parsing, we know it's ambiguity not conflict
protected void	ProfilingATNSimulator.reportAttemptingFullContext(DFA dfa, BitSet conflictingAlts, ATNConfigSet configs, int startIndex, int stopIndex)
protected void	ProfilingATNSimulator.reportAttemptingFullContext(DFA dfa, BitSet conflictingAlts, ATNConfigSet configs, int startIndex, int stopIndex)
protected void	ParserATNSimulator.reportAttemptingFullContext(DFA dfa, BitSet conflictingAlts, ATNConfigSet configs, int startIndex, int stopIndex)
protected void	ParserATNSimulator.reportAttemptingFullContext(DFA dfa, BitSet conflictingAlts, ATNConfigSet configs, int startIndex, int stopIndex)
protected void	ProfilingATNSimulator.reportContextSensitivity(DFA dfa, int prediction, ATNConfigSet configs, int startIndex, int stopIndex)
protected void	ProfilingATNSimulator.reportContextSensitivity(DFA dfa, int prediction, ATNConfigSet configs, int startIndex, int stopIndex)
protected void	ParserATNSimulator.reportContextSensitivity(DFA dfa, int prediction, ATNConfigSet configs, int startIndex, int stopIndex)
protected void	ParserATNSimulator.reportContextSensitivity(DFA dfa, int prediction, ATNConfigSet configs, int startIndex, int stopIndex)
static int	PredictionMode.resolvesToJustOneViableAlt(Collection<BitSet> altsets) Full LL prediction termination.
protected ATNConfig	ParserATNSimulator.ruleTransition(ATNConfig config, RuleTransition t)
protected ATNConfig	ParserATNSimulator.ruleTransition(ATNConfig config, RuleTransition t)
void	ParserATNSimulator.setPredictionMode(PredictionMode mode)

Constructor parameters in org.antlr.v4.runtime.atn with annotations of type NotNull

Constructor and Description
ActionTransition(ATNState target, int ruleIndex)
ActionTransition(ATNState target, int ruleIndex, int actionIndex, boolean isCtxDependent)
AmbiguityInfo(int decision, ATNConfigSet configs, TokenStream input, int startIndex, int stopIndex, boolean fullCtx) Constructs a new instance of the AmbiguityInfo class with the specified detailed ambiguity information.
AmbiguityInfo(int decision, ATNConfigSet configs, TokenStream input, int startIndex, int stopIndex, boolean fullCtx) Constructs a new instance of the AmbiguityInfo class with the specified detailed ambiguity information.
ATN(ATNType grammarType, int maxTokenType) Used for runtime deserialization of ATNs from strings
ATNConfig(ATNConfig c, ATNState state)
ATNConfig(ATNConfig c, ATNState state)
ATNConfig(ATNConfig c, ATNState state, PredictionContext context)
ATNConfig(ATNConfig c, ATNState state, PredictionContext context)
ATNConfig(ATNConfig c, ATNState state, PredictionContext context, SemanticContext semanticContext)
ATNConfig(ATNConfig c, ATNState state, PredictionContext context, SemanticContext semanticContext)
ATNConfig(ATNConfig c, ATNState state, PredictionContext context, SemanticContext semanticContext)
ATNConfig(ATNConfig c, ATNState state, SemanticContext semanticContext)
ATNConfig(ATNConfig c, ATNState state, SemanticContext semanticContext)
ATNConfig(ATNConfig c, ATNState state, SemanticContext semanticContext)
ATNConfig(ATNConfig c, SemanticContext semanticContext)
ATNConfig(ATNConfig c, SemanticContext semanticContext)
ATNConfig(ATNState state, int alt, PredictionContext context)
ATNConfig(ATNState state, int alt, PredictionContext context, SemanticContext semanticContext)
ATNConfig(ATNState state, int alt, PredictionContext context, SemanticContext semanticContext)
ATNSimulator(ATN atn, PredictionContextCache sharedContextCache)
ATNSimulator(ATN atn, PredictionContextCache sharedContextCache)
AtomTransition(ATNState target, int label)
ContextSensitivityInfo(int decision, ATNConfigSet configs, TokenStream input, int startIndex, int stopIndex) Constructs a new instance of the ContextSensitivityInfo class with the specified detailed context sensitivity information.
ContextSensitivityInfo(int decision, ATNConfigSet configs, TokenStream input, int startIndex, int stopIndex) Constructs a new instance of the ContextSensitivityInfo class with the specified detailed context sensitivity information.
DecisionEventInfo(int decision, ATNConfigSet configs, TokenStream input, int startIndex, int stopIndex, boolean fullCtx)
EpsilonTransition(ATNState target)
ErrorInfo(int decision, ATNConfigSet configs, TokenStream input, int startIndex, int stopIndex, boolean fullCtx) Constructs a new instance of the ErrorInfo class with the specified detailed syntax error information.
ErrorInfo(int decision, ATNConfigSet configs, TokenStream input, int startIndex, int stopIndex, boolean fullCtx) Constructs a new instance of the ErrorInfo class with the specified detailed syntax error information.
LexerActionExecutor(LexerAction[] lexerActions) Constructs an executor for a sequence of LexerAction actions.
LexerATNConfig(ATNState state, int alt, PredictionContext context)
LexerATNConfig(ATNState state, int alt, PredictionContext context, LexerActionExecutor lexerActionExecutor)
LexerATNConfig(LexerATNConfig c, ATNState state)
LexerATNConfig(LexerATNConfig c, ATNState state)
LexerATNConfig(LexerATNConfig c, ATNState state, LexerActionExecutor lexerActionExecutor)
LexerATNConfig(LexerATNConfig c, ATNState state, LexerActionExecutor lexerActionExecutor)
LexerATNConfig(LexerATNConfig c, ATNState state, PredictionContext context)
LexerATNConfig(LexerATNConfig c, ATNState state, PredictionContext context)
LexerATNSimulator(ATN atn, DFA[] decisionToDFA, PredictionContextCache sharedContextCache)
LexerATNSimulator(ATN atn, DFA[] decisionToDFA, PredictionContextCache sharedContextCache)
LexerATNSimulator(ATN atn, DFA[] decisionToDFA, PredictionContextCache sharedContextCache)
LexerATNSimulator(Lexer recog, ATN atn, DFA[] decisionToDFA, PredictionContextCache sharedContextCache)
LexerATNSimulator(Lexer recog, ATN atn, DFA[] decisionToDFA, PredictionContextCache sharedContextCache)
LexerATNSimulator(Lexer recog, ATN atn, DFA[] decisionToDFA, PredictionContextCache sharedContextCache)
LexerIndexedCustomAction(int offset, LexerAction action) Constructs a new indexed custom action by associating a character offset with a LexerAction.
LL1Analyzer(ATN atn)
LookaheadEventInfo(int decision, ATNConfigSet configs, TokenStream input, int startIndex, int stopIndex, boolean fullCtx) Constructs a new instance of the LookaheadEventInfo class with the specified detailed lookahead information.
NotSetTransition(ATNState target, IntervalSet set)
ParseInfo(ProfilingATNSimulator atnSimulator)
ParserATNSimulator(ATN atn, DFA[] decisionToDFA, PredictionContextCache sharedContextCache) Testing only!
ParserATNSimulator(ATN atn, DFA[] decisionToDFA, PredictionContextCache sharedContextCache) Testing only!
ParserATNSimulator(ATN atn, DFA[] decisionToDFA, PredictionContextCache sharedContextCache) Testing only!
ParserATNSimulator(Parser parser, ATN atn, DFA[] decisionToDFA, PredictionContextCache sharedContextCache)
ParserATNSimulator(Parser parser, ATN atn, DFA[] decisionToDFA, PredictionContextCache sharedContextCache)
ParserATNSimulator(Parser parser, ATN atn, DFA[] decisionToDFA, PredictionContextCache sharedContextCache)
PrecedencePredicateTransition(ATNState target, int precedence)
PredicateEvalInfo(int decision, TokenStream input, int startIndex, int stopIndex, SemanticContext semctx, boolean evalResult, int predictedAlt, boolean fullCtx) Constructs a new instance of the PredicateEvalInfo class with the specified detailed predicate evaluation information.
PredicateEvalInfo(int decision, TokenStream input, int startIndex, int stopIndex, SemanticContext semctx, boolean evalResult, int predictedAlt, boolean fullCtx) Constructs a new instance of the PredicateEvalInfo class with the specified detailed predicate evaluation information.
PredicateTransition(ATNState target, int ruleIndex, int predIndex, boolean isCtxDependent)
RangeTransition(ATNState target, int from, int to)
RuleTransition(RuleStartState ruleStart, int ruleIndex, ATNState followState) Deprecated. Use RuleTransition.RuleTransition(RuleStartState, int, int, ATNState) instead.
RuleTransition(RuleStartState ruleStart, int ruleIndex, ATNState followState) Deprecated. Use RuleTransition.RuleTransition(RuleStartState, int, int, ATNState) instead.
RuleTransition(RuleStartState ruleStart, int ruleIndex, int precedence, ATNState followState)
RuleTransition(RuleStartState ruleStart, int ruleIndex, int precedence, ATNState followState)
SemanticContext.AND(SemanticContext a, SemanticContext b)
SemanticContext.AND(SemanticContext a, SemanticContext b)
SemanticContext.OR(SemanticContext a, SemanticContext b)
SemanticContext.OR(SemanticContext a, SemanticContext b)
SetTransition(ATNState target, IntervalSet set)
Transition(ATNState target)
WildcardTransition(ATNState target)

Uses of NotNull in org.antlr.v4.runtime.dfa

Fields in org.antlr.v4.runtime.dfa with annotations of type NotNull

Modifier and Type	Field and Description
DecisionState	DFA.atnStartState From which ATN state did we create this DFA?
ATNConfigSet	DFAState.configs
SemanticContext	DFAState.PredPrediction.pred
Map<DFAState,DFAState>	DFA.states A set of all DFA states.

Methods in org.antlr.v4.runtime.dfa with annotations of type NotNull

Modifier and Type	Method and Description
protected String	LexerDFASerializer.getEdgeLabel(int i)
List<DFAState>	DFA.getStates() Return a list of all states in this DFA, ordered by state number.
protected String	DFASerializer.getStateString(DFAState s)

Method parameters in org.antlr.v4.runtime.dfa with annotations of type NotNull

Modifier and Type	Method and Description
protected String	DFASerializer.getStateString(DFAState s)

Constructor parameters in org.antlr.v4.runtime.dfa with annotations of type NotNull

Constructor and Description
DFA(DecisionState atnStartState)
DFA(DecisionState atnStartState, int decision)
DFASerializer(DFA dfa, String[] tokenNames)
DFAState(ATNConfigSet configs)
LexerDFASerializer(DFA dfa)

Uses of NotNull in org.antlr.v4.runtime.misc

Fields in org.antlr.v4.runtime.misc with annotations of type NotNull

Modifier and Type	Field and Description
protected AbstractEqualityComparator<? super K>	FlexibleHashMap.comparator
protected AbstractEqualityComparator<? super T>	Array2DHashSet.comparator

Methods in org.antlr.v4.runtime.misc with annotations of type NotNull

Modifier and Type	Method and Description
IntSet	IntSet.addAll(IntSet set) Modify the current IntSet object to contain all elements that are present in itself, the specified set, or both.
static IntervalSet	IntervalSet.of(int a) Create a set with a single element, el.
static IntervalSet	IntervalSet.subtract(IntervalSet left, IntervalSet right) Compute the set difference between two interval sets.
List<Integer>	IntSet.toList() Return a list containing the elements represented by the current set.

Constructor parameters in org.antlr.v4.runtime.misc with annotations of type NotNull

Constructor and Description
IntegerList(Collection<Integer> list)
IntegerList(IntegerList list)
IntegerStack(IntegerStack list)

Uses of NotNull in org.antlr.v4.runtime.tree

Methods in org.antlr.v4.runtime.tree with annotations of type NotNull

Modifier and Type	Method and Description
static List<? extends Tree>	Trees.getAncestors(Tree t) Return a list of all ancestors of this node.
Interval	SyntaxTree.getSourceInterval() Return an Interval indicating the index in the TokenStream of the first and last token associated with this subtree.

Method parameters in org.antlr.v4.runtime.tree with annotations of type NotNull

Modifier and Type	Method and Description
void	ParseTreeListener.enterEveryRule(ParserRuleContext ctx)
void	ParseTreeListener.exitEveryRule(ParserRuleContext ctx)
static List<? extends Tree>	Trees.getAncestors(Tree t) Return a list of all ancestors of this node.
static String	Trees.getNodeText(Tree t, List<String> ruleNames)
static String	Trees.getNodeText(Tree t, Parser recog)
protected boolean	AbstractParseTreeVisitor.shouldVisitNextChild(RuleNode node, T currentResult) This method is called after visiting each child in AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode).
static String	Trees.toStringTree(Tree t) Print out a whole tree in LISP form.
static String	Trees.toStringTree(Tree t, List<String> ruleNames) Print out a whole tree in LISP form.
static String	Trees.toStringTree(Tree t, Parser recog) Print out a whole tree in LISP form.
T	ParseTreeVisitor.visit(ParseTree tree) Visit a parse tree, and return a user-defined result of the operation.
T	AbstractParseTreeVisitor.visit(ParseTree tree) Visit a parse tree, and return a user-defined result of the operation.
T	ParseTreeVisitor.visitChildren(RuleNode node) Visit the children of a node, and return a user-defined result of the operation.
T	AbstractParseTreeVisitor.visitChildren(RuleNode node) Visit the children of a node, and return a user-defined result of the operation.
T	ParseTreeVisitor.visitErrorNode(ErrorNode node) Visit an error node, and return a user-defined result of the operation.
void	ParseTreeListener.visitErrorNode(ErrorNode node)
T	AbstractParseTreeVisitor.visitErrorNode(ErrorNode node) Visit an error node, and return a user-defined result of the operation.
T	ParseTreeVisitor.visitTerminal(TerminalNode node) Visit a terminal node, and return a user-defined result of the operation.
void	ParseTreeListener.visitTerminal(TerminalNode node)
T	AbstractParseTreeVisitor.visitTerminal(TerminalNode node) Visit a terminal node, and return a user-defined result of the operation.

Uses of NotNull in org.antlr.v4.runtime.tree.gui

Methods in org.antlr.v4.runtime.tree.gui with annotations of type NotNull

Modifier and Type	Method and Description
Future<JDialog>	TreeViewer.open()
protected static JDialog	TreeViewer.showInDialog(TreeViewer viewer)

Uses of NotNull in org.antlr.v4.runtime.tree.pattern

Methods in org.antlr.v4.runtime.tree.pattern with annotations of type NotNull

Modifier and Type	Method and Description
List<ParseTreeMatch>	ParseTreePattern.findAll(ParseTree tree, String xpath) Find all nodes using XPath and then try to match those subtrees against this tree pattern.
List<ParseTree>	ParseTreeMatch.getAll(String label) Return all nodes matching a rule or token tag with the specified label.
MultiMap<String,ParseTree>	ParseTreeMatch.getLabels() Return a mapping from label → [list of nodes].
Lexer	ParseTreePatternMatcher.getLexer() Used to convert the tree pattern string into a series of tokens.
ParseTreePatternMatcher	ParseTreePattern.getMatcher() Get the ParseTreePatternMatcher which created this tree pattern.
Parser	ParseTreePatternMatcher.getParser() Used to collect to the grammar file name, token names, rule names for used to parse the pattern into a parse tree.
String	ParseTreePattern.getPattern() Get the tree pattern in concrete syntax form.
ParseTreePattern	ParseTreeMatch.getPattern() Get the tree pattern we are matching against.
ParseTree	ParseTreePattern.getPatternTree() Get the tree pattern as a ParseTree.
String	RuleTagToken.getRuleName() Gets the name of the rule associated with this rule tag.
String	TokenTagToken.getTokenName() Gets the token name.
ParseTree	ParseTreeMatch.getTree() Get the parse tree we are trying to match to a pattern.
ParseTreeMatch	ParseTreePattern.match(ParseTree tree) Match a specific parse tree against this tree pattern.
ParseTreeMatch	ParseTreePatternMatcher.match(ParseTree tree, ParseTreePattern pattern) Compare pattern matched against tree and return a ParseTreeMatch object that contains the matched elements, or the node at which the match failed.

Method parameters in org.antlr.v4.runtime.tree.pattern with annotations of type NotNull

Modifier and Type	Method and Description
List<ParseTreeMatch>	ParseTreePattern.findAll(ParseTree tree, String xpath) Find all nodes using XPath and then try to match those subtrees against this tree pattern.
List<ParseTreeMatch>	ParseTreePattern.findAll(ParseTree tree, String xpath) Find all nodes using XPath and then try to match those subtrees against this tree pattern.
List<ParseTree>	ParseTreeMatch.getAll(String label) Return all nodes matching a rule or token tag with the specified label.
ParseTreeMatch	ParseTreePattern.match(ParseTree tree) Match a specific parse tree against this tree pattern.
ParseTreeMatch	ParseTreePatternMatcher.match(ParseTree tree, ParseTreePattern pattern) Compare pattern matched against tree and return a ParseTreeMatch object that contains the matched elements, or the node at which the match failed.
ParseTreeMatch	ParseTreePatternMatcher.match(ParseTree tree, ParseTreePattern pattern) Compare pattern matched against tree and return a ParseTreeMatch object that contains the matched elements, or the node at which the match failed.
boolean	ParseTreePattern.matches(ParseTree tree) Determine whether or not a parse tree matches this tree pattern.
protected ParseTree	ParseTreePatternMatcher.matchImpl(ParseTree tree, ParseTree patternTree, MultiMap<String,ParseTree> labels) Recursively walk tree against patternTree, filling match.labels.
protected ParseTree	ParseTreePatternMatcher.matchImpl(ParseTree tree, ParseTree patternTree, MultiMap<String,ParseTree> labels) Recursively walk tree against patternTree, filling match.labels.
protected ParseTree	ParseTreePatternMatcher.matchImpl(ParseTree tree, ParseTree patternTree, MultiMap<String,ParseTree> labels) Recursively walk tree against patternTree, filling match.labels.

Constructor parameters in org.antlr.v4.runtime.tree.pattern with annotations of type NotNull

Constructor and Description
ParseTreeMatch(ParseTree tree, ParseTreePattern pattern, MultiMap<String,ParseTree> labels, ParseTree mismatchedNode) Constructs a new instance of ParseTreeMatch from the specified parse tree and pattern.
ParseTreeMatch(ParseTree tree, ParseTreePattern pattern, MultiMap<String,ParseTree> labels, ParseTree mismatchedNode) Constructs a new instance of ParseTreeMatch from the specified parse tree and pattern.
ParseTreeMatch(ParseTree tree, ParseTreePattern pattern, MultiMap<String,ParseTree> labels, ParseTree mismatchedNode) Constructs a new instance of ParseTreeMatch from the specified parse tree and pattern.
ParseTreePattern(ParseTreePatternMatcher matcher, String pattern, int patternRuleIndex, ParseTree patternTree) Construct a new instance of the ParseTreePattern class.
ParseTreePattern(ParseTreePatternMatcher matcher, String pattern, int patternRuleIndex, ParseTree patternTree) Construct a new instance of the ParseTreePattern class.
ParseTreePattern(ParseTreePatternMatcher matcher, String pattern, int patternRuleIndex, ParseTree patternTree) Construct a new instance of the ParseTreePattern class.
RuleTagToken(String ruleName, int bypassTokenType) Constructs a new instance of RuleTagToken with the specified rule name and bypass token type and no label.
RuleTagToken(String ruleName, int bypassTokenType, String label) Constructs a new instance of RuleTagToken with the specified rule name, bypass token type, and label.
TokenTagToken(String tokenName, int type) Constructs a new instance of TokenTagToken for an unlabeled tag with the specified token name and type.
TokenTagToken(String tokenName, int type, String label) Constructs a new instance of TokenTagToken with the specified token name, type, and label.