Grammar

java.lang.Object
- org.antlr.v4.tool.Grammar

All Implemented Interfaces:

AttributeResolver

Direct Known Subclasses:

LexerGrammar
```
public class Grammar
extends java.lang.Object
implements AttributeResolver
```

Field Summary

Fields
Modifier and Type	Field and Description
`static java.util.Set<java.lang.String>`	`actionOptions`
`GrammarRootAST`	`ast`
`ATN`	`atn` The ATN that represents the grammar with edges labelled with tokens or epsilon.
`static java.lang.String`	`AUTO_GENERATED_TOKEN_NAME_PREFIX`
`java.util.Map<java.lang.String,java.lang.Integer>`	`channelNameToValueMap` Map channel like `COMMENTS_CHANNEL` to its constant channel value.
`java.util.List<java.lang.String>`	`channelValueToNameList` Map a constant channel value to its name.
`java.util.Map<java.lang.Integer,DFA>`	`decisionDFAs`
`java.util.List<IntervalSet[]>`	`decisionLOOK`
`static java.util.Set<java.lang.String>`	`doNotCopyOptionsToLexer`
`java.lang.String`	`fileName`
`static java.lang.String`	`GRAMMAR_FROM_STRING_NAME`
`static java.util.Map<java.lang.String,AttributeDict>`	`grammarAndLabelRefTypeToScope`
`LexerGrammar`	`implicitLexer` Was this parser grammar created from a COMBINED grammar? If so, this is what we extracted.
`java.util.List<Grammar>`	`importedGrammars`
`java.util.LinkedHashMap<java.lang.Integer,PredAST>`	`indexToPredMap` Map the other direction upon demand
`java.util.List<Rule>`	`indexToRule`
`static java.lang.String`	`INVALID_RULE_NAME` This value is used as the name for elements in the array returned by `getRuleNames()` for indexes not associated with a rule.
`static java.lang.String`	`INVALID_TOKEN_NAME` This value is used in the following situations to indicate that a token type does not have an associated name which can be directly referenced in a grammar.
`java.util.LinkedHashMap<ActionAST,java.lang.Integer>`	`lexerActions` Tracks all user lexer actions in all alternatives of all rules.
`static java.util.Set<java.lang.String>`	`LexerBlockOptions`
`static java.util.Set<java.lang.String>`	`lexerOptions`
`(package private) int`	`maxChannelType` The maximum channel value which is assigned by this grammar.
`(package private) int`	`maxTokenType` Token names and literal tokens like "void" are uniquely indexed.
`java.lang.String`	`name`
`java.util.Map<java.lang.String,ActionAST>`	`namedActions` Map a name to an action.
`Grammar`	`originalGrammar` If this is an extracted/implicit lexer, we point at original grammar
`org.antlr.runtime.TokenStream`	`originalTokenStream` If we transform grammar, track original unaltered token stream.
`Grammar`	`parent` If we're imported, who imported us? If null, implies grammar is root
`static java.util.Set<java.lang.String>`	`ParserBlockOptions`
`static java.util.Set<java.lang.String>`	`parserOptions`
`(package private) int`	`ruleNumber`
`static java.util.Set<java.lang.String>`	`ruleOptions`
`static java.util.Set<java.lang.String>`	`ruleRefOptions` Legal options for rule refs like id<key=value>
`OrderedHashMap<java.lang.String,Rule>`	`rules` All rules defined in this specific grammar, not imported.
`static java.util.Set<java.lang.String>`	`semPredOptions`
`java.util.LinkedHashMap<PredAST,java.lang.Integer>`	`sempreds` All sempreds found in grammar; maps tree node to sempred index; sempred index is 0..n-1
`java.util.Map<java.lang.Integer,Interval>`	`stateToGrammarRegionMap`
`(package private) int`	`stringLiteralRuleNumber`
`java.util.Map<java.lang.String,java.lang.Integer>`	`stringLiteralToTypeMap` Map token literals like `'while'` to its token type.
`java.lang.String`	`text`
`java.util.Map<java.lang.String,java.lang.Integer>`	`tokenNameToTypeMap` Map token like `ID` (but not literals like `'while'`) to its token type.
`static java.util.Set<java.lang.String>`	`tokenOptions` Legal options for terminal refs like ID<assoc=right>
`org.antlr.runtime.TokenStream`	`tokenStream` Track token stream used to create this grammar
`Tool`	`tool`
`java.util.List<java.lang.String>`	`typeToStringLiteralList` Reverse index for `stringLiteralToTypeMap`.
`java.util.List<java.lang.String>`	`typeToTokenList` Map a token type to its token name.

