如何使用ANTLR4创建AST？

时间：2015-04-30 14:58:40

标签： java compiler-construction antlr abstract-syntax-tree antlr4

我一直在寻找很多关于这一点，我找不到任何有用的东西，真的帮助我建立一个AST。我已经知道ANTLR4不像以前的ANTLR3那样构建AST。每个人都说：“嘿，使用访客！”，但是我找不到任何关于如何做的例子或更详细的解释......

我的语法必须像C一样，但每个命令都用葡萄牙语（portuga编程语言）编写。我可以使用ANTLR4轻松生成解析树。我的问题是：我现在需要做些什么才能创建AST？

BTW，我正在使用Java和IntelliJ ......

EDIT1：我能得到的最接近的是使用了这个主题的答案：Is there a simple example of using antlr4 to create an AST from java source code and extract methods, variables and comments? 但它只打印访问过的方法的名称..

由于第一次尝试对我不起作用，我尝试使用ANTLR3中的this tutorial，但我无法弄清楚如何使用StringTamplate而不是ST ......

阅读书籍The Definitive ANTLR 4 Reference我也找不到与AST有关的任何内容。

EDIT2：现在我有一个类来创建DOT文件，我只需要弄清楚如何正确使用访问者

3 个答案:

答案 0 :(得分：128)

好的，让我们构建一个简单的数学示例。构建AST对于这样的任务来说完全是过度的，但它是展示原理的好方法。

我将在C＃中完成，但Java版本非常相似。

语法

首先，让我们编写一个非常基本的数学语法来处理：

grammar Math;

compileUnit
    :   expr EOF
    ;

expr
    :   '(' expr ')'                         # parensExpr
    |   op=('+'|'-') expr                    # unaryExpr
    |   left=expr op=('*'|'/') right=expr    # infixExpr
    |   left=expr op=('+'|'-') right=expr    # infixExpr
    |   func=ID '(' expr ')'                 # funcExpr
    |   value=NUM                            # numberExpr
    ;

OP_ADD: '+';
OP_SUB: '-';
OP_MUL: '*';
OP_DIV: '/';

NUM :   [0-9]+ ('.' [0-9]+)? ([eE] [+-]? [0-9]+)?;
ID  :   [a-zA-Z]+;
WS  :   [ \t\r\n] -> channel(HIDDEN);

非常基本的东西，我们有一个expr规则来处理所有事情（优先规则等）。

AST节点

然后，让我们定义一些我们将使用的AST节点。这些都是完全自定义的，您可以按照自己的方式定义它们。

以下是我们将在此示例中使用的节点：

internal abstract class ExpressionNode
{
}

internal abstract class InfixExpressionNode : ExpressionNode
{
    public ExpressionNode Left { get; set; }
    public ExpressionNode Right { get; set; }
}

internal class AdditionNode : InfixExpressionNode
{
}

internal class SubtractionNode : InfixExpressionNode
{
}

internal class MultiplicationNode : InfixExpressionNode
{
}

internal class DivisionNode : InfixExpressionNode
{
}

internal class NegateNode : ExpressionNode
{
    public ExpressionNode InnerNode { get; set; }
}

internal class FunctionNode : ExpressionNode
{
    public Func<double, double> Function { get; set; }
    public ExpressionNode Argument { get; set; }
}

internal class NumberNode : ExpressionNode
{
    public double Value { get; set; }
}

将CST转换为AST

ANTLR为我们生成了CST节点（MathParser.*Context类）。我们现在必须将它们转换为AST节点。

这很容易通过访问者完成，ANTLR为我们提供了MathBaseVisitor<T>类，所以让我们使用它。

internal class BuildAstVisitor : MathBaseVisitor<ExpressionNode>
{
    public override ExpressionNode VisitCompileUnit(MathParser.CompileUnitContext context)
    {
        return Visit(context.expr());
    }

