Question

我正在构建一种新的简单编程语言（只是为了学习空闲时间的编译器工作方式）。

我已经构建了一个词法分析器，可以将我的源代码标记为词素。

但是，我现在停留在如何从标记形成抽象语法树的角度，源代码中可能包含一个表达式（具有运算符优先级）。

为简单起见，除方括号（）外，我将仅包括4个基本运算符：+，-，/和*。运算符优先级将遵循BODMAS规则。

我意识到我也许可以将表达式从中缀转换为前缀/后缀，形成树并将其替换。

但是，我不确定是否可行。即使有可能，我也不确定实施效率如何或实施起来有多困难。

是否有一些简单的方法可以就地形成树而不必先转换为前缀/后缀？

我遇到了Shunting Yard算法，它似乎可以做到这一点。但是，我发现它是一个相当复杂的算法。有没有更简单的方法，还是应该继续实施Shunting Yard算法？

目前，以下程序已由我的词法分析器标记为：

为了演示语法，我正在演示使用Java程序。

源程序：

public class Hello
{
    public static void main(String[] args)
    {
        int a = 5;
        int b = 6;
        int c = 7;

        int r = a + b * c;

        System.out.println(r);
    }
}

Lexer输出：

public
class
Hello
{
public
static
void
main
(
String
[
]
args
)
{
int
a
=
5
;
int
b
=
6
;
int
c
=
7
;
int
r
=
a
+
b
*
c
;
System
.
out
.
println
(
r
)
;
}
}

Answer 1

    // I know this might look ugly that I use a global variable ret to return parsed subtrees
    // but please bear with it, I got used to this for various performance/usability reasons
    
    var ret, tokens
    
    function get_precedence(op) {
    	// this is an essential part, cannot parse an expression without the precedence checker
    	if (op == '*' || op == '/' || op == '%') return 14
    	if (op == '+' || op == '-') return 13
    	if (op == '<=' || op == '>=' || op == '<' || op == '>') return 11
    	if (op == '==' || op == '!=') return 10
    	if (op == '^') return 8
    	if (op == '&&') return 6
    	if (op == '||') return 5
    	return 0
    }
    
    function parse_primary(pos) {
    	// in the real language primary is almost everything that can be on the sides of +
    	// but here we only handle numbers detected with the JavaScript 'typeof' keyword
    	if (typeof tokens[pos] == 'number') {
    		ret = {
    			type: 'number',
    			value: tokens[pos],
    		}
    		return pos + 1
    	}
    	else {
    		return undefined
    	}
    }
    
    function parse_operator(pos) {
    	// let's just reuse the function we already wrote insted of creating another huge 'if'
    	if (get_precedence(tokens[pos]) != 0) {
    		ret = {
    			type: 'operator',
    			operator: tokens[pos],
    		}
    		return pos + 1
    	}
    	else {
    		return undefined
    	}
    }
    
    function parse_expr(pos) {
    	var stack = [], code = [], n, op, next, precedence
    	
    	pos = parse_primary(pos)
    	if (pos == undefined) {
    		// error, an expression can only start with a primary
    		return undefined
    	}
    	stack.push(ret)
    
    	while (true) {
    		n = pos
    		pos = parse_operator(pos)
    		if (pos == undefined) break
    		op = ret
    		pos = parse_primary(pos)
    		if (pos == undefined) break
    		next = ret
    		precedence = get_precedence(op.operator)
    		while (stack.length > 0 && get_precedence(stack[stack.length - 1].operator) >= precedence) {
    			code.push(stack.pop())
    		}
    		stack.push(op)
    		code.push(next)
    	} 
    
    	while(stack.length > 0) {
    		code.push(stack.pop())
    	}
    	if (code.length == 1) ret = code[0]
    	else ret = {
    		type: 'expr',
    		stack: code,
    	}
    	return n
    }
    
    function main() {
    	tokens = [1, '+', 2, '*', 3]
    	var pos = parse_expr(0)
    	if (pos) {
    		console.log('parsed expression AST')
    		console.log(ret)
    	}
    	else {
    		console.log('unable to parse anything')
    	}
    }
    
    main()

这是调车场表达式解析的基本实现。这是用JavaScript编写的。这是尽可能简单和简单的方法。为简便起见，省略了标记化，您为解析提供了标记数组（您称它们为词素）。

实际的调车场是parse_expr功能。这是使用堆栈的“经典”实现，这是我的偏爱，有些人更喜欢函数递归。

解析各种语法元素的函数通常称为“ parselets”。在这里，我们有三个，一个用于表达式，其他用于primary和operator。如果parselet在位置pos处检测到相应的语法构造，它将返回构造之后的下一个位置，并且AST形式的构造本身通过全局变量ret返回。如果parselet找不到期望的结果，则返回undefined。

现在添加对parens分组(的支持非常简单，只需将parse_primary扩展为if (parse_group())... else if (parse_number())...等，与此同时，您的parse_primary将会变得非常强大，可以支持各种事物，前缀运算符，函数调用等。

包含表达式的源代码的抽象语法树

1 个答案: