面向对象编程语言的 AST（抽象语法树）是什么样的？
我正在阅读有关 AST（抽象语法树）的内容，但我看到的所有示例都使用以下表达式：
a + b * c
可以用类似 lispy 的语法表示为：
(+ a (* b c) )
这相当于：
+
/ \
a *
/ \
b c
我的问题是如何为类中的 AST OOPL 会是什么样子？
我天真的尝试是针对这个 Java 代码：
class Person {
String name;
int age;
public String toString() {
return "name";
}
}
是：
;Hand written
(classDeclaration Person
(varDeclaration String name)
(varDeclaration int age )
(funcDeclaration String toString
(return "name")
)
)
但我不太确定我与真正的 AST 表示有多近或多远。
这取决于我选择的语言。需要多少细节？是否需要这些“xyzDeclaraction”或者可以是：
(Person (String name) (int age))
我在哪里可以看到实际编程语言的“真实”表示以了解更多信息。
I'm reading about AST (abstract syntax trees) but all the samples I see use expressions such as:
a + b * c
Which could be represented in a lispy like syntax as:
(+ a (* b c) )
Which will be the equivalent to:
+
/ \
a *
/ \
b c
My question is How an AST for a class in a OOPL would look like?
My naive attempt is for this Java code:
class Person {
String name;
int age;
public String toString() {
return "name";
}
}
Is:
;Hand written
(classDeclaration Person
(varDeclaration String name)
(varDeclaration int age )
(funcDeclaration String toString
(return "name")
)
)
But I'm not quite sure how close or far am I to a real AST representation.
Does it depends on the language I choose. How much detail is needed? Are those "xyzDeclaraction" needed or could be as:
(Person (String name) (int age))
Where can I see a "real" representation of an actual programming language to learn more.
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（3）
AST 是 CST 的抽象（具体语法树，或解析树）。具体语法树是由用于解析文件的产生式（在语法中）产生的树。所以你的 AST 基本上是从你的语法定义中派生出来的，但是已经进行了转换
总而言之，我认为你帖子中的例子看起来不错。我可能会将变量声明包装在
varDeclList中，将函数声明包装在methDeclList中，并将 return 语句包装在stmtList中。 （见下文。）Apple 在他的《Java 中的现代编译器实现》一书中描述了 AST 的一种或多或少“真实”的表示。 （可以在此处找到资源。）
使用这些类，您的程序将表示如下：
AST is an abstraction of the CST (concrete syntax tree, or, parse tree). The concrete syntax tree is the tree resulting from the productions (in the grammar) used to parse the file. So your AST is basically derived from your grammar definition, but has for transformed
All in all I think the example in your post looks fine. I would probably wrap the variable declarations in a
varDeclListand the function declaration in amethDeclList, and the return statement in astmtList. (See below.)One more or less "real" representation of an AST is described by Apple in his book "Modern Compiler Implementation in Java". (Resources can be found here.)
Using those classes, your program would be represented as follows:
OP：我在哪里可以看到实际编程语言的真实表示以了解更多信息？
对于作为文件 Person.java 的源文本：
下面是 S 表达式中的具体语法树和抽象语法树-来自我们的 DMS 软件重新工程工具包的解析器树的风格转储，使用它的Java1.6解析器。所有表面上的复杂性几乎都是由该语言（例如，Java 本身）的实际复杂性引起的。
CST 显然比 AST（54 个节点）包含更多的内容（139 个节点）。给定 AST，AST 会丢弃所有可以从语法中自动推断出的内容。这包括删除不带值的叶子、一元产生式以及将由左或右递归语法规则引起的脊椎压缩到显式列表节点中。
左括号表示一个新的子树。左括号后面是节点类型的名称； @Java~Java1_.6 可能看起来没有必要，直到您了解 DMS 可以同时处理多种语言（包括相互嵌套的语言）。 #nnnnnn 是节点的内存地址。 ^M 表示“此节点有 M 个父节点，当 M==1 时被关闭。[...] 内的内容是节点值。A { M } 表示此列表节点有 M 个列表子节点。每个节点都标记为 这是具体语法
树（请参阅下面的 AST）：
这是 AST（由 DMS 从 CST 自动生成）：
2015 年 3 月编辑：这里是一些 C++ AST 示例的链接
2015 年 5 月编辑：DMS 也早已完成了 Java 1.7 和 1.8。
OP: Where can I see a real representation of an actual programming language to learn more?
For your source text as a file Person.java:
what follows are both Concrete and Abstract Syntax Tree in an S-expression-style dump of the parser tree from our DMS Software Reengineering Toolkit, using its Java1.6 parser. All the apparant complexity is pretty much caused by the real complexity of the language (e.g., of Java itself).
The CST clearly contains more stuff (139 nodes) than the AST (54 nodes). The AST drops everything that can be automatically inferred from the grammar, given the AST. This includes removing non-value-carrying leaves, unary productions, and compressing spines caused by left or right recursive grammar rules into explicit list nodes.
A left paren signals a new subtree. Following the left paren is the name of the node type; @Java~Java1_.6 might seem unnecessary until you understand DMS can handle many languages at once, including langauges nested inside one another. The #nnnnnn is the memory address of the node. ^M means "this node has M parents and is left off when M==1. Things inside [...] are the node value. A { M } means this list node has M list-children. Each node is stamped with position information.
This is the Concrete Syntax tree (see further down for AST):
This is the AST (automatically generated by DMS from the CST):
EDIT March 2015: Here's a link to some C++ AST examples
Edit May 2015: DMS has long done Java 1.7 and 1.8, too.
查看 Eclipse JDT AST执行。
作为第一个介绍，您可以阅读此 教程，也是。
Take a look at the Eclipse JDT AST implementation.
As first introduction you could read this tutorial, too.