    public override ExpressionNode VisitNumberExpr(MathParser.NumberExprContext context)
    {
        return new NumberNode
        {
            Value = double.Parse(context.value.Text, NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent)
        };
    }

    public override ExpressionNode VisitParensExpr(MathParser.ParensExprContext context)
    {
        return Visit(context.expr());
    }

    public override ExpressionNode VisitInfixExpr(MathParser.InfixExprContext context)
    {
        InfixExpressionNode node;

        switch (context.op.Type)
        {
            case MathLexer.OP_ADD:
                node = new AdditionNode();
                break;

            case MathLexer.OP_SUB:
                node = new SubtractionNode();
                break;

            case MathLexer.OP_MUL:
                node = new MultiplicationNode();
                break;

            case MathLexer.OP_DIV:
                node = new DivisionNode();
                break;

            default:
                throw new NotSupportedException();
        }

        node.Left = Visit(context.left);
        node.Right = Visit(context.right);

        return node;
    }

    public override ExpressionNode VisitUnaryExpr(MathParser.UnaryExprContext context)
    {
        switch (context.op.Type)
        {
            case MathLexer.OP_ADD:
                return Visit(context.expr());

            case MathLexer.OP_SUB:
                return new NegateNode
                {
                    InnerNode = Visit(context.expr())
                };

            default:
                throw new NotSupportedException();
        }
    }

    public override ExpressionNode VisitFuncExpr(MathParser.FuncExprContext context)
    {
        var functionName = context.func.Text;

        var func = typeof(Math)
            .GetMethods(BindingFlags.Public | BindingFlags.Static)
            .Where(m => m.ReturnType == typeof(double))
            .Where(m => m.GetParameters().Select(p => p.ParameterType).SequenceEqual(new[] { typeof(double) }))
            .FirstOrDefault(m => m.Name.Equals(functionName, StringComparison.OrdinalIgnoreCase));

        if (func == null)
            throw new NotSupportedException(string.Format("Function {0} is not supported", functionName));

        return new FunctionNode
        {
            Function = (Func<double, double>)func.CreateDelegate(typeof(Func<double, double>)),
            Argument = Visit(context.expr())
        };
    }
}

如您所见，只需使用访问者从CST节点创建AST节点即可。代码应该是非常不言自明的（好吧，可能除了VisitFuncExpr之外的事情，但它只是将委托连接到System.Math类的合适方法的快速方法。

在这里你有AST构建的东西。这就是所需要的。只需从CST中提取相关信息并将其保存在AST中。

AST访客

现在，让我们与AST一起玩吧。我们必须构建一个AST访问者基类来遍历它。让我们做一些类似于ANTLR提供的AbstractParseTreeVisitor<T>。

internal abstract class AstVisitor<T>
{
    public abstract T Visit(AdditionNode node);
    public abstract T Visit(SubtractionNode node);
    public abstract T Visit(MultiplicationNode node);
    public abstract T Visit(DivisionNode node);
    public abstract T Visit(NegateNode node);
    public abstract T Visit(FunctionNode node);
    public abstract T Visit(NumberNode node);

    public T Visit(ExpressionNode node)
    {
        return Visit((dynamic)node);
    }
}

在这里，我利用C＃的dynamic关键字在一行代码中执行双重调度。在Java中，您必须自己使用一系列if语句进行连接：

if (node is AdditionNode) {
    return Visit((AdditionNode)node);
} else if (node is SubtractionNode) {
    return Visit((SubtractionNode)node);
} else if ...

但我只是去寻找这个例子的快捷方式。

使用AST

那么，我们可以用数学表达式树做什么呢？当然要评估它！让我们实现一个表达式求值器：

internal class EvaluateExpressionVisitor : AstVisitor<double>
{
    public override double Visit(AdditionNode node)
    {
        return Visit(node.Left) + Visit(node.Right);
    }

    public override double Visit(SubtractionNode node)
    {
        return Visit(node.Left) - Visit(node.Right);
    }

