Grammar (ANTLR 4 Tool 4.2.2 API)

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

All Implemented Interfaces:

AttributeResolver

Direct Known Subclasses:

LexerGrammar
```
public class Grammar
extends Object
implements AttributeResolver
```

Field Summary

Fields
Modifier and Type	Field and Description
`static Set<String>`	`actionOptions`
`GrammarRootAST`	`ast`
`ATN`	`atn` The ATN that represents the grammar with edges labelled with tokens or epsilon.
`static String`	`AUTO_GENERATED_TOKEN_NAME_PREFIX`
`Map<Integer,DFA>`	`decisionDFAs`
`List<IntervalSet[]>`	`decisionLOOK`
`static Set<String>`	`doNotCopyOptionsToLexer`
`String`	`fileName`
`static String`	`GRAMMAR_FROM_STRING_NAME`
`static Map<String,AttributeDict>`	`grammarAndLabelRefTypeToScope`
`LexerGrammar`	`implicitLexer` Was this parser grammar created from a COMBINED grammar? If so, this is what we extracted.
`List<Grammar>`	`importedGrammars`
`List<Rule>`	`indexToRule`
`LinkedHashMap<ActionAST,Integer>`	`lexerActions` Tracks all user lexer actions in all alternatives of all rules.
`static Set<String>`	`LexerBlockOptions`
`static Set<String>`	`lexerOptions`
`String`	`name`
`Map<String,ActionAST>`	`namedActions` Map a name to an action.
`Grammar`	`originalGrammar` If this is an extracted/implicit lexer, we point at original grammar
`Grammar`	`parent` If we're imported, who imported us? If null, implies grammar is root
`static Set<String>`	`ParserBlockOptions`
`static Set<String>`	`parserOptions`
`static Set<String>`	`ruleOptions`
`static Set<String>`	`ruleRefOptions` Legal options for rule refs like id
`OrderedHashMap<String,Rule>`	`rules` All rules defined in this specific grammar, not imported.
`static Set<String>`	`semPredOptions`
`LinkedHashMap<PredAST,Integer>`	`sempreds` All sempreds found in grammar; maps tree node to sempred index; sempred index is 0..n-1
`Map<String,Integer>`	`stringLiteralToTypeMap` Map token literals like "while" to its token type.
`String`	`text`
`Map<String,Integer>`	`tokenNameToTypeMap` Map token like ID (but not literals like "while") to its token type
`static Set<String>`	`tokenOptions` Legal options for terminal refs like ID
`org.antlr.runtime.TokenStream`	`tokenStream` Track stream used to create this grammar
`Tool`	`tool`
`List<String>`	`typeToStringLiteralList` Reverse index for stringLiteralToTypeMap.
`List<String>`	`typeToTokenList` Map a token type to its token name.

Constructor Summary

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

Method Summary

