Package | Description |
---|---|
org.antlr.analysis | |
org.antlr.codegen | |
org.antlr.grammar.v3 | |
org.antlr.tool |
Modifier and Type | Field and 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 and 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 and 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 and Description |
---|
ActionLabel(GrammarAST actionAST) |
Predicate(GrammarAST predicate) |
PredicateLabel(GrammarAST predicateASTNode)
Make a semantic predicate label
|
Modifier and Type | Method and 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 and 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 and 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.grammar__return.getTree() |
GrammarAST |
ANTLRParser.grammarType_return.getTree() |
GrammarAST |
ANTLRParser.actions_return.getTree() |
GrammarAST |
ANTLRParser.action_return.getTree() |
GrammarAST |
ANTLRParser.actionScopeName_return.getTree() |
GrammarAST |
ANTLRParser.optionsSpec_return.getTree() |
GrammarAST |
ANTLRParser.option_return.getTree() |
GrammarAST |
ANTLRParser.optionValue_return.getTree() |
GrammarAST |
ANTLRParser.delegateGrammars_return.getTree() |
GrammarAST |
ANTLRParser.delegateGrammar_return.getTree() |
GrammarAST |
ANTLRParser.tokensSpec_return.getTree() |
GrammarAST |
ANTLRParser.tokenSpec_return.getTree() |
GrammarAST |
ANTLRParser.attrScopes_return.getTree() |
GrammarAST |
ANTLRParser.attrScope_return.getTree() |
GrammarAST |
ANTLRParser.rules_return.getTree() |
GrammarAST |
ANTLRParser.rule_return.getTree() |
GrammarAST |
ANTLRParser.ruleActions_return.getTree() |
GrammarAST |
ANTLRParser.ruleAction_return.getTree() |
GrammarAST |
ANTLRParser.throwsSpec_return.getTree() |
GrammarAST |
ANTLRParser.ruleScopeSpec_return.getTree() |
GrammarAST |
ANTLRParser.ruleAltList_return.getTree() |
GrammarAST |
ANTLRParser.block_return.getTree() |
GrammarAST |
ANTLRParser.alternative_return.getTree() |
GrammarAST |
ANTLRParser.exceptionGroup_return.getTree() |
GrammarAST |
ANTLRParser.exceptionHandler_return.getTree() |
GrammarAST |
ANTLRParser.finallyClause_return.getTree() |
GrammarAST |
ANTLRParser.element_return.getTree() |
GrammarAST |
ANTLRParser.elementNoOptionSpec_return.getTree() |
GrammarAST |
ANTLRParser.atom_return.getTree() |
GrammarAST |
ANTLRParser.ruleref_return.getTree() |
GrammarAST |
ANTLRParser.notSet_return.getTree() |
GrammarAST |
ANTLRParser.treeRoot_return.getTree() |
GrammarAST |
ANTLRParser.tree__return.getTree() |
GrammarAST |
ANTLRParser.ebnf_return.getTree() |
GrammarAST |
ANTLRParser.range_return.getTree() |
GrammarAST |
ANTLRParser.terminal_return.getTree() |
GrammarAST |
ANTLRParser.elementOptions_return.getTree() |
GrammarAST |
ANTLRParser.defaultNodeOption_return.getTree() |
GrammarAST |
ANTLRParser.elementOption_return.getTree() |
GrammarAST |
ANTLRParser.elementOptionId_return.getTree() |
GrammarAST |
ANTLRParser.ebnfSuffix_return.getTree() |
GrammarAST |
ANTLRParser.notTerminal_return.getTree() |
GrammarAST |
ANTLRParser.idList_return.getTree() |
GrammarAST |
ANTLRParser.id_return.getTree() |
GrammarAST |
ANTLRParser.rewrite_return.getTree() |
GrammarAST |
ANTLRParser.rewrite_with_sempred_return.getTree() |
GrammarAST |
ANTLRParser.rewrite_block_return.getTree() |
GrammarAST |
ANTLRParser.rewrite_alternative_return.getTree() |
GrammarAST |
ANTLRParser.rewrite_element_return.getTree() |
GrammarAST |
ANTLRParser.rewrite_atom_return.getTree() |
GrammarAST |
ANTLRParser.label_return.getTree() |
GrammarAST |
ANTLRParser.rewrite_ebnf_return.getTree() |
GrammarAST |
ANTLRParser.rewrite_tree_return.getTree() |
GrammarAST |
ANTLRParser.rewrite_template_return.getTree() |
GrammarAST |
ANTLRParser.rewrite_template_head_return.getTree() |
GrammarAST |
ANTLRParser.rewrite_indirect_template_head_return.getTree() |
GrammarAST |
ANTLRParser.rewrite_template_args_return.getTree() |
GrammarAST |
ANTLRParser.rewrite_template_arg_return.getTree() |
protected GrammarAST |
ANTLRParser.setToBlockWithSet(GrammarAST b) |
GrammarAST |
LeftRecursiveRuleWalker.token() |
Modifier and Type | Method and Description |
---|---|
protected void |
AssignTokenTypesWalker.alias(GrammarAST t,
GrammarAST s) |
CodeGenTreeWalker.alternative_return |
CodeGenTreeWalker.alternative(GrammarAST label) |
void |
DefineGrammarItemsWalker.atom(GrammarAST scope_) |
CodeGenTreeWalker.atom_return |
CodeGenTreeWalker.atom(GrammarAST scope,
GrammarAST label,
GrammarAST astSuffix) |
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 and Description |
---|---|
protected List<String> |
CodeGenTreeWalker.getTokenTypesAsTargetLabels(Collection<GrammarAST> refs)
Convert rewrite AST lists to target labels list
|
Constructor and Description |
---|
ActionAnalysis(Grammar grammar,
String ruleName,
GrammarAST actionAST) |
ActionTranslator(CodeGenerator generator,
String ruleName,
GrammarAST actionAST) |
Modifier and Type | Field and 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 and 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 and 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(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 and 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 and 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(GrammarAST atomAST) |
StateCluster |
NFAFactory.build_Atom(int label,
GrammarAST associatedAST)
From label A build Graph o-A->o
|
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 |
GrammarSanity.checkRuleReference(GrammarAST scopeAST,
GrammarAST refAST,
GrammarAST argsAST,
String currentRuleName) |
void |
Grammar.checkRuleReference(GrammarAST scopeAST,
GrammarAST refAST,
GrammarAST argsAST,
String currentRuleName) |
protected void |
Grammar.defineLabel(Rule r,
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(Token label,
GrammarAST elementRef,
int type) |
void |
Grammar.defineLexerRuleFoundInParser(Token ruleToken,
GrammarAST ruleAST) |
void |
AttributeScope.defineNamedAction(GrammarAST nameAST,
GrammarAST actionAST)
Given @scope::name {action} define it for this attribute scope.
|
void |
Rule.defineNamedAction(GrammarAST ampersandAST,
GrammarAST nameAST,
GrammarAST actionAST)
Given @scope::name {action} define it for this grammar.
|
void |
Grammar.defineNamedAction(GrammarAST ampersandAST,
String scope,
GrammarAST nameAST,
GrammarAST actionAST)
Given @scope::name {action} define it for this grammar.
|
void |
Grammar.defineRule(Token ruleToken,
String modifier,
Map<String,Object> options,
GrammarAST tree,
GrammarAST argActionAST,
int numAlts)
Define a new rule.
|
void |
Grammar.defineRuleListLabel(String ruleName,
Token label,
GrammarAST element) |
void |
Grammar.defineRuleRefLabel(String ruleName,
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,
Token label,
GrammarAST element) |
void |
Grammar.defineTokenRefLabel(String ruleName,
Token label,
GrammarAST tokenRef) |
void |
Grammar.defineWildcardTreeLabel(String ruleName,
Token label,
GrammarAST tokenRef) |
void |
Grammar.defineWildcardTreeListLabel(String ruleName,
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 and 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 and Description |
---|
LabelElementPair(Token label,
GrammarAST elementRef) |
Copyright © 1992–2015 ANTLR. All rights reserved.