java - 将 ANTLR 解析规则映射到用于代码生成的自定义 Java AST 类

Question

我似乎在 AST->StringTemplate 方面苦苦挣扎，可能是因为我来自手工编写解析器 -> LLVM。

我正在寻找的是一种自动将解析规则与可以表示它的 AST 类匹配并包含生成目标语言输出的方法的方法。 (在这种情况下可能使用 StringTemplate。)

在伪代码中，给出这个示例语法:

numberExpression
    : DIGIT+
    ;

我想把它映射到这个 AST 类:

class NumberExpressionAST extends BaseAST {
    private double value;

    public NumberExpressionAST(node) {
        this.value = node.value;
    }

    public String generateCode() {
        // However we want to generate the output.
        // Maybe use a template, maybe string literals, maybe cure cancer...whatever.
    }
}

为了将它们结合起来，也许会有如下所示的胶水:(或者你可能会疯狂使用 Class.forName 东西)

switch (child.ruleName) {
    case 'numberExpression':
        return new NumberExpressionAST(child);
        break;
}

我一直在网上搜索，我发现语法中有 -> 解析重写规则，但我似乎无法弄清楚如何将所有这些逻辑排除在语法之外。特别是从模板设置和生成目标输出的代码。我可以多次在树上行走。

我想也许我可以使用选项 output=AST 然后提供我自己的从 CommonTree 扩展的 AST 类？我承认，我对 ANTLR 的掌握非常原始，请原谅我的无知。我遵循的每个教程都展示了按照对我的语法进行所有这些操作是完全疯狂且难以维护的。

有人能告诉我完成类似事情的方法吗？

目标:将 AST/代码生成/模板逻辑排除在语法之外。

编辑----------------------------------------

我求助于追踪 ANTLR 的实际源代码(因为它们使用自己)，我看到类似的东西，如 BlockAST、RuleAST 等，它们都继承自普通树。我还没有完全弄清楚重要的部分……他们是如何使用它们的……

环顾四周，我注意到您基本上可以输入提示标记:

identifier
    : IDENTIFIER<AnyJavaClassIWantAST>
    ;

您不能对解析规则做完全相同的事情...但是如果您创建一些标记来表示整个解析规则，您可以像这样使用重写规则:

declaration
    : type identifier -> SOME_PARSE_RULE<AnyJavaClassIWantAST>
    ;

所有这些都更接近我想要的，但理想情况下我不应该乱扔语法......有什么办法可以把它们放在其他地方吗？

Answer 1

Could you add this as an answer...

这是一个人为的例子，它使用了一些 ANTLR4 的特性，这些特性在将语法与输出语言(主要是 alternative labels)分离方面大有帮助。和生成的监听器。这个示例语法可以表示一些微不足道的代码，但它没有语言引用——甚至没有调用 skip() 来获取词法分析器中的空格。测试类使用生成的监听器将输入转换为一些 Java 输出。

我避免使用在前几次尝试中无法使用的任何东西，所以无论如何不要认为这是一个详尽无遗的例子。

Simplang.g

grammar Simplang;


compilationUnit : statements EOF;
statements      : statement+;
statement       : block #BlockStatement 
                | call  #CallStatement
                | decl  #DeclStatement
                ;
block           : LCUR statements RCUR;    
call            : methodName LPAR args=arglist? RPAR SEMI;
methodName      : ID;
arglist         : arg (COMMA arg)*;
arg             : expr;    
decl            : VAR variableName EQ expr SEMI;
variableName    : ID;
expr            : add_expr;     
    
add_expr        : lhs=primary_expr (add_op rhs=primary_expr)*;
add_op          : PLUS | MINUS;    
primary_expr    : string=STRING
                | id=ID
                | integer=INT
                ;    
    
VAR: 'var';   
ID: ('a'..'z'|'A'..'Z')+;
INT: ('0'..'9')+;
STRING: '\'' ~('\r'|'\n'|'\'')* '\'';
SEMI: ';';
LPAR: '(';
RPAR: ')';
LCUR: '{';
RCUR: '}';
PLUS: '+';
MINUS: '-';    
COMMA: ',';
EQ: '=';
WS: (' '|'\t'|'\f'|'\r'|'\n') -> skip;

连同词法分析器和解析器，ANTLR4 生成一个监听器接口(interface)和默认的空实现类。这是为上面的语法生成的接口(interface)。

SimplangListener.java