Constructor Summary

Constructors
Constructor and Description
`Grammar(java.lang.String grammarText)` For testing
`Grammar(java.lang.String grammarText, ANTLRToolListener listener)` For testing
`Grammar(java.lang.String grammarText, LexerGrammar tokenVocabSource)`
`Grammar(java.lang.String fileName, java.lang.String grammarText)` For testing; builds trees, does sem anal
`Grammar(java.lang.String fileName, java.lang.String grammarText, ANTLRToolListener listener)` For testing; builds trees, does sem anal
`Grammar(java.lang.String fileName, java.lang.String grammarText, Grammar tokenVocabSource, ANTLRToolListener listener)` For testing; builds trees, does sem anal
`Grammar(Tool tool, GrammarRootAST ast)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`GrammarParserInterpreter`	`createGrammarParserInterpreter(TokenStream tokenStream)`
`LexerInterpreter`	`createLexerInterpreter(CharStream input)`
`ParserInterpreter`	`createParserInterpreter(TokenStream tokenStream)`
`protected static boolean`	`defAlias(GrammarAST r, java.lang.String pattern, org.antlr.runtime.tree.TreeWizard wiz, java.util.List<Pair<GrammarAST,GrammarAST>> lexerRuleToStringLiteral)`
`void`	`defineAction(GrammarAST atAST)`
`int`	`defineChannelName(java.lang.String name)` Define a token channel with a specified name.
`int`	`defineChannelName(java.lang.String name, int value)` Define a token channel with a specified name.
`boolean`	`defineRule(Rule r)` Define the specified rule in the grammar.
`int`	`defineStringLiteral(java.lang.String lit)`
`int`	`defineStringLiteral(java.lang.String lit, int ttype)`
`int`	`defineTokenAlias(java.lang.String name, java.lang.String lit)`
`int`	`defineTokenName(java.lang.String name)`
`int`	`defineTokenName(java.lang.String name, int ttype)`
`IntSet`	`getAllCharValues()` Return min to max char as defined by the target.
`java.util.List<Grammar>`	`getAllImportedGrammars()` Get list of all imports from all grammars in the delegate subtree of g.
`ATN`	`getATN()`
`int`	`getChannelValue(java.lang.String channel)` Gets the constant channel value for a user-defined channel.
`java.lang.String`	`getDefaultActionScope()` Given a grammar type, what should be the default action scope? If I say @members in a COMBINED grammar, for example, the default scope should be "parser".
`java.util.List<Grammar>`	`getGrammarAncestors()` Return list of imported grammars from root down to our parent.
`static java.lang.String`	`getGrammarTypeToFileNameSuffix(int type)`
`LexerGrammar`	`getImplicitLexer()`
`Grammar`	`getImportedGrammar(java.lang.String name)` Return grammar directly imported by this grammar
`java.util.List<Grammar>`	`getImportedGrammars()`
`java.util.LinkedHashMap<java.lang.Integer,PredAST>`	`getIndexToPredicateMap()`
`int`	`getMaxCharValue()` What is the max char value possible for this grammar's target? Use unicode max if no target defined.
`int`	`getMaxTokenType()` How many token types have been allocated so far?
`int`	`getNewChannelNumber()` Return a new unique integer in the channel value space.
`int`	`getNewTokenType()` Return a new unique integer in the token type space
`java.lang.String`	`getOptionString(java.lang.String key)`
`Grammar`	`getOutermostGrammar()` Return the grammar that imported us and our parents.
`java.lang.String`	`getPredicateDisplayString(SemanticContext.Predicate pred)`
`java.lang.String`	`getRecognizerName()` Get the name of the generated recognizer; may or may not be same as grammar name.
`Rule`	`getRule(int index)`
`Rule`	`getRule(java.lang.String name)`
`Rule`	`getRule(java.lang.String grammarName, java.lang.String ruleName)`
`java.lang.String[]`	`getRuleNames()` Gets an array of rule names for rules defined or imported by the grammar.
`java.lang.String`	`getSemanticContextDisplayString(SemanticContext semctx)` Given an arbitrarily complex SemanticContext, walk the "tree" and get display string.
`Interval`	`getStateToGrammarRegion(int atnStateNumber)` Given an ATN state number, return the token index range within the grammar from which that ATN state was derived.
`static java.util.Map<java.lang.Integer,Interval>`	`getStateToGrammarRegionMap(GrammarRootAST ast, IntervalSet grammarTokenTypes)`
`static java.util.List<Pair<GrammarAST,GrammarAST>>`	`getStringLiteralAliasesFromLexerRules(GrammarRootAST ast)` Return list of (TOKEN_NAME node, 'literal' node) pairs
`java.lang.String`	`getStringLiteralLexerRuleName(java.lang.String lit)`
`java.util.Set<java.lang.String>`	`getStringLiterals()`
`java.lang.String`	`getTokenDisplayName(int ttype)` Given a token type, get a meaningful name for it such as the ID or string literal.
`java.lang.String[]`	`getTokenDisplayNames()` Gets an array of display names for tokens defined or imported by the grammar.
`java.lang.String[]`	`getTokenLiteralNames()` Gets the literal names assigned to tokens in the grammar.
`java.lang.String`	`getTokenName(int ttype)` Gets the name by which a token can be referenced in the generated code.
`java.lang.String`	`getTokenName(java.lang.String literal)`
`java.lang.String[]`	`getTokenNames()` Gets an array of token names for tokens defined or imported by the grammar.
`org.antlr.runtime.TokenStream`	`getTokenStream()`
`java.lang.String[]`	`getTokenSymbolicNames()` Gets the symbolic names assigned to tokens in the grammar.
`int`	`getTokenType(java.lang.String token)`
`IntSet`	`getTokenTypes()` Return a set of all possible token or char types for this grammar
`int`	`getType()`
`java.lang.String`	`getTypeString()`
`Vocabulary`	`getVocabulary()` Gets a `Vocabulary` instance describing the vocabulary used by the grammar.
`void`	`importTokensFromTokensFile()`
`void`	`importVocab(Grammar importG)`
`protected void`	`initTokenSymbolTables()`
`boolean`	`isCombined()`
`boolean`	`isLexer()`
`boolean`	`isParser()`
`static boolean`	`isTokenName(java.lang.String id)` Is id a valid token name? Does id start with an uppercase letter?
`java.lang.String`	`joinPredicateOperands(SemanticContext.Operator op, java.lang.String separator)`
`static Grammar`	`load(java.lang.String fileName)` convenience method for Tool.loadGrammar()
`void`	`loadImportedGrammars()`
`boolean`	`resolvesToAttributeDict(java.lang.String x, ActionAST node)`
`boolean`	`resolvesToLabel(java.lang.String x, ActionAST node)`
`boolean`	`resolvesToListLabel(java.lang.String x, ActionAST node)`
`boolean`	`resolvesToToken(java.lang.String x, ActionAST node)`
`Attribute`	`resolveToAttribute(java.lang.String x, ActionAST node)`
`Attribute`	`resolveToAttribute(java.lang.String x, java.lang.String y, ActionAST node)`
`void`	`setChannelNameForValue(int channelValue, java.lang.String name)` Sets the channel name associated with a particular channel value.
`void`	`setLookaheadDFA(int decision, DFA lookaheadDFA)`
`static void`	`setNodeOptions(GrammarAST node, GrammarAST options)` Given ^(TOKEN_REF ^(OPTIONS ^(ELEMENT_OPTIONS (= assoc right)))) set option assoc=right in TOKEN_REF.
`void`	`setTokenForType(int ttype, java.lang.String text)`
`boolean`	`undefineRule(Rule r)` Undefine the specified rule from this `Grammar` instance.

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

- Field Detail
  - GRAMMAR_FROM_STRING_NAME
```
public static final java.lang.String GRAMMAR_FROM_STRING_NAME
```
    See Also:
    
    Constant Field Values
  - INVALID_TOKEN_NAME
```
public static final java.lang.String INVALID_TOKEN_NAME
```
    This value is used in the following situations to indicate that a token type does not have an associated name which can be directly referenced in a grammar.
    - This value is the name and display name for the token with type Token.INVALID_TYPE.
    - This value is the name for tokens with a type not represented by a named token. The display name for these tokens is simply the string representation of the token type as an integer.
    See Also:
    
    Constant Field Values
  - INVALID_RULE_NAME
```
public static final java.lang.String INVALID_RULE_NAME
```
    This value is used as the name for elements in the array returned by getRuleNames() for indexes not associated with a rule.
    
    See Also:
    
    Constant Field Values
  - parserOptions
```
public static final java.util.Set<java.lang.String> parserOptions
```
  - lexerOptions
```
public static final java.util.Set<java.lang.String> lexerOptions
```
  - ruleOptions
```
public static final java.util.Set<java.lang.String> ruleOptions
```
  - ParserBlockOptions
```
public static final java.util.Set<java.lang.String> ParserBlockOptions
```
  - LexerBlockOptions
```
public static final java.util.Set<java.lang.String> LexerBlockOptions
```
  - ruleRefOptions
```
public static final java.util.Set<java.lang.String> ruleRefOptions
```
    Legal options for rule refs like id<key=value>
  - tokenOptions
```
public static final java.util.Set<java.lang.String> tokenOptions
```
    Legal options for terminal refs like ID<assoc=right>
  - actionOptions
```
public static final java.util.Set<java.lang.String> actionOptions
```
  - semPredOptions
```
public static final java.util.Set<java.lang.String> semPredOptions
```
  - doNotCopyOptionsToLexer
```
public static final java.util.Set<java.lang.String> doNotCopyOptionsToLexer
```
  - grammarAndLabelRefTypeToScope
```
public static final java.util.Map<java.lang.String,AttributeDict> grammarAndLabelRefTypeToScope
```
  - name
```
public java.lang.String name
```
  - ast
```
public GrammarRootAST ast
```
  - tokenStream
```
public final org.antlr.runtime.TokenStream tokenStream
```
    Track token stream used to create this grammar
  - originalTokenStream
```
public org.antlr.runtime.TokenStream originalTokenStream
```
    If we transform grammar, track original unaltered token stream. This is set to the same value as tokenStream when tokenStream is initially set. If this field differs from tokenStream, then we have transformed the grammar.
  - text
```
public java.lang.String text
```
  - fileName
```
public java.lang.String fileName
```
  - implicitLexer
```
public LexerGrammar implicitLexer
```
    Was this parser grammar created from a COMBINED grammar? If so, this is what we extracted.
  - originalGrammar
```
public Grammar originalGrammar
```
    If this is an extracted/implicit lexer, we point at original grammar
  - parent
```
public Grammar parent
```
    If we're imported, who imported us? If null, implies grammar is root
  - importedGrammars
```
public java.util.List<Grammar> importedGrammars
```
  - rules
```
public OrderedHashMap<java.lang.String,Rule> rules
```
    All rules defined in this specific grammar, not imported. Also does not include lexical rules if combined.
  - indexToRule
```
public java.util.List<Rule> indexToRule
```
  - ruleNumber
```
int ruleNumber
```
  - stringLiteralRuleNumber
```
int stringLiteralRuleNumber
```
  - atn
```
public ATN atn
```
    The ATN that represents the grammar with edges labelled with tokens or epsilon. It is more suitable to analysis than an AST representation.
  - stateToGrammarRegionMap
```
public java.util.Map<java.lang.Integer,Interval> stateToGrammarRegionMap
```
  - decisionDFAs
```
public java.util.Map<java.lang.Integer,DFA> decisionDFAs
```
  - decisionLOOK
```
public java.util.List<IntervalSet[]> decisionLOOK
```
  - tool
```
public final Tool tool
```
  - maxTokenType
```
int maxTokenType
```
    Token names and literal tokens like "void" are uniquely indexed. with -1 implying EOF. Characters are different; they go from -1 (EOF) to . For example, 0 could be a binary byte you want to lexer. Labels of DFA/ATN transitions can be both tokens and characters. I use negative numbers for bookkeeping labels like EPSILON. Char/String literals and token types overlap in the same space, however.
  - tokenNameToTypeMap
```
public final java.util.Map<java.lang.String,java.lang.Integer> tokenNameToTypeMap
```
    Map token like ID (but not literals like 'while') to its token type.
  - stringLiteralToTypeMap
```
public final java.util.Map<java.lang.String,java.lang.Integer> stringLiteralToTypeMap
```
    Map token literals like 'while' to its token type. It may be that WHILE="while"=35, in which case both tokenNameToTypeMap and this field will have entries both mapped to 35.
  - typeToStringLiteralList
```
public final java.util.List<java.lang.String> typeToStringLiteralList
```
    Reverse index for stringLiteralToTypeMap. Indexed with raw token type. 0 is invalid.
  - typeToTokenList
```
public final java.util.List<java.lang.String> typeToTokenList
```
    Map a token type to its token name. Indexed with raw token type. 0 is invalid.
  - maxChannelType
```
int maxChannelType
```
    The maximum channel value which is assigned by this grammar. Values below Token.MIN_USER_CHANNEL_VALUE are assumed to be predefined.
  - channelNameToValueMap
```
public final java.util.Map<java.lang.String,java.lang.Integer> channelNameToValueMap
```
    Map channel like COMMENTS_CHANNEL to its constant channel value. Only user-defined channels are defined in this map.
  - channelValueToNameList
```
public final java.util.List<java.lang.String> channelValueToNameList
```
    Map a constant channel value to its name. Indexed with raw channel value. The predefined channels Token.DEFAULT_CHANNEL and Token.HIDDEN_CHANNEL are not stored in this list, so the values at the corresponding indexes is null.
  - namedActions
```
public java.util.Map<java.lang.String,ActionAST> namedActions
```
    Map a name to an action. The code generator will use this to fill holes in the output files. I track the AST node for the action in case I need the line number for errors.
  - lexerActions
```
public java.util.LinkedHashMap<ActionAST,java.lang.Integer> lexerActions
```
    Tracks all user lexer actions in all alternatives of all rules. Doesn't track sempreds. maps tree node to action index (alt number 1..n).
  - sempreds
```
public java.util.LinkedHashMap<PredAST,java.lang.Integer> sempreds
```
    All sempreds found in grammar; maps tree node to sempred index; sempred index is 0..n-1
  - indexToPredMap
```
public java.util.LinkedHashMap<java.lang.Integer,PredAST> indexToPredMap
```
    Map the other direction upon demand
  - AUTO_GENERATED_TOKEN_NAME_PREFIX
```
public static final java.lang.String AUTO_GENERATED_TOKEN_NAME_PREFIX
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - Grammar
```
public Grammar(Tool tool,
               GrammarRootAST ast)
```
  - Grammar