Methods
Modifier and Type	Method and Description
`LexerInterpreter`	`createLexerInterpreter(CharStream input)`
`ParserInterpreter`	`createParserInterpreter(TokenStream tokenStream)`
`protected static boolean`	`defAlias(GrammarAST r, String pattern, org.antlr.runtime.tree.TreeWizard wiz, List<Pair<GrammarAST,GrammarAST>> lexerRuleToStringLiteral)`
`void`	`defineAction(GrammarAST atAST)`
`boolean`	`defineRule(Rule r)` Define the specified rule in the grammar.
`int`	`defineStringLiteral(String lit)`
`int`	`defineStringLiteral(String lit, int ttype)`
`int`	`defineTokenAlias(String name, String lit)`
`int`	`defineTokenName(String name)`
`int`	`defineTokenName(String name, int ttype)`
`IntSet`	`getAllCharValues()` Return min to max char as defined by the target.
`List<Grammar>`	`getAllImportedGrammars()` Get list of all imports from all grammars in the delegate subtree of g.
`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".
`List<Grammar>`	`getGrammarAncestors()` Return list of imported grammars from root down to our parent.
`static String`	`getGrammarTypeToFileNameSuffix(int type)`
`LexerGrammar`	`getImplicitLexer()` Get delegates below direct delegates of g public List getIndirectDelegates(Grammar g) { List direct = getDirectDelegates(g); List delegates = getDelegates(g); delegates.removeAll(direct); return delegates; }
`Grammar`	`getImportedGrammar(String name)` Return grammar directly imported by this grammar
`List<Grammar>`	`getImportedGrammars()`
`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`	`getNewTokenType()` Return a new unique integer in the token type space
`String`	`getOptionString(String key)`
`Grammar`	`getOutermostGrammar()` Return the grammar that imported us and our parents.
`String`	`getRecognizerName()` Get the name of the generated recognizer; may or may not be same as grammar name.
`Rule`	`getRule(int index)`
`Rule`	`getRule(String name)`
`Rule`	`getRule(String grammarName, String ruleName)`
`String[]`	`getRuleNames()`
`static List<Pair<GrammarAST,GrammarAST>>`	`getStringLiteralAliasesFromLexerRules(GrammarRootAST ast)` Return list of (TOKEN_NAME node, 'literal' node) pairs
`String`	`getStringLiteralLexerRuleName(String lit)`
`Set<String>`	`getStringLiterals()`
`String`	`getTokenDisplayName(int ttype)` Given a token type, get a meaningful name for it such as the ID or string literal.
`String[]`	`getTokenDisplayNames()`
`List<String>`	`getTokenDisplayNames(IntegerList types)`
`String[]`	`getTokenNames()`
`org.antlr.runtime.TokenStream`	`getTokenStream()`
`int`	`getTokenType(String token)`
`IntSet`	`getTokenTypes()` Return a set of all possible token or char types for this grammar
`int`	`getType()`
`String`	`getTypeString()`
`void`	`importTokensFromTokensFile()`
`void`	`importVocab(Grammar importG)`
`protected void`	`initTokenSymbolTables()`
`boolean`	`isCombined()`
`boolean`	`isLexer()`
`boolean`	`isParser()`
`static boolean`	`isTokenName(String id)` Is id a valid token name? Does id start with an uppercase letter?
`static Grammar`	`load(String fileName)` convenience method for Tool.loadGrammar()
`void`	`loadImportedGrammars()`
`boolean`	`resolvesToAttributeDict(String x, ActionAST node)`
`boolean`	`resolvesToLabel(String x, ActionAST node)`
`boolean`	`resolvesToListLabel(String x, ActionAST node)`
`boolean`	`resolvesToToken(String x, ActionAST node)`
`Attribute`	`resolveToAttribute(String x, ActionAST node)`
`Attribute`	`resolveToAttribute(String x, String y, ActionAST node)`
`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, 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 String GRAMMAR_FROM_STRING_NAME
```
    See Also:
    Constant Field Values
  - parserOptions
```
public static final Set<String> parserOptions
```
  - lexerOptions
```
public static final Set<String> lexerOptions
```
  - ruleOptions
```
public static final Set<String> ruleOptions
```
  - ParserBlockOptions
```
public static final Set<String> ParserBlockOptions
```
  - LexerBlockOptions
```
public static final Set<String> LexerBlockOptions
```
  - ruleRefOptions
```
public static final Set<String> ruleRefOptions
```
    Legal options for rule refs like id
  - tokenOptions
```
public static final Set<String> tokenOptions
```
    Legal options for terminal refs like ID
  - actionOptions
```
public static final Set<String> actionOptions
```
  - semPredOptions
```
public static final Set<String> semPredOptions
```
  - doNotCopyOptionsToLexer
```
public static final Set<String> doNotCopyOptionsToLexer
```
  - grammarAndLabelRefTypeToScope
```
public static final Map<String,AttributeDict> grammarAndLabelRefTypeToScope
```
  - name
```
public String name
```
  - ast
```
public GrammarRootAST ast
```
  - tokenStream
```
@NotNull
public final org.antlr.runtime.TokenStream tokenStream
```
    Track stream used to create this grammar
  - text
```
public String text
```
  - fileName
```
public 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 List<Grammar> importedGrammars
```
  - rules
```
public OrderedHashMap<String,Rule> rules
```
    All rules defined in this specific grammar, not imported. Also does not include lexical rules if combined.
  - indexToRule
```
public List<Rule> indexToRule
```
  - 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.
  - decisionDFAs
```
public Map<Integer,DFA> decisionDFAs
```
  - decisionLOOK
```
public List<IntervalSet[]> decisionLOOK
```
  - tool
```
@NotNull
public final Tool tool
```
  - tokenNameToTypeMap
```
public Map<String,Integer> tokenNameToTypeMap
```
    Map token like ID (but not literals like "while") to its token type
  - stringLiteralToTypeMap
```
public Map<String,Integer> stringLiteralToTypeMap
```
    Map token literals like "while" to its token type. It may be that WHILE="while"=35, in which case both tokenIDToTypeMap and this field will have entries both mapped to 35.
  - typeToStringLiteralList
```
public List<String> typeToStringLiteralList
```
    Reverse index for stringLiteralToTypeMap. Indexed with raw token type. 0 is invalid.
  - typeToTokenList
```
public List<String> typeToTokenList
```
    Map a token type to its token name. Indexed with raw token type. 0 is invalid.
  - namedActions
```
public Map<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 LinkedHashMap<ActionAST,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 LinkedHashMap<PredAST,Integer> sempreds
```
    All sempreds found in grammar; maps tree node to sempred index; sempred index is 0..n-1
  - AUTO_GENERATED_TOKEN_NAME_PREFIX
```
public static final String AUTO_GENERATED_TOKEN_NAME_PREFIX
```
    See Also:
    Constant Field Values
- Constructor Detail
  - Grammar
```
public Grammar(Tool tool,
       @NotNull
       GrammarRootAST ast)
