org.antlr.v4.codegen.model.RuleFunction Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of antlr4 Show documentation
Show all versions of antlr4 Show documentation
The ANTLR 4 grammar compiler.
/*
* Copyright (c) 2012 The ANTLR Project. All rights reserved.
* Use of this file is governed by the BSD-3-Clause license that
* can be found in the LICENSE.txt file in the project root.
*/
package org.antlr.v4.codegen.model;
import org.antlr.runtime.RecognitionException;
import org.antlr.runtime.tree.CommonTree;
import org.antlr.runtime.tree.CommonTreeNodeStream;
import org.antlr.v4.codegen.OutputModelController;
import org.antlr.v4.codegen.OutputModelFactory;
import org.antlr.v4.codegen.model.decl.AltLabelStructDecl;
import org.antlr.v4.codegen.model.decl.AttributeDecl;
import org.antlr.v4.codegen.model.decl.ContextRuleGetterDecl;
import org.antlr.v4.codegen.model.decl.ContextRuleListGetterDecl;
import org.antlr.v4.codegen.model.decl.ContextRuleListIndexedGetterDecl;
import org.antlr.v4.codegen.model.decl.ContextTokenGetterDecl;
import org.antlr.v4.codegen.model.decl.ContextTokenListGetterDecl;
import org.antlr.v4.codegen.model.decl.ContextTokenListIndexedGetterDecl;
import org.antlr.v4.codegen.model.decl.Decl;
import org.antlr.v4.codegen.model.decl.StructDecl;
import org.antlr.v4.misc.FrequencySet;
import org.antlr.v4.misc.Utils;
import org.antlr.v4.parse.GrammarASTAdaptor;
import org.antlr.v4.runtime.atn.ATNSimulator;
import org.antlr.v4.runtime.atn.ATNState;
import org.antlr.v4.runtime.misc.IntervalSet;
import org.antlr.v4.runtime.misc.OrderedHashSet;
import org.antlr.v4.runtime.misc.Tuple;
import org.antlr.v4.runtime.misc.Tuple2;
import org.antlr.v4.tool.Attribute;
import org.antlr.v4.tool.ErrorType;
import org.antlr.v4.tool.Grammar;
import org.antlr.v4.tool.Rule;
import org.antlr.v4.tool.ast.ActionAST;
import org.antlr.v4.tool.ast.AltAST;
import org.antlr.v4.tool.ast.GrammarAST;
import org.antlr.v4.tool.ast.PredAST;
import org.antlr.v4.tool.ast.RuleAST;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import static org.antlr.v4.parse.ANTLRParser.RULE_REF;
import static org.antlr.v4.parse.ANTLRParser.STRING_LITERAL;
import static org.antlr.v4.parse.ANTLRParser.TOKEN_REF;
/** */
public class RuleFunction extends OutputModelObject {
public String name;
public List modifiers;
public String ctxType;
public Collection ruleLabels;
public Collection tokenLabels;
public ATNState startState;
public int index;
public Rule rule;
public boolean hasLookaheadBlock;
public String variantOf;
@ModelElement public List code;
@ModelElement public OrderedHashSet locals; // TODO: move into ctx?
@ModelElement public Collection args = null;
@ModelElement public StructDecl ruleCtx;
@ModelElement public Map altLabelCtxs;
@ModelElement public Map namedActions;
@ModelElement public Action finallyAction;
@ModelElement public List exceptions;
@ModelElement public List postamble;
public RuleFunction(OutputModelFactory factory, Rule r) {
super(factory);
this.name = r.name;
this.rule = r;
if ( r.modifiers!=null && !r.modifiers.isEmpty() ) {
this.modifiers = new ArrayList();
for (GrammarAST t : r.modifiers) modifiers.add(t.getText());
}
modifiers = Utils.nodesToStrings(r.modifiers);
index = r.index;
int lfIndex = name.indexOf(ATNSimulator.RULE_VARIANT_DELIMITER);
if (lfIndex >= 0) {
variantOf = name.substring(0, lfIndex);
}
if (r.name.equals(r.getBaseContext())) {
ruleCtx = new StructDecl(factory, r);
addContextGetters(factory, r.g.contextASTs.get(r.name));
if ( r.args!=null ) {
Collection decls = r.args.attributes.values();
if ( decls.size()>0 ) {
args = new ArrayList();
ruleCtx.addDecls(decls);
for (Attribute a : decls) {
args.add(new AttributeDecl(factory, a));
}
ruleCtx.ctorAttrs = args;
}
}
if ( r.retvals!=null ) {
ruleCtx.addDecls(r.retvals.attributes.values());
}
if ( r.locals!=null ) {
ruleCtx.addDecls(r.locals.attributes.values());
}
}
else {
if (r.args != null || r.retvals != null || r.locals != null) {
throw new UnsupportedOperationException("customized fields are not yet supported for customized context objects");
}
}
ruleLabels = r.getElementLabelNames();
tokenLabels = r.getTokenRefs();
if ( r.exceptions!=null ) {
exceptions = new ArrayList();
for (GrammarAST e : r.exceptions) {
ActionAST catchArg = (ActionAST)e.getChild(0);
ActionAST catchAction = (ActionAST)e.getChild(1);
exceptions.add(new ExceptionClause(factory, catchArg, catchAction));
}
}
startState = factory.getGrammar().atn.ruleToStartState[r.index];
}
public StructDecl getEffectiveRuleContext(OutputModelController controller) {
if (ruleCtx != null) {
return ruleCtx;
}
RuleFunction effectiveRuleFunction = controller.rule(controller.getGrammar().getRule(rule.getBaseContext()));
if (effectiveRuleFunction == this) {
throw new IllegalStateException("Rule function does not have an effective context");
}
assert effectiveRuleFunction.ruleCtx != null;
return effectiveRuleFunction.ruleCtx;
}
public Map getEffectiveAltLabelContexts(OutputModelController controller) {
if (altLabelCtxs != null) {
return altLabelCtxs;
}
RuleFunction effectiveRuleFunction = controller.rule(controller.getGrammar().getRule(rule.getBaseContext()));
if (effectiveRuleFunction == this) {
throw new IllegalStateException("Rule function does not have an effective context");
}
assert effectiveRuleFunction.altLabelCtxs != null;
return effectiveRuleFunction.altLabelCtxs;
}
public void addContextGetters(OutputModelFactory factory, Collection contextASTs) {
List unlabeledAlternatives = new ArrayList();
Map> labeledAlternatives = new LinkedHashMap>();
for (RuleAST ast : contextASTs) {
try {
unlabeledAlternatives.addAll(rule.g.getUnlabeledAlternatives(ast));
for (Map.Entry>> entry : rule.g.getLabeledAlternatives(ast).entrySet()) {
List list = labeledAlternatives.get(entry.getKey());
if (list == null) {
list = new ArrayList();
labeledAlternatives.put(entry.getKey(), list);
}
for (Tuple2 tuple : entry.getValue()) {
list.add(tuple.getItem2());
}
}
}
catch (RecognitionException ex) {
}
}
// Add ctx labels for elements in alts with no '#' label
if (!unlabeledAlternatives.isEmpty()) {
Set decls = getDeclsForAllElements(unlabeledAlternatives);
// put directly in base context
for (Decl decl : decls) {
ruleCtx.addDecl(decl);
}
}
// make structs for '#' labeled alts, define ctx labels for elements
altLabelCtxs = new LinkedHashMap();
if (!labeledAlternatives.isEmpty()) {
for (Map.Entry> entry : labeledAlternatives.entrySet()) {
AltLabelStructDecl labelDecl = new AltLabelStructDecl(factory, rule, entry.getKey());
altLabelCtxs.put(entry.getKey(), labelDecl);
Set decls = getDeclsForAllElements(entry.getValue());
for (Decl decl : decls) {
labelDecl.addDecl(decl);
}
}
}
}
public void fillNamedActions(OutputModelFactory factory, Rule r) {
if ( r.finallyAction!=null ) {
finallyAction = new Action(factory, r.finallyAction);
}
namedActions = new HashMap();
for (String name : r.namedActions.keySet()) {
ActionAST ast = r.namedActions.get(name);
namedActions.put(name, new Action(factory, ast));
}
}
/** for all alts, find which ref X or r needs List
Must see across alts. If any alt needs X or r as list, then
define as list.
*/
public Set getDeclsForAllElements(List altASTs) {
Set needsList = new HashSet();
Set nonOptional = new HashSet();
Set suppress = new HashSet();
List allRefs = new ArrayList();
boolean firstAlt = true;
IntervalSet reftypes = new IntervalSet(RULE_REF, TOKEN_REF, STRING_LITERAL);
for (AltAST ast : altASTs) {
List refs = getRuleTokens(ast.getNodesWithType(reftypes));
allRefs.addAll(refs);
Tuple2, FrequencySet> minAndAltFreq = getElementFrequenciesForAlt(ast);
FrequencySet minFreq = minAndAltFreq.getItem1();
FrequencySet altFreq = minAndAltFreq.getItem2();
for (GrammarAST t : refs) {
String refLabelName = getLabelName(rule.g, t);
if (refLabelName != null) {
if (altFreq.count(refLabelName)==0) {
suppress.add(refLabelName);
}
if (altFreq.count(refLabelName) > 1) {
needsList.add(refLabelName);
}
if (firstAlt && minFreq.count(refLabelName) != 0) {
nonOptional.add(refLabelName);
}
}
}
for (String ref : nonOptional.toArray(new String[nonOptional.size()])) {
if (minFreq.count(ref) == 0) {
nonOptional.remove(ref);
}
}
firstAlt = false;
}
Set decls = new LinkedHashSet();
for (GrammarAST t : allRefs) {
String refLabelName = getLabelName(rule.g, t);
if (refLabelName == null || suppress.contains(refLabelName)) {
continue;
}
List d = getDeclForAltElement(t,
refLabelName,
needsList.contains(refLabelName),
!nonOptional.contains(refLabelName));
decls.addAll(d);
}
return decls;
}
private List getRuleTokens(List refs) {
List result = new ArrayList(refs.size());
for (GrammarAST ref : refs) {
CommonTree r = ref;
boolean ignore = false;
while (r != null) {
// Ignore string literals in predicates
if (r instanceof PredAST) {
ignore = true;
break;
}
r = r.parent;
}
if (!ignore) {
result.add(ref);
}
}
return result;
}
public static String getLabelName(Grammar g, GrammarAST t) {
String tokenText = t.getText();
String tokenName = t.getType() != STRING_LITERAL ? tokenText : g.getTokenName(tokenText);
if (tokenName == null || tokenName.startsWith("T__")) {
// Do not include tokens with auto generated names
return null;
}
String labelName = tokenName;
Rule referencedRule = g.rules.get(labelName);
if (referencedRule != null) {
labelName = referencedRule.getBaseContext();
}
return labelName;
}
/** Given list of X and r refs in alt, compute how many of each there are */
protected Tuple2, FrequencySet> getElementFrequenciesForAlt(AltAST ast) {
try {
ElementFrequenciesVisitor visitor = new ElementFrequenciesVisitor(rule.g, new CommonTreeNodeStream(new GrammarASTAdaptor(), ast));
visitor.outerAlternative();
if (visitor.frequencies.size() != 1) {
factory.getGrammar().tool.errMgr.toolError(ErrorType.INTERNAL_ERROR);
return Tuple.create(new FrequencySet(), new FrequencySet());
}
return Tuple.create(visitor.getMinFrequencies(), visitor.frequencies.peek());
}
catch (RecognitionException ex) {
factory.getGrammar().tool.errMgr.toolError(ErrorType.INTERNAL_ERROR, ex);
return Tuple.create(new FrequencySet(), new FrequencySet());
}
}
public List getDeclForAltElement(GrammarAST t, String refLabelName, boolean needList, boolean optional) {
int lfIndex = refLabelName.indexOf(ATNSimulator.RULE_VARIANT_DELIMITER);
if (lfIndex >= 0) {
refLabelName = refLabelName.substring(0, lfIndex);
}
List decls = new ArrayList();
if ( t.getType()==RULE_REF ) {
Rule rref = factory.getGrammar().getRule(t.getText());
String ctxName = factory.getTarget()
.getRuleFunctionContextStructName(rref);
if ( needList) {
if(factory.getTarget().supportsOverloadedMethods())
decls.add( new ContextRuleListGetterDecl(factory, refLabelName, ctxName) );
decls.add( new ContextRuleListIndexedGetterDecl(factory, refLabelName, ctxName) );
}
else {
decls.add( new ContextRuleGetterDecl(factory, refLabelName, ctxName, optional) );
}
}
else {
if ( needList ) {
if(factory.getTarget().supportsOverloadedMethods())
decls.add( new ContextTokenListGetterDecl(factory, refLabelName) );
decls.add( new ContextTokenListIndexedGetterDecl(factory, refLabelName) );
}
else {
decls.add( new ContextTokenGetterDecl(factory, refLabelName, optional) );
}
}
return decls;
}
/** Add local var decl */
public void addLocalDecl(Decl d) {
if ( locals ==null ) locals = new OrderedHashSet();
locals.add(d);
d.isLocal = true;
}
/** Add decl to struct ctx for rule or alt if labeled */
public void addContextDecl(String altLabel, Decl d) {
CodeBlockForOuterMostAlt alt = d.getOuterMostAltCodeBlock();
// if we found code blk and might be alt label, try to add to that label ctx
if ( alt!=null ) {
// System.out.println(d.name+" lives in alt "+alt.alt.altNum);
AltLabelStructDecl altCtx = getEffectiveAltLabelContexts(factory.getController()).get(altLabel);
if ( altCtx!=null ) { // we have an alt ctx
// System.out.println("ctx is "+ altCtx.name);
altCtx.addDecl(d);
return;
}
}
getEffectiveRuleContext(factory.getController()).addDecl(d); // stick in overall rule's ctx
}
}