Grammar (ANTLR 4 Tool 4.0 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`
`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 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(Tool tool, GrammarRootAST ast)`

Method Summary

Methods
Modifier and Type	Method and Description
`protected static boolean`	`defAlias(GrammarAST r, String pattern, org.antlr.runtime.tree.TreeWizard wiz, List<Pair<GrammarAST,GrammarAST>> lexerRuleToStringLiteral)`
`void`	`defineAction(GrammarAST atAST)`
`void`	`defineRule(Rule r)`
`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)`
`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)`
`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?
`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)`

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
```
- 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,
       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

Method Detail

initTokenSymbolTables

protected void initTokenSymbolTables()

loadImportedGrammars
```
public void loadImportedGrammars()
```

defineAction

public void defineAction(GrammarAST atAST)

defineRule
```
public void defineRule(Rule r)
```

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()

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.

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)

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

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

Method Detail

initTokenSymbolTables

loadImportedGrammars

defineAction

defineRule

getRule

getRule

getRule

getAllImportedGrammars

getImportedGrammars

getGrammarAncestors

getOutermostGrammar

getRecognizerName

getStringLiteralLexerRuleName

getImportedGrammar

getTokenType

getTokenDisplayName

getTokenDisplayNames

getTokenNames

getTokenDisplayNames

getMaxCharValue

getTokenTypes

getAllCharValues

getMaxTokenType

getNewTokenType

importTokensFromTokensFile

importVocab

defineTokenName

defineTokenName

defineStringLiteral

defineStringLiteral

defineTokenAlias

setTokenForType

resolveToAttribute