编译原理——表达式计算

写在前面

最近需要实现自定义报表的功能，其中有一个需求是要计算用户输入的公式。比如用户输入公式：

A1 + A2 * 2

A1

A2

A1 * (A2 - 3)

SUM

MIN

MAX

AVG

COUNT

B1 * SUM(A1, A2 + 1.2)。

通过一周对编译原理的学习，最终完成了任务。今记录于此，希望能给同样遇到该问题的人一些帮助。

从整体上看，整个过程分两步：词法分析和语法分析。词法分析将表达式的字符流转换为词法单元流；语法分析依赖词法分析分析出的单元流，来构造表达式对象。

词法分析

我们第一步要做的事情是对整个表达式进行词法分析。

所谓词法分析，简单地讲，就是要把表达式解析成一个一个的词法单元——Token。而所谓的Token，就是表达式中一个“有意义”的最短的子串。比如对于表达式

A1 * (SUM(A2, A3, 2) + 2.5)

A1

A

A1*

A1

A

A1 *

{ A1, *, (, SUM, (, A2, A3, 2, ), +, 2.5 }

public class Token {
private TokenType type;
private Object value;

// getter and setter
}

而

TokenType

public enum TokenType {
VARIABLE, NUMBER, FUNCTION, OPERATOR, DELIMITER, END
}

其中，

VARIABLE

NUMBER

FUNCTION

OPERATOR

DELIMITER

,

(

)

END

下面分析如何将表达式字符串解析为一个一个的Token。大致的工作流程是从字符流中逐一读取字符，当发现当前字符不再能与之前读取的字符连在一起构成一个“有意义”的字符串时，便将之前读到的字符串作为一个Token；不断进行上述操作，知道读到字符流的末尾为止；当读到末尾时，我们再加一个

END

以上操作关键之处在于如何判断当前字符不再能和之前读到的字符构成一个“有意义”的字符串。其实分析一下各个Token类型不难发现：

OPERATOR

DELIMITER

END

NUMBER

VARIABLE

FUNCTION

我们可以画出状态转换图来更加形象地展示处理过程：

在上图中，状态0是起始状态，当读到一个字母时，转移到状态1；若接下来一直读到的是字母或数字，则一直停留在状态1，直到读到一个非字母或数字则转移到状态2；状态2是两个同心圆，这表示它是一个终止态，到这里这一轮的识别就结束了，这一轮可识别出一个

VARIABLE

FUNCTION

Number

OPERATOR

DELIMITER

下面给出以上过程的完整的

Java

import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.util.Arrays;
import java.util.HashSet;
import java.util.NoSuchElementException;
import java.util.Set;

/**
* 公式词法分析器
* <p>
* DFA: <img alt="DFA text" src ="http://ojapxw8c8.bkt.clouddn.com/production.png" />
*
* @author derker
* @date 2018-10-04 14:51
*/
public class Lexer {

private static final Set<Character> OPERATOR = new HashSet<>(Arrays.asList('+', '-', '*', '/'));
private static final Set<Character> DELIMITER = new HashSet<>(Arrays.asList('(', ')', ','));
private static final Set<Character> BLACK = new HashSet<>(Arrays.asList(' ', '\r', '\n', '\f'));

public TokenStream scan(Reader reader) {
return new TokenStream(reader);
}

public class TokenStream {

private final Reader reader;

private boolean isReachedEnd;
private Character peek;
private int row = 1;
private int col = 0;

public TokenStream(Reader reader) {
this.reader = reader;
}

public Token next() {
// 流中已没有字符
if (isReachedEnd) {
throw new NoSuchElementException();
}

if (peek == null) {
read();
}

if (peek == Character.MIN_VALUE) {
isReachedEnd = true;
return new Token(TokenType.END, '$');
}

// 舍弃空白符
if (BLACK.contains(peek)) {
if (peek == '\n') {
row++;
col = 0;
}
peek = null;
return next();
}

Token token = null;

// 当前字符是数字
if (Character.isDigit(peek)) {
token = readNumber();
}

// 当前字符是字母
else if (Character.isLetter(peek)) {
token = readWord();
}

// 当前字符是操作符
else if (OPERATOR.contains(peek)) {
token = new Token(TokenType.OPERATOR, peek);
peek = null;
}

// 当前字符是边界符
else if (DELIMITER.contains(peek)) {
token = new Token(TokenType.DELIMITER, peek);
peek = null;
}

if (token == null) {
throw new LexerException(row, col, "" + peek);
}
return token;
}

/**
* 匹配一个数字
*/
private Token readNumber() {
int intValue = Character.digit(peek, 10);
for (read(); Character.isDigit(peek); read()) {
intValue = intValue * 10 + Character.digit(peek, 10);
}

if (peek != '.') {
return new Token(TokenType.NUMBER, intValue);
}

// 扫描到小数点
double floatValue = intValue;
float rate = 10;
for (read(); Character.isDigit(peek); read()) {
floatValue = floatValue + Character.digit(peek, 10) / rate;
rate *= 10;
}
return new Token(TokenType.NUMBER, floatValue);
}

/**
* 匹配单词
*/
private Token readWord() {
StringBuilder builder = new StringBuilder(peek + "");
for (read(); Character.isLetterOrDigit(peek) || peek == '_'; read()) {
// 若出现下划线 或 中间现过数字
builder.append(peek);
}
String word = builder.toString();
// 优先匹配函数
FunctionType functionType = FunctionType.valueOfName(word);
if (functionType != null) {
return new Token(TokenType.FUNCTION, functionType);
}
// 匹配单元格名字
return new Token(TokenType.VARIABLE, word);
}

/**
* 从流中读取一个字符到peek
*/
private void read() {
Integer readResult;
try {
readResult = reader.read();
} catch (IOException e) {
throw new LexerException(e);
}
col++;
peek = readResult == -1 ? Character.MIN_VALUE : (char) readResult.intValue();
}
}

/**
* 测试
*/
public static void main(String[] args) {
Lexer lexer = new Lexer();
TokenStream tokenStream = lexer.scan(new StringReader("a + 1"));
for (Token token = tokenStream.next(); token.getType() != TokenType.END; token = tokenStream.next()) {
System.out.println(token);
}
}
}

语法分析

做完了词法分析的工作，接下来就要做语法分析了。

在词法分析阶段，我们将整个表达式“划分”成了一个一个的“有意义”的字符串，但我们没有去做表达式是否合法的检查。也就是说，对于给定的一个表达式，比如

A1 + + B1

<VARIABLE, A1>

<OPERATOR, +>

<OPERATOR, +>

<VARIABLE, B1>

先来分析一下之前的那个例子

A1 * (SUM(A2, A3, 2) + 2.5)

SUM(A2, A3, 2)

A1

从上图中可以发现：带圆圈的节点都是操作符或函数，而它们的子节点都是变量或数字；以每一个带圆圈的节点为根节点的子树也是一个表达式；若我们能够构造出这棵树，便能很轻松的计算出整个表达式了。下面着手构建这棵树。

在此以前，先介绍一种用来描述每棵子树构成规则的表达方式——产生式。举个例子，对于一个只包含加减乘除的四则运算式，例如：

A1 + 2 * A2

A1 + 2

unit   ->   factor+unit
| factor-unit
| factor*unit
| factor/unit
| factor
factor -> VARIABLE | NUMBER

简单解释一下产生式的含义，

"->"

|

+

VARIABLE

以上两个产生式所代表的意思是：

factor

VARIABLE

NUMBER

unit

factor

unit

factor

根据以上介绍，下面给出我们需要求值的表达式的产生式：

E  ->  E+T | E-T | T
T  ->  T*U | T/U | U
U  ->  -F | F
F  ->  (E) | FUNCTION(L) | VARIABLE  | NUMBER
L  ->  EL' | ε
L' ->  ,EL' | ε

各个单元的含义如下：

E: expression, 表达式
T: term, 表达式项
U: unary, 一元式
F: factor, 表达式项的因子
L: expression list，表达式列表
ε：空

有了产生式，我们就可以根据它来指导写代码了。但目前它们是不可用的，因为它们当中有些是左递归的，而我们待会会使用一种叫做自顶向下递归的预测分析技术来做语法分析，运用该技术前必须先消除产生式中的左递归（下面会明白这是为什么）。于是，在消除左递归后，可得到如下产生式：

E  ->  TE'
E' ->  +TE' | -TE' | ε
T  ->  UT'
T' -> *UT' | /UT' | ε
U  ->  -F | F
F  -> (E) | function(L) | variable  | number
L  -> EL' | ε
L' -> ,EL' | ε

下面正式开始做语法分析。分析的过程其实很简单，为每个非终结符写一个分析过程即可。

在此之前我们先来定义一些数据结构来表示这些非终结符。我们可以将每一个非终结符都看成一个表达式，为此抽象出一个表达式的对象：

public abstract class Expr {
/**
* 操作符
*/
protected final Token op;

protected Expr(Token op) {
this.op = op;
}

/**
* 计算表达式的值
*/
public final Object evaluate(Map<String, Object> values) {
return this.evaluate(values::get);
}

// op getter ...
}

以上表达式对象有一个

evaluate

op

1 + 2

A1 * 4

Arith

Expr

op

+

-

*

/

public class Arith extends Expr {

private Expr leftExpr;
private Expr rightExpr;

public Arith(Token op, Expr leftExpr, Expr rightExpr) {
super(op);
this.leftExpr = leftExpr;
this.rightExpr = rightExpr;
}

@Override
public Object evaluate(VariableValueCalculator calculator) {
Object left = leftExpr.evaluate(calculator);
Object right = rightExpr.evaluate(calculator);

left = attemptCast2Number(left);
right = attemptCast2Number(right);

char operator = (char) op.getValue();
switch (operator) {
case '+':
return plus(left, right);
case '-':
return minus(left, right);
case '*':
return multiply(left, right);
case '/':
return divide(left, right);
}
return null;
}

/**
* 加法
*/
protected Object plus(Object left, Object right) {
// 若是列表，取第一个
if (left instanceof List && !((List) left).isEmpty()) {
left = ((List) left).get(0);
}
if (right instanceof List && !((List) right).isEmpty()) {
right = ((List) right).get(0);
}
// 有一个是字符串
if (isString(left) || isString(right)) {
return stringValue(left) + stringValue(right);
}
// 都是数字
if (isNumber(left) && isNumber(right)) {
if (isDouble(left) || isDouble(right)) {
return doubleValue(left) + doubleValue(right);
}
return longValue(left) + longValue(right);
}
return null;
}

// setter and getter ...
}

正如

Arith

leftExpr

rightExpr

evaluate

op

同

Arith

Unary

5

op

null

-VARIABLE

op

Func

Num

Var

有了以上定义后，下面给出语法分析器Parser的代码。先看整体逻辑：

public class Parser {

/**
* 词法分析器
*/
private final Lexer lexer;

private String source;
private TokenStream tokenStream;
private Token look;

public Parser(Lexer lexer) {
this.lexer = lexer;
}

public Expr parse(Reader reader) throws LexerException, IOException, ParserException {
tokenStream = lexer.scan(reader);
move();
return e();
}

/**
* 移动游标到下一个token
*/
private void move() throws LexerException, IOException {
look = tokenStream.next();
}

private void match(char c) throws LexerException, IOException, ParserException {
if ((char) look.getValue() == c) {
move();
} else {
throw exception();
}
}

private ParserException exception() {
return new ParserException(source, tokenStream.getRow(), "syntax exception");
}
}

Parser依赖Lexer，每次会从Lexer分析得到的Token流中获取一个Token（

move

E  ->  TE'

e

evaluate

下面问题的关键是各产生式的推导过程怎么写。由于篇幅原因，举其中几个产生式推导方法的例子。

'

1

比如对于产生式

E  =>  TE'

private Expr e() {
Expr expr = t();
if (look.getType() == TokenType.OPERATOR) {
while (((char) look.getValue()) == '+' || ((char) look.getValue()) == '-') {
Token op = look;
move();
expr = new Arith(op, expr, t());
}
}
return expr;
}

根据该产生式右侧的

TE'

t

T

E'

e1

e1

E  =>  TE'

E'

e1

e

e1

e

E' =>  +TE' | -TE' | ε

E'

+

-

while

E' =>  +TE'

E' =>  +TE'

E'

当完成

E' =>  +TE'

E' =>  +TE'

new Arith(op, expr, t())

new Arith(op, expr, t())

expr

t()

到此，就完成了 产生式

E  =>  TE'

写在最后

本文试图站在一个从未接触过《编译原理》的同学的角度去介绍一些皮毛知识，事实上，我自己也只是在国庆假期时简单学了一下 :-p，因此文中隐去了许多相关的专业术语，并按我自己理解的通俗意思做了替换。有些概念和算法，由于篇幅和本人水平有限的原因，未作出详尽解释，还请包涵。若想要更加深入地学习 ，还请阅读专业的书籍。

完整代码GitHub地址：过两天整理好了给出 :-p

参考

• 龙书
• 中科大编译原理和技术. 陈意云
• PYTHON实现算术表达式的词法语法语义分析（编译原理应用）