org.antlr.v4.tool

Class Grammar

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

public 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,
       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)