用antlr4來實現《按編譯原理的思路設計的一個計算器》中的計算器

上次在公司內部講《詞法分析——使用正則文法》是一次失敗的嘗試——上午有十幾個人在場，下午就只來了四個聽眾。

本來我還在構思如何來講“語法分析”的知識呢，但現在看來已不太可能。

 

這個課程沒有預想中的受歡迎，其原因可能是：

1.課程內容相對復雜，聽眾知識背景與基礎差異比較大。

2.授課技巧不夠，不能把復雜的知識簡單化的呈現給基礎稍差一點的人。

 

針對這兩個可能的原因，我要嘗試做出以下調整：

1.使用antlr來實現詞法和語法的部分。

2.暫時把“編譯”過程改為“解釋”來實現。

 

使用antlr的原因是：

1.采用文法生成器可直接略過詞法和語法的部分直接進入語義分析，這樣利於速成，同時避免學員被詞法分析和語法分析的復雜性嚇到，而失去了繼續學習的勇氣。

2.antlr的文法是LL(k)型，非常易於編寫——雖然k型方法的性能肯定不如1型文法，但與初學者談性能問題並不是一個好主意，不如直接避開性能不談，能運行即可。

3.antlr默認生成的是java代碼，這與公司內大多數員工的現有知識是相吻合的。

 

 下面進入正文。

 

一、什么是antlr？如何安裝？

這不是一篇湊字數的文章，所以請直接參考官方網站（http://www.antlr.org/）。

我使用的是目前的最新版本（V4.2.2）.

我上傳了參考資料（包括jar包、電子書和官方示例）到百度雲上，可從這個地址下載（http://pan.baidu.com/s/1hq65XWC）。

 

二、本計算器的文法示例及文法的解釋。

整個計算器的詞法的語法就由以下幾行的antlr4代碼來實現，先貼在下面：

grammar Calc;                            // 文法的名字為Calc

// 以下以小寫字母開頭的文法表示為語法元素
// 由大寫字母開頭的文法表示為詞法元素
// 詞法元素的表示類似於正則表示式
// 語法元素的表示類似於BNF

exprs : setExpr                            // set表達式
    | calcExpr                            // 或calc表達式
    ;

setExpr : 'set' agmts ;                    // 以set命令開頭，后面是多個賦值語句
agmts   : agmt (';' agmts)? ';'? ;        // 多個賦值語句是由一個賦值語句后根着多個賦值語句，中間由分號分隔，結尾有一個可選的分號
agmt    : id=ID '=' num=NUMBER ;        // 一個賦值語句是由一個ID，后跟着一個等號，再后面跟送一個數字組成
calcExpr: 'calc' expr ;                    // 以calc命令開頭，后面是一個計算表達式

// expr可能由多個產生式
// 在前面的產生式優先於在后面的產生式
// 這樣來解決優先級的問題

expr: expr op=(MUL | DIV) expr            // 乘法或除法
    | expr op=(ADD | SUB) expr            // 加法或減法
    | factor                            // 一個計算因子——可做為+-*/的操作數據的東西
    ;

factor: (sign=(ADD | SUB))? num=NUMBER    // 計算因子可以是一個正數或負數
    | '(' expr ')'                        // 計算因子可以是括號括起來的表示式
    | id=ID                                // 計算因子可以是一個變量
    | funCall                            // 計算因子可以是一個函數調用
    ;

funCall: name=ID '(' params ')' ;        // 函數名后面加參數列表
params : expr (',' params)? ;            // 參數列表是由一個表達式后面跟關一個可選的參數列表組成

WS : [ \t\n\r]+ -> skip ;                // 空白， 后面的->skip表示antlr4在分析語言的文本時，符合這個規則的詞法將被無視
ID : [a-z]+ ;                            // 標識符，由0到多個小寫字母組成
NUMBER : [0-9]+('.'([0-9]+)?)? ;        // 數字
ADD : '+' ;
SUB : '-' ;
MUL : '*' ;
DIV : '/' ;

 

 

我們把這段文法保存到一個文件Calc.g4中，並運行命令“antlr4 -visitor Calc.g4”即生成6個java文件和兩個tokens文件。

這幾個文件包括了這個計算器的“詞法分析程序”、“語法分析程序”和一個visitor（CalcBaseVisitor.java），不過此時這個visitor內部實現都是空的，我們需要自己實現它。

在實現這個visitor之前，我們先實現一個上下文，上下文的做用有兩個：

1.保存變量——用於在計算表達式中引用變量。

2.保存堆棧——用於函數的參數傳遞。

這個上下文的內容很少，代碼也很短，直接貼在下面：

public class Context {
    private static Context ourInstance = new Context();

    public static Context getInstance() {
        return ourInstance;
    }

    private Context() {
    }