```
public Grammar(java.lang.String grammarText)
        throws org.antlr.runtime.RecognitionException
```
    For testing
    
    Throws:
    
    org.antlr.runtime.RecognitionException
  - Grammar
```
public Grammar(java.lang.String grammarText,
               LexerGrammar tokenVocabSource)
        throws org.antlr.runtime.RecognitionException
```
    Throws:
    
    org.antlr.runtime.RecognitionException
  - Grammar
```
public Grammar(java.lang.String grammarText,
               ANTLRToolListener listener)
        throws org.antlr.runtime.RecognitionException
```
    For testing
    
    Throws:
    
    org.antlr.runtime.RecognitionException
  - Grammar
```
public Grammar(java.lang.String fileName,
               java.lang.String grammarText)
        throws org.antlr.runtime.RecognitionException
```
    For testing; builds trees, does sem anal
    
    Throws:
    
    org.antlr.runtime.RecognitionException
  - Grammar
```
public Grammar(java.lang.String fileName,
               java.lang.String grammarText,
               ANTLRToolListener listener)
        throws org.antlr.runtime.RecognitionException
```
    For testing; builds trees, does sem anal
    
    Throws:
    
    org.antlr.runtime.RecognitionException
  - Grammar
```
public Grammar(java.lang.String fileName,
               java.lang.String grammarText,
               Grammar tokenVocabSource,
               ANTLRToolListener listener)
        throws org.antlr.runtime.RecognitionException
```
    For testing; builds trees, does sem anal
    
    Throws:
    
    org.antlr.runtime.RecognitionException