    public override double Visit(MultiplicationNode node)
    {
        return Visit(node.Left) * Visit(node.Right);
    }

    public override double Visit(DivisionNode node)
    {
        return Visit(node.Left) / Visit(node.Right);
    }

    public override double Visit(NegateNode node)
    {
        return -Visit(node.InnerNode);
    }

    public override double Visit(FunctionNode node)
    {
        return node.Function(Visit(node.Argument));
    }

    public override double Visit(NumberNode node)
    {
        return node.Value;
    }
}

一旦我们有了AST就很简单，不是吗？

全部放在一起

最后但并非最不重要的是，我们必须实际编写主程序：

internal class Program
{
    private static void Main()
    {
        while (true)
        {
            Console.Write("> ");
            var exprText = Console.ReadLine();

            if (string.IsNullOrWhiteSpace(exprText))
                break;

            var inputStream = new AntlrInputStream(new StringReader(exprText));
            var lexer = new MathLexer(inputStream);
            var tokenStream = new CommonTokenStream(lexer);
            var parser = new MathParser(tokenStream);

            try
            {
                var cst = parser.compileUnit();
                var ast = new BuildAstVisitor().VisitCompileUnit(cst);
                var value = new EvaluateExpressionVisitor().Visit(ast);

                Console.WriteLine("= {0}", value);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            Console.WriteLine();
        }
    }
}

现在我们终于可以玩了它：

enter image description here

答案 1 :(得分：4)

我创建了一个小型Java项目，允许您通过编译内存中ANTLR生成的词法分析器和解析器来立即测试您的ANTLR语法。您可以通过将字符串传递给解析器来解析字符串，它将自动生成一个AST，然后可以在您的应用程序中使用它。

为了减小AST的大小，您可以使用NodeFilter，您可以在构建AST时添加您希望考虑的非终端的生产规则名称。

可以在以下位置找到代码和一些代码示例 https://github.com/julianthome/inmemantlr

希望该工具有用; - ）

答案 2 :(得分：1)

我找到了两种简单的方法，重点介绍 antlr4 的 TestRig.java 文件中可用的功能。

  1. 通过终端

这是我用对应的CPP14.g4语法文件解析C++的例子 java -cp .:antlr-4.9-complete.jar org.antlr.v4.gui.TestRig CPP14 translationunit -tree filename.cpp。如果省略 filename.cpp，则装备将从 stdin 读取。 “translationunit”是我使用的CPP14.g4语法文件的起始规则名称。

  1. 通过Java

我使用了 TestRig.java 文件中的部分代码。让我们再次假设我们有一个 C++ 源代码字符串，我们要从中生成 AST（您也可以直接从文件中读取）。

String source_code = "...your cpp source code...";

CodePointCharStream stream_from_string = CharStreams.fromString(source_code);
CPP14Lexer lexer = new CPP14Lexer(new ANTLRInputStream(source_code));
CommonTokenStream tokens = new CommonTokenStream(lexer);
CPP14Parser parser = new CPP14Parser(tokens);

String parserName = "CPP14Parser";
ClassLoader cl = Thread.currentThread().getContextClassLoader();
Class<? extends Parser> parserClass = null;
parserClass = cl.loadClass(parserName).asSubclass(Parser.class);

String startRuleName = "translationunit"; //as specified in my CPP14.g4 file
Method startRule = parserClass.getMethod(startRuleName);
ParserRuleContext tree = (ParserRuleContext)startRule.invoke(parser, (Object[])null);
System.out.println(tree.toStringTree(parser));

我的导入是：

import java.lang.reflect.Method;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.CharStreams;
import org.antlr.v4.runtime.CodePointCharStream;
import org.antlr.v4.runtime.ANTLRInputStream;
import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.Parser;

所有这些都要求您使用命令 java -jar yournaltrfile.jar yourgrammar.g4 生成必要的文件（词法分析器、解析器等），然后编译所有 *.java 文件。

相关问题
最新问题