    private Map<String, Double> map = new HashMap<>();
    private Deque<Double> stack = new ArrayDeque<>();

    public Double getValue(String key) {
        Double d = map.get(key);
        return d == null ? Double.NaN : d;
    }

    public void setContext(String key, Double value) {
        map.put(key, value);
    }

    public void setContext(String key, String value) {
        setContext(key, Double.valueOf(value));
    }

    public void pushStack(Double d) {
        stack.push(d);
    }

    public Double popStack() {
        return stack.pop();
    }
}

 

下面我們開始實現這個計算器的visitor，

public class MyCalcVisitor extends CalcBaseVisitor<Double> {

    @Override
    public Double visitExprs(CalcParser.ExprsContext ctx) {
        return visit(ctx.getChild(0));
    }

    @Override
    public Double visitAgmt(CalcParser.AgmtContext ctx) {
        Context.getInstance().setContext(ctx.id.getText(), ctx.num.getText());
        return null;
    }

    @Override
    public Double visitAgmts(CalcParser.AgmtsContext ctx) {
        visit(ctx.agmt());
        if (ctx.agmts() != null)
            visit(ctx.agmts());
        return null;
    }

    @Override
    public Double visitCalcExpr(CalcParser.CalcExprContext ctx) {
        return visit(ctx.expr());
    }

    @Override
    public Double visitExpr(CalcParser.ExprContext ctx) {
        int cc = ctx.getChildCount();
        if (cc == 3) {
            switch (ctx.op.getType()) {
            case CalcParser.ADD:
                return visit(ctx.expr(0)) + visit(ctx.expr(1));
            case CalcParser.SUB:
                return visit(ctx.expr(0)) - visit(ctx.expr(1));
            case CalcParser.MUL:
                return visit(ctx.expr(0)) * visit(ctx.expr(1));
            case CalcParser.DIV:
                return visit(ctx.expr(0)) / visit(ctx.expr(1));
            }
        } else if (cc == 1) {
            return visit(ctx.getChild(0));
        }
        throw new RuntimeException();
    }

    @Override
    public Double visitFactor(CalcParser.FactorContext ctx) {
        int cc = ctx.getChildCount();
        if (cc == 3) {
            return visit(ctx.getChild(1));
        } else if (cc == 2) {
            if (ctx.sign.getType() == CalcParser.ADD)
                return Double.valueOf(ctx.getChild(1).getText());
            if (ctx.sign.getType() == CalcParser.SUB)
                return -1 * Double.valueOf(ctx.getChild(1).getText());
        } else if (cc == 1) {
            if (ctx.num != null)
                return Double.valueOf(ctx.getChild(0).getText());
            if (ctx.id != null)
                return Context.getInstance().getValue(ctx.id.getText());
            return visit(ctx.funCall());
        }
        throw new RuntimeException();
    }

    @Override
    public Double visitParams(CalcParser.ParamsContext ctx) {
        if (ctx.params() != null)
            visit(ctx.params());
        Context.getInstance().pushStack(visit(ctx.expr()));
        return null;
    }

    @Override
    public Double visitFunCall(CalcParser.FunCallContext ctx) {
        visit(ctx.params());
        String funName = ctx.name.getText();
        switch (funName) {
        case "pow":
            return Math.pow(Context.getInstance().popStack(), Context.getInstance().popStack());
        case "sqrt":
            return Math.sqrt(Context.getInstance().popStack());
        }
        throw new RuntimeException();
    }

    @Override
    public Double visitSetExpr(CalcParser.SetExprContext ctx) {
        return visit(ctx.agmts());
    }

}

 最后再實現一個入口，調用這個Visitor即完成了我們的計算器。

入口代碼如下：

import java.util.Scanner;

import org.antlr.v4.runtime.ANTLRInputStream;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.tree.ParseTree;

public class Portal {

    private static final String lineStart = "CALC> ";

    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(System.in)) {
            System.out.print(lineStart);
            while (scanner.hasNext()) {
                String line = scanner.nextLine();
                if (line != null) {
                    line = line.trim();
                    if (line.length() != 0) {
                        if ("exit".equals(line) || "bye".equals(line))
                            break;
                        ANTLRInputStream input = new ANTLRInputStream(line);
                        CalcLexer lexer = new CalcLexer(input);
                        CommonTokenStream tokens = new CommonTokenStream(lexer);
                        CalcParser parser = new CalcParser(tokens);
                        ParseTree tree = parser.exprs();
                        MyCalcVisitor mv = new MyCalcVisitor();
                        Double res = mv.visit(tree);
                        if (res != null)
                            System.out.println(res);
                    }
                }

                System.out.print(lineStart);
            }
        }
    }

}

 

整個計算器只寫了一個文法和三個類，所有代碼都貼在上面了，相對於完全自己手寫的計算器來說，的確是簡單很多了。