- Method Detail
  - initTokenSymbolTables
```
protected void initTokenSymbolTables()
```
  - loadImportedGrammars
```
public void loadImportedGrammars()
```
  - defineAction
```
public void defineAction(GrammarAST atAST)
```
  - defineRule
```
public boolean defineRule(Rule r)
```
    Define the specified rule in the grammar. This method assigns the rule's Rule.index according to the ruleNumber field, and adds the Rule instance to rules and indexToRule.
    
    Parameters:
    
    r - The rule to define in the grammar.
    
    Returns:
    
    true if the rule was added to the Grammar instance; otherwise, false if a rule with this name already existed in the grammar instance.
  - undefineRule
```
public boolean undefineRule(Rule r)
```
    Undefine the specified rule from this Grammar instance. The instance r is removed from rules and indexToRule. This method updates the Rule.index field for all rules defined after r, and decrements ruleNumber in preparation for adding new rules.
    This method does nothing if the current Grammar does not contain the instance r at index r.index in indexToRule.
    
    Parameters:
    
    r -
    
    Returns:
    
    true if the rule was removed from the Grammar instance; otherwise, false if the specified rule was not defined in the grammar.
  - getRule
```
public Rule getRule(java.lang.String name)
```
  - getATN
```
public ATN getATN()
```
  - getRule
