Package | Description |
---|---|
org.antlr.analysis | |
org.antlr.codegen | |
org.antlr.grammar.v3 | |
org.antlr.tool |
Modifier and Type | Field | Description |
---|---|---|
GrammarAST |
ActionLabel.actionAST |
|
GrammarAST |
NFAState.associatedASTNode |
Associate this NFAState with the corresponding GrammarAST node
from which this node was created.
|
GrammarAST |
SemanticContext.Predicate.predicateAST |
The AST node in tree created from the grammar holding the predicate
|
Modifier and Type | Method | Description |
---|---|---|
GrammarAST |
DFA.getDecisionASTNode() |
What GrammarAST node (derived from the grammar) is this DFA
associated with? It will point to the start of a block or
the loop back of a (...)+ block etc...
|
Modifier and Type | Method | Description |
---|---|---|
void |
NFAState.setDecisionASTNode(GrammarAST decisionASTNode) |
What AST node is associated with this NFAState? When you
set the AST node, I set the node to point back to this NFA state.
|
Constructor | Description |
---|---|
ActionLabel(GrammarAST actionAST) |
|
Predicate(GrammarAST predicate) |
|
PredicateLabel(GrammarAST predicateASTNode) |
Make a semantic predicate label
|
Modifier and Type | Method | Description |
---|---|---|
void |
CodeGenerator.generateLocalFOLLOW(GrammarAST referencedElementNode,
String referencedElementName,
String enclosingRuleName,
int elementIndex) |
Error recovery in ANTLR recognizers.
|
List<? extends Object> |
CodeGenerator.translateAction(String ruleName,
GrammarAST actionTree) |
|
List<org.stringtemplate.v4.ST> |
CodeGenerator.translateArgAction(String ruleName,
GrammarAST actionTree) |
Translate an action like [3,"foo",a[3]] and return a List of the
translated actions.
|
Modifier and Type | Field | Description |
---|---|---|
protected static GrammarAST |
AssignTokenTypesWalker.charAlias |
|
protected static GrammarAST |
AssignTokenTypesWalker.charAlias2 |
|
protected GrammarAST |
ANTLRParser.currentBlockAST |
|
protected GrammarAST |
DefineGrammarItemsWalker.currentRewriteBlock |
|
protected GrammarAST |
DefineGrammarItemsWalker.currentRewriteRule |
|
protected GrammarAST |
DefineGrammarItemsWalker.root |
|
protected static GrammarAST |
AssignTokenTypesWalker.stringAlias |
|
protected static GrammarAST |
AssignTokenTypesWalker.stringAlias2 |
Modifier and Type | Method | Description |
---|---|---|
protected GrammarAST |
ANTLRParser.createBlockFromDupAlt(GrammarAST alt) |
Create a copy of the alt and make it into a BLOCK; all actions,
labels, tree operators, rewrites are removed.
|
static GrammarAST |
ANTLRParser.createSimpleRuleAST(String name,
GrammarAST block,
boolean fragment) |
|
protected GrammarAST |
ANTLRParser.createSynSemPredFromBlock(GrammarAST synpredBlockAST,
int synpredTokenType) |
|
GrammarAST |
ANTLRParser.action_return.getTree() |
|
GrammarAST |
ANTLRParser.actions_return.getTree() |
|
GrammarAST |
ANTLRParser.actionScopeName_return.getTree() |
|
GrammarAST |
ANTLRParser.alternative_return.getTree() |
|
GrammarAST |
ANTLRParser.atom_return.getTree() |
|
GrammarAST |
ANTLRParser.attrScope_return.getTree() |
|
GrammarAST |
ANTLRParser.attrScopes_return.getTree() |
|
GrammarAST |
ANTLRParser.block_return.getTree() |
|
GrammarAST |
ANTLRParser.defaultNodeOption_return.getTree() |
|
GrammarAST |
ANTLRParser.delegateGrammar_return.getTree() |
|
GrammarAST |
ANTLRParser.delegateGrammars_return.getTree() |
|
GrammarAST |
ANTLRParser.ebnf_return.getTree() |
|
GrammarAST |
ANTLRParser.ebnfSuffix_return.getTree() |
|
GrammarAST |
ANTLRParser.element_return.getTree() |
|
GrammarAST |
ANTLRParser.elementNoOptionSpec_return.getTree() |
|
GrammarAST |
ANTLRParser.elementOption_return.getTree() |
|
GrammarAST |
ANTLRParser.elementOptionId_return.getTree() |
|
GrammarAST |
ANTLRParser.elementOptions_return.getTree() |
|
GrammarAST |
ANTLRParser.exceptionGroup_return.getTree() |
|
GrammarAST |
ANTLRParser.exceptionHandler_return.getTree() |
|
GrammarAST |
ANTLRParser.finallyClause_return.getTree() |
|
GrammarAST |
ANTLRParser.grammar__return.getTree() |
|
GrammarAST |
ANTLRParser.grammarType_return.getTree() |
|
GrammarAST |
ANTLRParser.id_return.getTree() |
|
GrammarAST |
ANTLRParser.idList_return.getTree() |
|
GrammarAST |
ANTLRParser.label_return.getTree() |
|
GrammarAST |
ANTLRParser.notSet_return.getTree() |
|
GrammarAST |
ANTLRParser.notTerminal_return.getTree() |
|
GrammarAST |
ANTLRParser.option_return.getTree() |
|
GrammarAST |
ANTLRParser.optionsSpec_return.getTree() |
|
GrammarAST |
ANTLRParser.optionValue_return.getTree() |
|
GrammarAST |
ANTLRParser.range_return.getTree() |
|
GrammarAST |
ANTLRParser.rewrite_alternative_return.getTree() |
|
GrammarAST |
ANTLRParser.rewrite_atom_return.getTree() |
|
GrammarAST |
ANTLRParser.rewrite_block_return.getTree() |
|
GrammarAST |
ANTLRParser.rewrite_ebnf_return.getTree() |
|
GrammarAST |
ANTLRParser.rewrite_element_return.getTree() |
|
GrammarAST |
ANTLRParser.rewrite_indirect_template_head_return.getTree() |
|
GrammarAST |
ANTLRParser.rewrite_return.getTree() |
|
GrammarAST |
ANTLRParser.rewrite_template_arg_return.getTree() |
|
GrammarAST |
ANTLRParser.rewrite_template_args_return.getTree() |
|
GrammarAST |
ANTLRParser.rewrite_template_head_return.getTree() |
|
GrammarAST |
ANTLRParser.rewrite_template_return.getTree() |
|
GrammarAST |
ANTLRParser.rewrite_tree_return.getTree() |
|
GrammarAST |
ANTLRParser.rewrite_with_sempred_return.getTree() |
|
GrammarAST |
ANTLRParser.rule_return.getTree() |
|
GrammarAST |
ANTLRParser.ruleAction_return.getTree() |
|
GrammarAST |
ANTLRParser.ruleActions_return.getTree() |
|
GrammarAST |
ANTLRParser.ruleAltList_return.getTree() |
|
GrammarAST |
ANTLRParser.ruleref_return.getTree() |
|
GrammarAST |
ANTLRParser.rules_return.getTree() |
|
GrammarAST |
ANTLRParser.ruleScopeSpec_return.getTree() |
|
GrammarAST |
ANTLRParser.terminal_return.getTree() |
|
GrammarAST |
ANTLRParser.throwsSpec_return.getTree() |
|
GrammarAST |
ANTLRParser.tokenSpec_return.getTree() |
|
GrammarAST |
ANTLRParser.tokensSpec_return.getTree() |
|
GrammarAST |
ANTLRParser.tree__return.getTree() |
|
GrammarAST |
ANTLRParser.treeRoot_return.getTree() |
|
protected GrammarAST |
ANTLRParser.setToBlockWithSet(GrammarAST b) |
|
GrammarAST |
LeftRecursiveRuleWalker.token() |
Modifier and Type | Method | Description |
---|---|---|
protected void |
AssignTokenTypesWalker.alias(GrammarAST t,
GrammarAST s) |
|
CodeGenTreeWalker.alternative_return |
CodeGenTreeWalker.alternative(GrammarAST label) |
|
CodeGenTreeWalker.atom_return |
CodeGenTreeWalker.atom(GrammarAST scope,
GrammarAST label,
GrammarAST astSuffix) |
|
void |
DefineGrammarItemsWalker.atom(GrammarAST scope_) |
|
void |
LeftRecursiveRuleWalker.binaryAlt(GrammarAST altTree,
GrammarAST rewriteTree,
int alt) |
|
CodeGenTreeWalker.block_return |
CodeGenTreeWalker.block(String blockTemplateName,
DFA dfa,
GrammarAST label) |
|
void |
ANTLRParser.cleanup(GrammarAST root) |
|
int |
ANTLRTreePrinter.countAltsForBlock(GrammarAST t) |
|
protected GrammarAST |
ANTLRParser.createBlockFromDupAlt(GrammarAST alt) |
Create a copy of the alt and make it into a BLOCK; all actions,
labels, tree operators, rewrites are removed.
|
static GrammarAST |
ANTLRParser.createSimpleRuleAST(String name,
GrammarAST block,
boolean fragment) |
|
protected GrammarAST |
ANTLRParser.createSynSemPredFromBlock(GrammarAST synpredBlockAST,
int synpredTokenType) |
|
ANTLRParser.defaultNodeOption_return |
ANTLRParser.defaultNodeOption(GrammarAST terminalAST) |
|
CodeGenTreeWalker.ebnf_return |
CodeGenTreeWalker.ebnf(GrammarAST label) |
|
ANTLRParser.ebnfSuffix_return |
ANTLRParser.ebnfSuffix(GrammarAST elemAST,
boolean inRewrite) |
|
CodeGenTreeWalker.element_return |
CodeGenTreeWalker.element(GrammarAST label,
GrammarAST astSuffix) |
|
ANTLRParser.elementOption_return |
ANTLRParser.elementOption(GrammarAST terminalAST) |
|
ANTLRParser.elementOptions_return |
ANTLRParser.elementOptions(GrammarAST terminalAST) |
|
protected org.stringtemplate.v4.ST |
CodeGenTreeWalker.getRuleElementST(String name,
String ruleTargetName,
GrammarAST elementAST,
GrammarAST ast_suffix,
String label) |
|
protected String |
CodeGenTreeWalker.getSTSuffix(GrammarAST elementAST,
GrammarAST ast_suffix,
String label) |
Return a non-empty template name suffix if the token is to be
tracked, added to a tree, or both.
|
protected org.stringtemplate.v4.ST |
CodeGenTreeWalker.getTokenElementST(String name,
String elementName,
GrammarAST elementAST,
GrammarAST ast_suffix,
String label) |
|
protected org.stringtemplate.v4.ST |
CodeGenTreeWalker.getWildcardST(GrammarAST elementAST,
GrammarAST ast_suffix,
String label) |
|
org.stringtemplate.v4.ST |
CodeGenTreeWalker.notElement(GrammarAST n,
GrammarAST label,
GrammarAST astSuffix) |
|
void |
LeftRecursiveRuleWalker.otherAlt(GrammarAST altTree,
GrammarAST rewriteTree,
int alt) |
|
void |
LeftRecursiveRuleWalker.prefixAlt(GrammarAST altTree,
GrammarAST rewriteTree,
int alt) |
|
protected void |
ANTLRParser.prefixWithSynPred(GrammarAST alt) |
Rewrite alt to have a synpred as first element;
(xxx)=>xxx
but only if they didn't specify one manually.
|
org.stringtemplate.v4.ST |
CodeGenTreeWalker.set(GrammarAST label,
GrammarAST astSuffix) |
|
void |
LeftRecursiveRuleWalker.setReturnValues(GrammarAST t) |
|
IntSet |
TreeToNFAConverter.setRule(GrammarAST t) |
|
protected GrammarAST |
ANTLRParser.setToBlockWithSet(GrammarAST b) |
|
void |
LeftRecursiveRuleWalker.setTokenPrec(GrammarAST t,
int alt) |
|
void |
LeftRecursiveRuleWalker.suffixAlt(GrammarAST altTree,
GrammarAST rewriteTree,
int alt) |
|
void |
LeftRecursiveRuleWalker.ternaryAlt(GrammarAST altTree,
GrammarAST rewriteTree,
int alt) |
|
int |
TreeToNFAConverter.testBlockAsSet(GrammarAST t) |
|
int |
TreeToNFAConverter.testSetRule(GrammarAST t) |
|
protected void |
DefineGrammarItemsWalker.trackInlineAction(GrammarAST actionAST) |
|
protected void |
AssignTokenTypesWalker.trackString(GrammarAST t) |
|
protected void |
AssignTokenTypesWalker.trackToken(GrammarAST t) |
|
protected void |
AssignTokenTypesWalker.trackTokenRule(GrammarAST t,
GrammarAST modifier,
GrammarAST block) |
Modifier and Type | Method | Description |
---|---|---|
protected List<String> |
CodeGenTreeWalker.getTokenTypesAsTargetLabels(Collection<GrammarAST> refs) |
Convert rewrite AST lists to target labels list
|
Constructor | Description |
---|---|
ActionAnalysis(Grammar grammar,
String ruleName,
GrammarAST actionAST) |
|
ActionTranslator(CodeGenerator generator,
String ruleName,
GrammarAST actionAST) |
Modifier and Type | Field | Description |
---|---|---|
GrammarAST |
Rule.argActionAST |
For convenience, track the argument def AST action node if any
|
GrammarAST |
Grammar.Decision.blockAST |
|
GrammarAST |
Grammar.LabelElementPair.elementRef |
|
GrammarAST |
Rule.EORNode |
|
protected GrammarAST |
Grammar.grammarTree |
An AST that records entire input grammar with all rules.
|
GrammarAST |
LeftRecursiveRuleAnalyzer.retvals |
|
GrammarAST |
Rule.tree |
The AST representing the whole rule
|
Modifier and Type | Field | Description |
---|---|---|
LinkedHashMap<String,GrammarAST> |
AttributeScope.actions |
|
Set<GrammarAST> |
Grammar.blocksWithSemPreds |
Track decisions with syn preds specified for reporting.
|
Set<GrammarAST> |
Grammar.blocksWithSynPreds |
Track decisions with syn preds specified for reporting.
|
protected List<GrammarAST> |
Rule.inlineActions |
Track all executable actions other than named actions like @init.
|
protected LinkedHashMap<String,GrammarAST> |
Grammar.nameToSynpredASTMap |
When we read in a grammar, we track the list of syntactic predicates
and build faux rules for them later.
|
Set<GrammarAST> |
GrammarAST.rewriteRefsDeep |
|
Set<GrammarAST> |
GrammarAST.rewriteRefsShallow |
If this is a BLOCK node for a rewrite rule, track referenced
elements here.
|
protected Set<GrammarAST> |
Grammar.ruleRefs |
The unique set of all rule references in any rule; set of tree node
objects so two refs to same rule can exist but at different line/position.
|
protected Set<GrammarAST> |
Grammar.scopedRuleRefs |
Modifier and Type | Method | Description |
---|---|---|
GrammarAST |
Grammar.addArtificialMatchTokensRule(GrammarAST grammarAST,
List<String> ruleNames,
List<String> delegateNames,
boolean filterMode) |
Parse a rule we add artificially that is a list of the other lexer
rules like this: "Tokens : ID | INT | SEMI ;" nextToken() will invoke
this to set the current token.
|
static GrammarAST |
GrammarAST.dup(org.antlr.runtime.tree.Tree t) |
|
static GrammarAST |
GrammarAST.dupTree(GrammarAST t) |
|
static GrammarAST |
GrammarAST.dupTreeNoActions(GrammarAST t,
GrammarAST parent) |
Duplicate a tree, assuming this is a root node of a tree--
duplicate that node and what's below; ignore siblings of root node.
|
GrammarAST |
GrammarAST.findFirstType(int ttype) |
|
protected GrammarAST |
Grammar.findFirstTypeOutsideRewrite(GrammarAST block,
BitSet types) |
|
GrammarAST |
GrammarAST.getBlockALT(int i) |
|
GrammarAST[] |
GrammarAST.getChildrenAsArray() |
|
GrammarAST |
Grammar.getDecisionBlockAST(int decision) |
|
GrammarAST |
Grammar.getGrammarTree() |
|
GrammarAST |
GrammarAST.getLastChild() |
|
GrammarAST |
GrammarAST.getLastSibling() |
|
GrammarAST |
GrammarAST.getNextSibling() |
|
GrammarAST |
Grammar.getSyntacticPredicate(String name) |
|
GrammarAST |
Grammar.parseArtificialRule(String ruleText) |
|
GrammarAST |
LeftRecursiveRuleAnalyzer.replaceLastRuleRef(GrammarAST t,
String name) |
|
GrammarAST |
LeftRecursiveRuleAnalyzer.replaceRuleRefs(GrammarAST t,
String name) |
Modifier and Type | Method | Description |
---|---|---|
List<GrammarAST> |
GrammarAST.findAllType(int ttype) |
|
protected List<? extends GrammarAST> |
Grammar.getArtificialRulesForSyntacticPredicates(LinkedHashMap<String,GrammarAST> nameToSynpredASTMap) |
for any syntactic predicates, we need to define rules for them; they will get
defined automatically like any other rule.
|
List<GrammarAST> |
Rule.getInlineActions() |
|
List<GrammarAST> |
Rule.getRuleRefsInAlt(String ref,
int outerAltNum) |
|
LinkedHashMap<String,GrammarAST> |
Grammar.getSyntacticPredicates() |
|
List<GrammarAST> |
Rule.getTokenRefsInAlt(String ref,
int outerAltNum) |
Modifier and Type | Method | Description |
---|---|---|
GrammarAST |
Grammar.addArtificialMatchTokensRule(GrammarAST grammarAST,
List<String> ruleNames,
List<String> delegateNames,
boolean filterMode) |
Parse a rule we add artificially that is a list of the other lexer
rules like this: "Tokens : ID | INT | SEMI ;" nextToken() will invoke
this to set the current token.
|
void |
Grammar.addRule(GrammarAST grammarTree,
GrammarAST t) |
|
protected void |
AssignTokenTypesBehavior.alias(GrammarAST t,
GrammarAST s) |
|
void |
GrammarSerializerFoo.alt(GrammarAST alt) |
|
void |
Grammar.altReferencesRule(String enclosingRuleName,
GrammarAST refScopeAST,
GrammarAST refAST,
int outerAltNum) |
Track a rule reference within an outermost alt of a rule.
|
void |
Grammar.altReferencesTokenID(String ruleName,
GrammarAST refAST,
int outerAltNum) |
Track a token reference within an outermost alt of a rule.
|
void |
LeftRecursiveRuleAnalyzer.binaryAlt(GrammarAST altTree,
GrammarAST rewriteTree,
int alt) |
|
static boolean |
GrammarReport.blockHasSynPred(GrammarAST blockAST) |
|
StateCluster |
NFAFactory.build_Action(GrammarAST action) |
Build what amounts to an epsilon transition with an action.
|
StateCluster |
NFAFactory.build_Atom(int label,
GrammarAST associatedAST) |
From label A build Graph o-A->o
|
StateCluster |
NFAFactory.build_Atom(GrammarAST atomAST) |
|
StateCluster |
NFAFactory.build_CharLiteralAtom(GrammarAST charLiteralAST) |
From char 'c' build StateCluster o-intValue(c)->o
|
StateCluster |
NFAFactory.build_SemanticPredicate(GrammarAST pred) |
Build what amounts to an epsilon transition with a semantic
predicate action.
|
StateCluster |
NFAFactory.build_Set(IntSet set,
GrammarAST associatedAST) |
From set build single edge graph o->o-set->o.
|
StateCluster |
NFAFactory.build_StringLiteralAtom(GrammarAST stringLiteralAST) |
For a non-lexer, just build a simple token reference atom.
|
StateCluster |
NFAFactory.build_Wildcard(GrammarAST associatedAST) |
Build an atom with all possible values in its label
|
StateCluster |
NFAFactory.build_WildcardTree(GrammarAST associatedAST) |
Build a subrule matching ^(.
|
void |
GrammarSerializerFoo.charLiteral(GrammarAST t) |
|
void |
Grammar.checkRuleReference(GrammarAST scopeAST,
GrammarAST refAST,
GrammarAST argsAST,
String currentRuleName) |
|
void |
GrammarSanity.checkRuleReference(GrammarAST scopeAST,
GrammarAST refAST,
GrammarAST argsAST,
String currentRuleName) |
|
protected void |
Grammar.defineLabel(Rule r,
org.antlr.runtime.Token label,
GrammarAST element,
int type) |
Define a label defined in a rule r; check the validity then ask the
Rule object to actually define it.
|
void |
Rule.defineLabel(org.antlr.runtime.Token label,
GrammarAST elementRef,
int type) |
|
void |
Grammar.defineLexerRuleFoundInParser(org.antlr.runtime.Token ruleToken,
GrammarAST ruleAST) |
|
void |
AttributeScope.defineNamedAction(GrammarAST nameAST,
GrammarAST actionAST) |
Given @scope::name {action} define it for this attribute scope.
|
void |
Grammar.defineNamedAction(GrammarAST ampersandAST,
String scope,
GrammarAST nameAST,
GrammarAST actionAST) |
Given @scope::name {action} define it for this grammar.
|
void |
Rule.defineNamedAction(GrammarAST ampersandAST,
GrammarAST nameAST,
GrammarAST actionAST) |
Given @scope::name {action} define it for this grammar.
|
void |
Grammar.defineRule(org.antlr.runtime.Token ruleToken,
String modifier,
Map<String,Object> options,
GrammarAST tree,
GrammarAST argActionAST,
int numAlts) |
Define a new rule.
|
void |
Grammar.defineRuleListLabel(String ruleName,
org.antlr.runtime.Token label,
GrammarAST element) |
|
void |
Grammar.defineRuleRefLabel(String ruleName,
org.antlr.runtime.Token label,
GrammarAST ruleRef) |
|
String |
Grammar.defineSyntacticPredicate(GrammarAST blockAST,
String currentRuleName) |
Define a new predicate and get back its name for use in building
a semantic predicate reference to the syn pred.
|
void |
Grammar.defineTokenListLabel(String ruleName,
org.antlr.runtime.Token label,
GrammarAST element) |
|
void |
Grammar.defineTokenRefLabel(String ruleName,
org.antlr.runtime.Token label,
GrammarAST tokenRef) |
|
void |
Grammar.defineWildcardTreeLabel(String ruleName,
org.antlr.runtime.Token label,
GrammarAST tokenRef) |
|
void |
Grammar.defineWildcardTreeListLabel(String ruleName,
org.antlr.runtime.Token label,
GrammarAST tokenRef) |
|
static GrammarAST |
GrammarAST.dupTree(GrammarAST t) |
|
static GrammarAST |
GrammarAST.dupTreeNoActions(GrammarAST t,
GrammarAST parent) |
Duplicate a tree, assuming this is a root node of a tree--
duplicate that node and what's below; ignore siblings of root node.
|
void |
GrammarSanity.ensureAltIsSimpleNodeOrTree(GrammarAST altAST,
GrammarAST elementAST,
int outerAltNum) |
Rules in tree grammar that use -> rewrites and are spitting out
templates via output=template and then use rewrite=true must only
use -> on alts that are simple nodes or trees or single rule refs
that match either nodes or trees.
|
protected GrammarAST |
Grammar.findFirstTypeOutsideRewrite(GrammarAST block,
BitSet types) |
|
Object |
Grammar.getBlockOption(GrammarAST blockAST,
String key) |
|
String |
Grammar.grammarTreeToString(GrammarAST t) |
|
String |
Grammar.grammarTreeToString(GrammarAST t,
boolean showActions) |
|
static boolean |
LeftRecursiveRuleAnalyzer.hasImmediateRecursiveRuleRefs(GrammarAST t,
String ruleName) |
|
void |
Grammar.importGrammar(GrammarAST grammarNameAST,
String label) |
Import the rules/tokens of a delegate grammar.
|
int |
Grammar.importTokenVocabulary(GrammarAST tokenVocabOptionAST,
String vocabName) |
Load a vocab file <vocabName>.tokens and return max token type found.
|
boolean |
Grammar.isEmptyRule(GrammarAST block) |
Rules like "a : ;" and "a : {...} ;" should not generate
try/catch blocks for RecognitionException.
|
protected boolean |
GrammarSanity.isNextNonActionElementEOA(GrammarAST t) |
|
boolean |
Grammar.isValidSet(TreeToNFAConverter nfabuilder,
GrammarAST t) |
Given set tree like ( SET A B ), check that A and B
are both valid sets themselves, else we must tree like a BLOCK
|
void |
LeftRecursiveRuleAnalyzer.otherAlt(GrammarAST altTree,
GrammarAST rewriteTree,
int alt) |
|
void |
LeftRecursiveRuleAnalyzer.prefixAlt(GrammarAST altTree,
GrammarAST rewriteTree,
int alt) |
|
GrammarAST |
LeftRecursiveRuleAnalyzer.replaceLastRuleRef(GrammarAST t,
String name) |
|
GrammarAST |
LeftRecursiveRuleAnalyzer.replaceRuleRefs(GrammarAST t,
String name) |
|
void |
GrammarSerializerFoo.ruleRef(GrammarAST t) |
|
void |
Grammar.setDecisionBlockAST(int decision,
GrammarAST blockAST) |
|
void |
Grammar.setGrammarTree(GrammarAST value) |
|
void |
LeftRecursiveRuleAnalyzer.setReturnValues(GrammarAST t) |
|
void |
Grammar.setRuleAST(String ruleName,
GrammarAST t) |
|
void |
LeftRecursiveRuleAnalyzer.setTokenPrec(GrammarAST t,
int alt) |
|
void |
LeftRecursiveRuleAnalyzer.stripLeftRecursion(GrammarAST altAST) |
|
void |
LeftRecursiveRuleAnalyzer.stripSynPred(GrammarAST altAST) |
|
void |
LeftRecursiveRuleAnalyzer.suffixAlt(GrammarAST altTree,
GrammarAST rewriteTree,
int alt) |
|
void |
LeftRecursiveRuleAnalyzer.ternaryAlt(GrammarAST altTree,
GrammarAST rewriteTree,
int alt) |
Convert e ? e : e → ? e : e_[nextPrec]
|
String |
LeftRecursiveRuleAnalyzer.text(GrammarAST t) |
|
void |
GrammarSerializerFoo.token(GrammarAST t) |
|
void |
Rule.trackInlineAction(GrammarAST actionAST) |
|
void |
Rule.trackRuleReferenceInAlt(GrammarAST refAST,
int outerAltNum) |
|
protected void |
AssignTokenTypesBehavior.trackString(GrammarAST t) |
Track string literals (could be in tokens{} section)
|
protected void |
AssignTokenTypesBehavior.trackToken(GrammarAST t) |
|
void |
Rule.trackTokenReferenceInAlt(GrammarAST refAST,
int outerAltNum) |
Track a token ID or literal like '+' and "void" as having been referenced
somewhere within the alts (not rewrite sections) of a rule.
|
protected void |
AssignTokenTypesBehavior.trackTokenRule(GrammarAST t,
GrammarAST modifier,
GrammarAST block) |
|
void |
Grammar.translateLeftRecursiveRule(GrammarAST ruleAST) |
|
void |
GrammarSerializerFoo.wildcard(GrammarAST t) |
Modifier and Type | Method | Description |
---|---|---|
void |
GrammarAST._findAllType(int ttype,
List<GrammarAST> nodes) |
|
protected List<? extends GrammarAST> |
Grammar.getArtificialRulesForSyntacticPredicates(LinkedHashMap<String,GrammarAST> nameToSynpredASTMap) |
for any syntactic predicates, we need to define rules for them; they will get
defined automatically like any other rule.
|
Set<String> |
Grammar.getLabels(Set<GrammarAST> rewriteElements,
int labelType) |
Given a set of all rewrite elements on right of ->, filter for
label types such as Grammar.TOKEN_LABEL, Grammar.TOKEN_LIST_LABEL, ...
|
Constructor | Description |
---|---|
LabelElementPair(org.antlr.runtime.Token label,
GrammarAST elementRef) |
Copyright © 1992–2019 ANTLR. All rights reserved.