Search in sources :

Example 1 with ActionAST

use of org.antlr.v4.tool.ast.ActionAST in project antlr4 by antlr.

the class UseDefAnalyzer method trackTokenRuleRefsInActions.

// side-effect: updates Alternative with refs in actions
public static void trackTokenRuleRefsInActions(Grammar g) {
    for (Rule r : g.rules.values()) {
        for (int i = 1; i <= r.numberOfAlts; i++) {
            Alternative alt = r.alt[i];
            for (ActionAST a : alt.actions) {
                ActionSniffer sniffer = new ActionSniffer(g, r, alt, a, a.token);
                sniffer.examineAction();
            }
        }
    }
}
Also used : Alternative(org.antlr.v4.tool.Alternative) Rule(org.antlr.v4.tool.Rule) ActionAST(org.antlr.v4.tool.ast.ActionAST)

Example 2 with ActionAST

use of org.antlr.v4.tool.ast.ActionAST in project antlr4 by antlr.

the class AttributeChecks method checkAllAttributeExpressions.

public static void checkAllAttributeExpressions(Grammar g) {
    for (ActionAST act : g.namedActions.values()) {
        AttributeChecks checker = new AttributeChecks(g, null, null, act, act.token);
        checker.examineAction();
    }
    for (Rule r : g.rules.values()) {
        for (ActionAST a : r.namedActions.values()) {
            AttributeChecks checker = new AttributeChecks(g, r, null, a, a.token);
            checker.examineAction();
        }
        for (int i = 1; i <= r.numberOfAlts; i++) {
            Alternative alt = r.alt[i];
            for (ActionAST a : alt.actions) {
                AttributeChecks checker = new AttributeChecks(g, r, alt, a, a.token);
                checker.examineAction();
            }
        }
        for (GrammarAST e : r.exceptions) {
            ActionAST a = (ActionAST) e.getChild(1);
            AttributeChecks checker = new AttributeChecks(g, r, null, a, a.token);
            checker.examineAction();
        }
        if (r.finallyAction != null) {
            AttributeChecks checker = new AttributeChecks(g, r, null, r.finallyAction, r.finallyAction.token);
            checker.examineAction();
        }
    }
}
Also used : Alternative(org.antlr.v4.tool.Alternative) GrammarAST(org.antlr.v4.tool.ast.GrammarAST) Rule(org.antlr.v4.tool.Rule) ActionAST(org.antlr.v4.tool.ast.ActionAST)

Example 3 with ActionAST

use of org.antlr.v4.tool.ast.ActionAST in project antlr4 by antlr.

the class ActionTranslator method translateAction.

public static List<ActionChunk> translateAction(OutputModelFactory factory, RuleFunction rf, Token tokenWithinAction, ActionAST node) {
    String action = tokenWithinAction.getText();
    if (action != null && action.length() > 0 && action.charAt(0) == '{') {
        int firstCurly = action.indexOf('{');
        int lastCurly = action.lastIndexOf('}');
        if (firstCurly >= 0 && lastCurly >= 0) {
            // trim {...}
            action = action.substring(firstCurly + 1, lastCurly);
        }
    }
    return translateActionChunk(factory, rf, action, node);
}
Also used : TokenPropertyRef_int(org.antlr.v4.codegen.model.chunk.TokenPropertyRef_int)

Example 4 with ActionAST

use of org.antlr.v4.tool.ast.ActionAST in project antlr4 by antlr.

the class LeftRecursiveRuleTransformer method translateLeftRecursiveRule.