```
public Rule getRule(int index)
```
  - getRule
```
public Rule getRule(java.lang.String grammarName,
                    java.lang.String ruleName)
```
  - getAllImportedGrammars
```
public java.util.List<Grammar> getAllImportedGrammars()
```
    Get list of all imports from all grammars in the delegate subtree of g. The grammars are in import tree preorder. Don't include ourselves in list as we're not a delegate of ourselves.
  - getImportedGrammars
```
public java.util.List<Grammar> getImportedGrammars()
```
  - getImplicitLexer
```
public LexerGrammar getImplicitLexer()
```
  - load
```
public static Grammar load(java.lang.String fileName)
```
    convenience method for Tool.loadGrammar()
  - getGrammarAncestors
```
public java.util.List<Grammar> getGrammarAncestors()
```
    Return list of imported grammars from root down to our parent. Order is [root, ..., this.parent]. (us not included).
  - getOutermostGrammar
```
public Grammar getOutermostGrammar()
```
    Return the grammar that imported us and our parents. Return this if we're root.
  - getRecognizerName
```
public java.lang.String getRecognizerName()
```
    Get the name of the generated recognizer; may or may not be same as grammar name. Recognizer is TParser and TLexer from T if combined, else just use T regardless of grammar type.
  - getStringLiteralLexerRuleName