public interface SimplangListener extends ParseTreeListener {
    void enterArglist(SimplangParser.ArglistContext ctx);
    void exitArglist(SimplangParser.ArglistContext ctx);
    void enterCall(SimplangParser.CallContext ctx);
    void exitCall(SimplangParser.CallContext ctx);
    void enterCompilationUnit(SimplangParser.CompilationUnitContext ctx);
    void exitCompilationUnit(SimplangParser.CompilationUnitContext ctx);
    void enterVariableName(SimplangParser.VariableNameContext ctx);
    void exitVariableName(SimplangParser.VariableNameContext ctx);
    void enterBlock(SimplangParser.BlockContext ctx);
    void exitBlock(SimplangParser.BlockContext ctx);
    void enterExpr(SimplangParser.ExprContext ctx);
    void exitExpr(SimplangParser.ExprContext ctx);
    void enterPrimary_expr(SimplangParser.Primary_exprContext ctx);
    void exitPrimary_expr(SimplangParser.Primary_exprContext ctx);
    void enterAdd_expr(SimplangParser.Add_exprContext ctx);
    void exitAdd_expr(SimplangParser.Add_exprContext ctx);
    void enterArg(SimplangParser.ArgContext ctx);
    void exitArg(SimplangParser.ArgContext ctx);
    void enterAdd_op(SimplangParser.Add_opContext ctx);
    void exitAdd_op(SimplangParser.Add_opContext ctx);
    void enterStatements(SimplangParser.StatementsContext ctx);
    void exitStatements(SimplangParser.StatementsContext ctx);
    void enterBlockStatement(SimplangParser.BlockStatementContext ctx);
    void exitBlockStatement(SimplangParser.BlockStatementContext ctx);
    void enterCallStatement(SimplangParser.CallStatementContext ctx);
    void exitCallStatement(SimplangParser.CallStatementContext ctx);
    void enterMethodName(SimplangParser.MethodNameContext ctx);
    void exitMethodName(SimplangParser.MethodNameContext ctx);
    void enterDeclStatement(SimplangParser.DeclStatementContext ctx);
    void exitDeclStatement(SimplangParser.DeclStatementContext ctx);
    void enterDecl(SimplangParser.DeclContext ctx);
    void exitDecl(SimplangParser.DeclContext ctx);
}

这是一个测试类，它覆盖了空监听器中的一些方法并调用了解析器。

SimplangTest.java

public class SimplangTest {

    public static void main(String[] args) {

        ANTLRInputStream input = new ANTLRInputStream(
                "var x = 4;\nfoo(x, 10);\nbar(y + 10 - 1, 'x' + 'y' + 'z');");

        SimplangLexer lexer = new SimplangLexer(input);

        SimplangParser parser = new SimplangParser(new CommonTokenStream(lexer));

        parser.addParseListener(new SimplangBaseListener() {
            public void exitArg(SimplangParser.ArgContext ctx) {
                System.out.print(", ");
            }

            public void exitCall(SimplangParser.CallContext call) {
                System.out.print("})");
            }

            public void exitMethodName(SimplangParser.MethodNameContext ctx) {
                System.out.printf("call(\"%s\", new Object[]{", ctx.ID()
                        .getText());
            }

            public void exitCallStatement(SimplangParser.CallStatementContext ctx) {
                System.out.println(";");
            }

            public void enterDecl(SimplangParser.DeclContext ctx) {
                System.out.print("define(");
            }

            public void exitVariableName(SimplangParser.VariableNameContext ctx) {
                System.out.printf("\"%s\", ", ctx.ID().getText());
            }

            public void exitDeclStatement(SimplangParser.DeclStatementContext ctx) {
                System.out.println(");");
            }

            public void exitAdd_op(SimplangParser.Add_opContext ctx) {
                if (ctx.MINUS() != null) {
                    System.out.print(" - ");
                } else {
                    System.out.print(" + ");
                }
            }

            public void exitPrimary_expr(SimplangParser.Primary_exprContext ctx) {
                if (ctx.string != null) {
                    String value = ctx.string.getText();
                    System.out.printf("\"%s\"",
                            value.subSequence(1, value.length() - 1));
                } else if (ctx.altNum == 2){    //cheating and using the alt# for "INT"
                    System.out.printf("read(\"%s\")", ctx.id.getText());
                } else {
                    System.out.print(ctx.INT().getText());
                }
            }
        });

        parser.compilationUnit();
    }
}

这是在测试类中硬编码的测试输入:

var x = 4;
foo(x, 10);
bar(y + 10 - 1, 'x' + 'y' + 'z');

这是生成的输出:

define("x", 4);
call("foo", new Object[]{read("x"), 10, });
call("bar", new Object[]{read("y") + 10 - 1, "x" + "y" + "z", });

这是一个愚蠢的示例，但它展示了一些在构建自定义 AST 时可能对您有用的功能。