/** Return true if successful */
public boolean translateLeftRecursiveRule(GrammarRootAST ast, LeftRecursiveRule r, String language) {
    //tool.log("grammar", ruleAST.toStringTree());
    GrammarAST prevRuleAST = r.ast;
    String ruleName = prevRuleAST.getChild(0).getText();
    LeftRecursiveRuleAnalyzer leftRecursiveRuleWalker = new LeftRecursiveRuleAnalyzer(prevRuleAST, tool, ruleName, language);
    boolean isLeftRec;
    try {
        //			System.out.println("TESTING ---------------\n"+
        //							   leftRecursiveRuleWalker.text(ruleAST));
        isLeftRec = leftRecursiveRuleWalker.rec_rule();
    } catch (RecognitionException re) {
        // didn't match; oh well
        isLeftRec = false;
    }
    if (!isLeftRec)
        return false;
    // replace old rule's AST; first create text of altered rule
    GrammarAST RULES = (GrammarAST) ast.getFirstChildWithType(ANTLRParser.RULES);
    String newRuleText = leftRecursiveRuleWalker.getArtificialOpPrecRule();
    //		System.out.println("created: "+newRuleText);
    // now parse within the context of the grammar that originally created
    // the AST we are transforming. This could be an imported grammar so
    // we cannot just reference this.g because the role might come from
    // the imported grammar and not the root grammar (this.g)
    RuleAST t = parseArtificialRule(prevRuleAST.g, newRuleText);
    // reuse the name token from the original AST since it refers to the proper source location in the original grammar
    ((GrammarAST) t.getChild(0)).token = ((GrammarAST) prevRuleAST.getChild(0)).getToken();
    // update grammar AST and set rule's AST.
    RULES.setChild(prevRuleAST.getChildIndex(), t);
    r.ast = t;
    // Reduce sets in newly created rule tree
    GrammarTransformPipeline transform = new GrammarTransformPipeline(g, g.tool);
    transform.reduceBlocksToSets(r.ast);
    transform.expandParameterizedLoops(r.ast);
    // Rerun semantic checks on the new rule
    RuleCollector ruleCollector = new RuleCollector(g);
    ruleCollector.visit(t, "rule");
    BasicSemanticChecks basics = new BasicSemanticChecks(g, ruleCollector);
    // disable the assoc element option checks because they are already
    // handled for the pre-transformed rule.
    basics.checkAssocElementOption = false;
    basics.visit(t, "rule");
    // track recursive alt info for codegen
    r.recPrimaryAlts = new ArrayList<LeftRecursiveRuleAltInfo>();
    r.recPrimaryAlts.addAll(leftRecursiveRuleWalker.prefixAndOtherAlts);
    if (r.recPrimaryAlts.isEmpty()) {
        tool.errMgr.grammarError(ErrorType.NO_NON_LR_ALTS, g.fileName, ((GrammarAST) r.ast.getChild(0)).getToken(), r.name);
    }
    r.recOpAlts = new OrderedHashMap<Integer, LeftRecursiveRuleAltInfo>();
    r.recOpAlts.putAll(leftRecursiveRuleWalker.binaryAlts);
    r.recOpAlts.putAll(leftRecursiveRuleWalker.ternaryAlts);
    r.recOpAlts.putAll(leftRecursiveRuleWalker.suffixAlts);
    // walk alt info records and set their altAST to point to appropriate ALT subtree
    // from freshly created AST
    setAltASTPointers(r, t);
    // update Rule to just one alt and add prec alt
    ActionAST arg = (ActionAST) r.ast.getFirstChildWithType(ANTLRParser.ARG_ACTION);
    if (arg != null) {
        r.args = ScopeParser.parseTypedArgList(arg, arg.getText(), g);
        r.args.type = AttributeDict.DictType.ARG;
        r.args.ast = arg;
        // todo: isn't this Rule or something?
        arg.resolver = r.alt[1];
    }
    // these are so $label in action translation works
    for (Pair<GrammarAST, String> pair : leftRecursiveRuleWalker.leftRecursiveRuleRefLabels) {
        GrammarAST labelNode = pair.a;
        GrammarAST labelOpNode = (GrammarAST) labelNode.getParent();
        GrammarAST elementNode = (GrammarAST) labelOpNode.getChild(1);
        LabelElementPair lp = new LabelElementPair(g, labelNode, elementNode, labelOpNode.getType());
        r.alt[1].labelDefs.map(labelNode.getText(), lp);
    }
    // copy to rule from walker
    r.leftRecursiveRuleRefLabels = leftRecursiveRuleWalker.leftRecursiveRuleRefLabels;
    tool.log("grammar", "added: " + t.toStringTree());
    return true;
}
Also used : RuleAST(org.antlr.v4.tool.ast.RuleAST) RuleCollector(org.antlr.v4.semantics.RuleCollector) GrammarAST(org.antlr.v4.tool.ast.GrammarAST) LabelElementPair(org.antlr.v4.tool.LabelElementPair) ActionAST(org.antlr.v4.tool.ast.ActionAST) GrammarTransformPipeline(org.antlr.v4.tool.GrammarTransformPipeline) BasicSemanticChecks(org.antlr.v4.semantics.BasicSemanticChecks) RecognitionException(org.antlr.runtime.RecognitionException)

Example 5 with ActionAST

use of org.antlr.v4.tool.ast.ActionAST in project antlr4 by antlr.

the class LexerATNFactory method action.

@Override
public Handle action(String action) {
    if (action.trim().isEmpty()) {
        ATNState left = newState(null);
        ATNState right = newState(null);
        epsilon(left, right);
        return new Handle(left, right);
    }
    // define action AST for this rule as if we had found in grammar
    ActionAST ast = new ActionAST(new CommonToken(ANTLRParser.ACTION, action));
    currentRule.defineActionInAlt(currentOuterAlt, ast);
    return action(ast);
}
Also used : CommonToken(org.antlr.runtime.CommonToken) ATNState(org.antlr.v4.runtime.atn.ATNState) ActionAST(org.antlr.v4.tool.ast.ActionAST)

Aggregations

ActionAST (org.antlr.v4.tool.ast.ActionAST)11 GrammarAST (org.antlr.v4.tool.ast.GrammarAST)5 Rule (org.antlr.v4.tool.Rule)3 PredAST (org.antlr.v4.tool.ast.PredAST)3 HashMap (java.util.HashMap)2 ANTLRStringStream (org.antlr.runtime.ANTLRStringStream)2 CommonToken (org.antlr.runtime.CommonToken)2 Token (org.antlr.runtime.Token)2 Action (org.antlr.v4.codegen.model.Action)2 RuleSempredFunction (org.antlr.v4.codegen.model.RuleSempredFunction)2 ActionSplitter (org.antlr.v4.parse.ActionSplitter)2 ATNState (org.antlr.v4.runtime.atn.ATNState)2 Alternative (org.antlr.v4.tool.Alternative)2 Attribute (org.antlr.v4.tool.Attribute)2 Grammar (org.antlr.v4.tool.Grammar)2 LeftRecursiveRule (org.antlr.v4.tool.LeftRecursiveRule)2 RuleAST (org.antlr.v4.tool.ast.RuleAST)2 ArrayList (java.util.ArrayList)1 LinkedHashMap (java.util.LinkedHashMap)1 CopyOnWriteArrayList (java.util.concurrent.CopyOnWriteArrayList)1