```
public java.lang.String getStringLiteralLexerRuleName(java.lang.String lit)
```
  - getImportedGrammar
```
public Grammar getImportedGrammar(java.lang.String name)
```
    Return grammar directly imported by this grammar
  - getTokenType
```
public int getTokenType(java.lang.String token)
```
  - getTokenName
```
public java.lang.String getTokenName(java.lang.String literal)
```
  - getTokenDisplayName
```
public java.lang.String getTokenDisplayName(int ttype)
```
    Given a token type, get a meaningful name for it such as the ID or string literal. If this is a lexer and the ttype is in the char vocabulary, compute an ANTLR-valid (possibly escaped) char literal.
  - getTokenName
```
public java.lang.String getTokenName(int ttype)
```
    Gets the name by which a token can be referenced in the generated code. For tokens defined in a tokens{} block or via a lexer rule, this is the declared name of the token. For token types generated by the use of a string literal within a parser rule of a combined grammar, this is the automatically generated token type which includes the AUTO_GENERATED_TOKEN_NAME_PREFIX prefix. For types which are not associated with a defined token, this method returns INVALID_TOKEN_NAME.
    
    Parameters:
    
    ttype - The token type.
    
    Returns:
    
    The name of the token with the specified type.
  - getChannelValue
```
public int getChannelValue(java.lang.String channel)
```
    Gets the constant channel value for a user-defined channel.
    This method only returns channel values for user-defined channels. All other channels, including the predefined channels Token.DEFAULT_CHANNEL and Token.HIDDEN_CHANNEL along with any channel defined in code (e.g. in a @members{} block), are ignored.
    
    Parameters:
    
    channel - The channel name.
    
    Returns:
    
    The channel value, if channel is the name of a known user-defined token channel; otherwise, -1.
  - getRuleNames
```
public java.lang.String[] getRuleNames()
```
    Gets an array of rule names for rules defined or imported by the grammar. The array index is the rule index, and the value is the name of the rule with the corresponding Rule.index.
    If no rule is defined with an index for an element of the resulting array, the value of that element is INVALID_RULE_NAME.
    
    Returns:
    
    The names of all rules defined in the grammar.
  - getTokenNames
```
public java.lang.String[] getTokenNames()
```
    Gets an array of token names for tokens defined or imported by the grammar. The array index is the token type, and the value is the result of getTokenName(java.lang.String) for the corresponding token type.
    
    Returns:
    
    The token names of all tokens defined in the grammar.
    
    See Also:
    
    getTokenName(java.lang.String)
  - getTokenDisplayNames
```
public java.lang.String[] getTokenDisplayNames()
```
    Gets an array of display names for tokens defined or imported by the grammar. The array index is the token type, and the value is the result of getTokenDisplayName(int) for the corresponding token type.
    
    Returns:
    
    The display names of all tokens defined in the grammar.
    
    See Also:
    
    getTokenDisplayName(int)
  - getTokenLiteralNames