```
  - Grammar
```
public Grammar(String grammarText)
        throws org.antlr.runtime.RecognitionException
```
    For testing
    
    Throws:
    
    org.antlr.runtime.RecognitionException
  - Grammar
```
public Grammar(String grammarText,
       LexerGrammar tokenVocabSource)
        throws org.antlr.runtime.RecognitionException
```
    Throws:
    
    org.antlr.runtime.RecognitionException
  - Grammar
```
public Grammar(String grammarText,
       ANTLRToolListener listener)
        throws org.antlr.runtime.RecognitionException
```
    For testing
    
    Throws:
    
    org.antlr.runtime.RecognitionException
  - Grammar
```
public Grammar(String fileName,
       String grammarText)
        throws org.antlr.runtime.RecognitionException
```
    For testing; builds trees, does sem anal
    
    Throws:
    
    org.antlr.runtime.RecognitionException
  - Grammar
```
public Grammar(String fileName,
       String grammarText,
       @Nullable
       ANTLRToolListener listener)
        throws org.antlr.runtime.RecognitionException
```
    For testing; builds trees, does sem anal
    
    Throws:
    
    org.antlr.runtime.RecognitionException
  - Grammar
```
public Grammar(String fileName,
       String grammarText,
       Grammar tokenVocabSource,
       @Nullable
       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(@NotNull
                 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(@NotNull
                   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(String name)
```
  - getRule
```
public Rule getRule(int index)
```
  - getRule
```
public Rule getRule(String grammarName,
           String ruleName)
```
  - getAllImportedGrammars
```
public 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 List<Grammar> getImportedGrammars()
```
  - getImplicitLexer
```
public LexerGrammar getImplicitLexer()
```
    Get delegates below direct delegates of g public List getIndirectDelegates(Grammar g) { List direct = getDirectDelegates(g); List delegates = getDelegates(g); delegates.removeAll(direct); return delegates; }
  - load
```
public static Grammar load(String fileName)
```
    convenience method for Tool.loadGrammar()
  - getGrammarAncestors
```
public 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 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 String getStringLiteralLexerRuleName(String lit)
```
  - getImportedGrammar
```
public Grammar getImportedGrammar(String name)
```
    Return grammar directly imported by this grammar
  - getTokenType
```
public int getTokenType(String token)
```
  - getTokenDisplayName
```
public 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.
  - getRuleNames
```
public String[] getRuleNames()
```
  - getTokenDisplayNames
```
public List<String> getTokenDisplayNames(IntegerList types)
```
  - getTokenNames
```
public String[] getTokenNames()
```
  - getTokenDisplayNames
```
public String[] getTokenDisplayNames()
```
  - 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
  - importTokensFromTokensFile
```
public void importTokensFromTokensFile()
```
  - importVocab
```
public void importVocab(Grammar importG)
```
  - defineTokenName
```
public int defineTokenName(String name)
```
  - defineTokenName
```
public int defineTokenName(String name,
                  int ttype)
```
  - defineStringLiteral
```
public int defineStringLiteral(String lit)
```
  - defineStringLiteral
```
public int defineStringLiteral(String lit,
                      int ttype)
```
  - defineTokenAlias
```
public int defineTokenAlias(String name,
                   String lit)
```
  - setTokenForType
```
public void setTokenForType(int ttype,
                   String text)
```
  - resolveToAttribute
```
public Attribute resolveToAttribute(String x,
                           ActionAST node)
```
    Specified by:
    
    resolveToAttribute in interface AttributeResolver
  - resolveToAttribute
```
public Attribute resolveToAttribute(String x,
                           String y,
                           ActionAST node)
```
    Specified by:
    
    resolveToAttribute in interface AttributeResolver
  - resolvesToLabel
```
public boolean resolvesToLabel(String x,
                      ActionAST node)
```
    Specified by:
    
    resolvesToLabel in interface AttributeResolver
  - resolvesToListLabel
```
public boolean resolvesToListLabel(String x,
                          ActionAST node)
```
    Specified by:
    
    resolvesToListLabel in interface AttributeResolver
  - resolvesToToken
```
public boolean resolvesToToken(String x,
                      ActionAST node)
```
    Specified by:
    
    resolvesToToken in interface AttributeResolver
  - resolvesToAttributeDict
```
public boolean resolvesToAttributeDict(String x,
                              ActionAST node)
```
    Specified by:
    
    resolvesToAttributeDict in interface AttributeResolver
  - getDefaultActionScope
```
public 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(String id)
```
    Is id a valid token name? Does id start with an uppercase letter?
  - getTypeString
```
public String getTypeString()
```
  - getGrammarTypeToFileNameSuffix
```
public static String getGrammarTypeToFileNameSuffix(int type)
```
  - getOptionString
```
public String getOptionString(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 List<Pair<GrammarAST,GrammarAST>> getStringLiteralAliasesFromLexerRules(GrammarRootAST ast)
```
    Return list of (TOKEN_NAME node, 'literal' node) pairs
  - defAlias
```
protected static boolean defAlias(GrammarAST r,
               String pattern,
               org.antlr.runtime.tree.TreeWizard wiz,
               List<Pair<GrammarAST,GrammarAST>> lexerRuleToStringLiteral)
```
  - getStringLiterals
```
public Set<String> getStringLiterals()
```
  - setLookaheadDFA
```
public void setLookaheadDFA(int decision,
                   DFA lookaheadDFA)
```
  - createLexerInterpreter
```
public LexerInterpreter createLexerInterpreter(CharStream input)
```
  - 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

parserOptions

lexerOptions

ruleOptions

ParserBlockOptions

LexerBlockOptions

ruleRefOptions

tokenOptions

actionOptions

semPredOptions

doNotCopyOptionsToLexer

grammarAndLabelRefTypeToScope

name

ast

tokenStream

text

fileName

implicitLexer

originalGrammar

parent

importedGrammars

rules

indexToRule

atn

decisionDFAs

decisionLOOK

tool

tokenNameToTypeMap

stringLiteralToTypeMap

typeToStringLiteralList

typeToTokenList

namedActions

lexerActions

sempreds

AUTO_GENERATED_TOKEN_NAME_PREFIX

Constructor Detail

Grammar

Grammar

Grammar

Grammar

Grammar

Grammar

Grammar

Method Detail

initTokenSymbolTables

loadImportedGrammars

defineAction

defineRule

undefineRule

getRule

getRule

getRule

getAllImportedGrammars

getImportedGrammars

getImplicitLexer

load

getGrammarAncestors

getOutermostGrammar

getRecognizerName

getStringLiteralLexerRuleName

getImportedGrammar

getTokenType

getTokenDisplayName

getRuleNames

getTokenDisplayNames

getTokenNames

getTokenDisplayNames

getMaxCharValue

getTokenTypes

getAllCharValues

getMaxTokenType

getNewTokenType

importTokensFromTokensFile

importVocab