```
public java.lang.String[] getTokenLiteralNames()
```
    Gets the literal names assigned to tokens in the grammar.
  - getTokenSymbolicNames
```
public java.lang.String[] getTokenSymbolicNames()
```
    Gets the symbolic names assigned to tokens in the grammar.
  - getVocabulary
```
public Vocabulary getVocabulary()
```
    Gets a Vocabulary instance describing the vocabulary used by the grammar.
  - getSemanticContextDisplayString
```
public java.lang.String getSemanticContextDisplayString(SemanticContext semctx)
```
    Given an arbitrarily complex SemanticContext, walk the "tree" and get display string. Pull predicates from grammar text.
  - joinPredicateOperands
```
public java.lang.String joinPredicateOperands(SemanticContext.Operator op,
                                              java.lang.String separator)
```
  - getIndexToPredicateMap
```
public java.util.LinkedHashMap<java.lang.Integer,PredAST> getIndexToPredicateMap()
```
  - getPredicateDisplayString
```
public java.lang.String getPredicateDisplayString(SemanticContext.Predicate pred)
```
  - getMaxCharValue
```
public int getMaxCharValue()
```
    What is the max char value possible for this grammar's target? Use unicode max if no target defined.
  - getTokenTypes
```
public IntSet getTokenTypes()
```
    Return a set of all possible token or char types for this grammar
  - getAllCharValues
```
public IntSet getAllCharValues()
```
    Return min to max char as defined by the target. If no target, use max unicode char value.
  - getMaxTokenType
```
public int getMaxTokenType()
```
    How many token types have been allocated so far?
  - getNewTokenType
```
public int getNewTokenType()
```
    Return a new unique integer in the token type space
  - getNewChannelNumber
```
public int getNewChannelNumber()
```
    Return a new unique integer in the channel value space.
  - importTokensFromTokensFile
```
public void importTokensFromTokensFile()
```
  - importVocab
```
public void importVocab(Grammar importG)
```
  - defineTokenName
```
public int defineTokenName(java.lang.String name)
```
  - defineTokenName
```
public int defineTokenName(java.lang.String name,
                           int ttype)
```
  - defineStringLiteral
```
public int defineStringLiteral(java.lang.String lit)
```
  - defineStringLiteral
```
public int defineStringLiteral(java.lang.String lit,
                               int ttype)
```
  - defineTokenAlias
```
public int defineTokenAlias(java.lang.String name,
                            java.lang.String lit)
```
  - setTokenForType
```
public void setTokenForType(int ttype,
                            java.lang.String text)
```
  - defineChannelName
```
public int defineChannelName(java.lang.String name)
```
    Define a token channel with a specified name.
    If a channel with the specified name already exists, the previously assigned channel value is returned.
    
    Parameters:
    
    name - The channel name.
    
    Returns:
    
    The constant channel value assigned to the channel.
  - defineChannelName
```
public int defineChannelName(java.lang.String name,
                             int value)
```
    Define a token channel with a specified name.
    If a channel with the specified name already exists, the previously assigned channel value is not altered.
    
    Parameters:
    
    name - The channel name.
    
    Returns:
    
    The constant channel value assigned to the channel.
  - setChannelNameForValue
```
public void setChannelNameForValue(int channelValue,
                                   java.lang.String name)
```
    Sets the channel name associated with a particular channel value.
    If a name has already been assigned to the channel with constant value channelValue, this method does nothing.
    
    Parameters:
    
    channelValue - The constant value for the channel.
    
    name - The channel name.
  - resolveToAttribute
```
public Attribute resolveToAttribute(java.lang.String x,
                                    ActionAST node)
```
    Specified by:
    
    resolveToAttribute in interface AttributeResolver
  - resolveToAttribute
```
public Attribute resolveToAttribute(java.lang.String x,
                                    java.lang.String y,
                                    ActionAST node)
```
    Specified by:
    
    resolveToAttribute in interface AttributeResolver
  - resolvesToLabel
```
public boolean resolvesToLabel(java.lang.String x,
                               ActionAST node)
```
    Specified by:
    
    resolvesToLabel in interface AttributeResolver
  - resolvesToListLabel
```
public boolean resolvesToListLabel(java.lang.String x,
                                   ActionAST node)
```
    Specified by:
    
    resolvesToListLabel in interface AttributeResolver
  - resolvesToToken
```
public boolean resolvesToToken(java.lang.String x,
                               ActionAST node)
```
    Specified by:
    
    resolvesToToken in interface AttributeResolver
  - resolvesToAttributeDict
```
public boolean resolvesToAttributeDict(java.lang.String x,
                                       ActionAST node)
```
    Specified by:
    
    resolvesToAttributeDict in interface AttributeResolver
  - getDefaultActionScope
```
public java.lang.String getDefaultActionScope()
```
    Given a grammar type, what should be the default action scope? If I say @members in a COMBINED grammar, for example, the default scope should be "parser".
  - getType
```
public int getType()
```
  - getTokenStream
```
public org.antlr.runtime.TokenStream getTokenStream()
```
  - isLexer
```
public boolean isLexer()
```
  - isParser
```
public boolean isParser()
```
  - isCombined
```
public boolean isCombined()
```
  - isTokenName
```
public static boolean isTokenName(java.lang.String id)
```
    Is id a valid token name? Does id start with an uppercase letter?
  - getTypeString
```
public java.lang.String getTypeString()
```
  - getGrammarTypeToFileNameSuffix
```
public static java.lang.String getGrammarTypeToFileNameSuffix(int type)
```
  - getOptionString
```
public java.lang.String getOptionString(java.lang.String key)
```
  - setNodeOptions
```
public static void setNodeOptions(GrammarAST node,
                                  GrammarAST options)
```
    Given ^(TOKEN_REF ^(OPTIONS ^(ELEMENT_OPTIONS (= assoc right)))) set option assoc=right in TOKEN_REF.
  - getStringLiteralAliasesFromLexerRules
```
public static java.util.List<Pair<GrammarAST,GrammarAST>> getStringLiteralAliasesFromLexerRules(GrammarRootAST ast)
```
    Return list of (TOKEN_NAME node, 'literal' node) pairs
  - defAlias
```
protected static boolean defAlias(GrammarAST r,
                                  java.lang.String pattern,
                                  org.antlr.runtime.tree.TreeWizard wiz,
                                  java.util.List<Pair<GrammarAST,GrammarAST>> lexerRuleToStringLiteral)
```
  - getStringLiterals
```
public java.util.Set<java.lang.String> getStringLiterals()
```
  - setLookaheadDFA
```
public void setLookaheadDFA(int decision,
                            DFA lookaheadDFA)
```
  - getStateToGrammarRegionMap
```
public static java.util.Map<java.lang.Integer,Interval> getStateToGrammarRegionMap(GrammarRootAST ast,
                                                                                   IntervalSet grammarTokenTypes)
```
  - getStateToGrammarRegion
```
public Interval getStateToGrammarRegion(int atnStateNumber)
```
    Given an ATN state number, return the token index range within the grammar from which that ATN state was derived.
  - createLexerInterpreter
```
public LexerInterpreter createLexerInterpreter(CharStream input)
```
  - createGrammarParserInterpreter
```
public GrammarParserInterpreter createGrammarParserInterpreter(TokenStream tokenStream)
```
    Since:
    
    4.5.1
  - createParserInterpreter
```
public ParserInterpreter createParserInterpreter(TokenStream tokenStream)
```

Class Grammar

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

GRAMMAR_FROM_STRING_NAME

INVALID_TOKEN_NAME

INVALID_RULE_NAME

parserOptions

lexerOptions

ruleOptions

ParserBlockOptions

LexerBlockOptions

ruleRefOptions

tokenOptions

actionOptions

semPredOptions

doNotCopyOptionsToLexer

grammarAndLabelRefTypeToScope

name

ast

tokenStream

originalTokenStream

text

fileName

implicitLexer

originalGrammar

parent

importedGrammars

rules

indexToRule

ruleNumber

stringLiteralRuleNumber

atn

stateToGrammarRegionMap

decisionDFAs

decisionLOOK

tool

maxTokenType

tokenNameToTypeMap

stringLiteralToTypeMap

typeToStringLiteralList

typeToTokenList

maxChannelType

channelNameToValueMap

channelValueToNameList

namedActions

lexerActions

sempreds

indexToPredMap

AUTO_GENERATED_TOKEN_NAME_PREFIX

Constructor Detail

Grammar

Grammar

Grammar

Grammar

Grammar

Grammar

Grammar

Method Detail

initTokenSymbolTables

loadImportedGrammars

defineAction

defineRule

undefineRule

getRule

getATN

getRule

getRule

getAllImportedGrammars

getImportedGrammars

getImplicitLexer

load

getGrammarAncestors

getOutermostGrammar

getRecognizerName

getStringLiteralLexerRuleName

getImportedGrammar

getTokenType