2. 程式人生 > >從零寫一個編譯器（九）：語義分析之構造抽象語法樹(AST)

從零寫一個編譯器（九）：語義分析之構造抽象語法樹(AST)

阿新 • • 發佈：2019-08-19

專案的完整程式碼在 C2j-Compiler

前言

在上一篇完成了符號表的構建，下一步就是輸出抽象語法樹(Abstract Syntax Tree，AST)

抽象語法樹（abstract syntax tree 或者縮寫為 AST），是原始碼的抽象語法結構的樹狀表現形式，這裡特指程式語言的原始碼。樹上的每個節點都表示原始碼中的一種結構。

AST對於編譯器是至關重要的，現在的編譯型語言一般通過AST來生成IR，解釋型語言也可以不用虛擬機器而直接遍歷AST來解釋執行，之後要寫直譯器和編譯器都依賴這個AST

這一篇主要檔案有：

  • AstBuilder.java
  • AstNode.java
  • AstNodeImpl.java
  • NodeKey.java
  • NodeFactory.java

主要資料結構

AST節點的表示

public interface AstNode {

    AstNode addChild(AstNode node);

    AstNode getParent();

    ArrayList<AstNode> getChildren();

    void setAttribute(NodeKey key, Object value);

    Object getAttribute(NodeKey key);

    boolean isChildrenReverse();

    void reverseChildren();

    AstNode copy();

}

這是對AstNode介面的實現，並且繼承HashMap，這裡的NodeKey是

TokenType, VALUE, SYMBOL, PRODUCTION, TEXT

對應的value，

  1. TokenType就是非終結符的型別
  2. Text用來儲存解析物件的文字資訊
  3. Symbol對應的就是變數的符號物件
  4. Value是對應物件解析的值，比如int a = 1，那麼value的值就為1
public class AstNodeImpl extends HashMap<NodeKey, Object> implements AstNode {
    private Token type;
    private AstNodeImpl parent;
    private ArrayList<AstNode> children;
    String name;

    private boolean isChildrenReverse = false;

    public AstNodeImpl(Token type) {
        this.type = type;
        this.parent = null;
        this.children = new ArrayList<>();
        setAttribute(NodeKey.TokenType, type);
    }

    @Override
    public AstNode addChild(AstNode node) {
        if (node != null) {
            children.add(node);
            ((AstNodeImpl) node).parent = this;
        }

        return node;
    }

    @Override
    public AstNode getParent() {
        return parent;
    }

    @Override
    public void reverseChildren() {
        if (isChildrenReverse) {
            return;
        }

        Collections.reverse(children);
        isChildrenReverse = true;
    }

    @Override
    public boolean isChildrenReverse() {
        return isChildrenReverse;
    }

    @Override
    public ArrayList<AstNode> getChildren() {
        reverseChildren();

        return children;
    }

    @Override
    public void setAttribute(NodeKey key, Object value) {
        if (key == NodeKey.TEXT) {
            name = (String) value;
        }
        put(key, value);
    }

    @Override
    public Object getAttribute(NodeKey key) {
        return get(key);
    }

    @Override
    public String toString() {
        String info = "";
        if (get(NodeKey.VALUE) != null) {
            info += "Node Value is " + get(NodeKey.VALUE).toString();
        }

        if (get(NodeKey.TEXT) != null) {
            info += "\nNode Text is " + get(NodeKey.TEXT).toString();
        }

        if (get(NodeKey.SYMBOL) != null) {
            info += "\nNode Symbol is " + get(NodeKey.SYMBOL).toString();
        }

        return info + "\n Node Type is " + type.toString();
    }

    @Override
    public AstNode copy() {
        AstNodeImpl copy = (AstNodeImpl) NodeFactory.createICodeNode(type);
        Set<Entry<NodeKey, Object>> attributes = entrySet();
        Iterator<Map.Entry<NodeKey, Object>> it = attributes.iterator();

        while (it.hasNext()) {
            Map.Entry<NodeKey, Object> attribute = it.next();
            copy.put(attribute.getKey(), attribute.getValue());
        }

        return copy;
    }
}

NodeFactory

NodeFactory就是簡單的返回一個節點的實現

public class NodeFactory {
    public static AstNode createICodeNode(Token type) {
        return new AstNodeImpl(type);
    }
}

構造AST

AST的建立也是需要在語法分析過程中根據reduce操作進行操作的。也就是在takeActionForReduce方法中呼叫AstBuilder的buildSyntaxTree方法

在AstBuilder裡面還是需要兩個堆疊來輔助操作

private Stack<AstNode> nodeStack = new Stack<>();

private LRStateTableParser parser = null;
private TypeSystem typeSystem = null;
private Stack<Object> valueStack = null;
private String functionName;
private HashMap<String, AstNode> funcMap = new HashMap<>();

private static AstBuilder instance;

構造AST的主要邏輯在buildSyntaxTree方法裡，需要注意的是有一些節點在解釋執行和程式碼生成的時候是不一樣的，有時程式碼生成需要的節點解釋執行的話並不需要

在這裡提一下UNARY這個非終結符，這個非終結符和NAME很像，但是它一般是代表進行運算和一些操作的時候，比如陣列，++，--或者函式呼叫的時候

其實構建AST的過程和符號表的構建過程有點兒類似，都是根據reduce操作來建立資訊和組合資訊，符號表是組合修飾符說明符等，而AST則是組合節點間的關係變成一棵樹

我們只看幾個操作

  • Specifiers_DeclList_Semi_TO_Def

    這個節點需要注意的是，從堆疊的什麼地方拿到Symbol，這個需要從reduce次數和推導式中得出
* DEF -> SPECIFIERS  DECL_LIST SEMI
* DECL -> VAR_DECL
* VAR_DECL -> NEW_NAME
*             | VAR_DECL LP RP
*             | VAR_DECL LP VAR_LIST RP
*             | LP VAR_DECL RP
*             | START VAR_DECL

從推導式可以看出，DEF節點的符號應該在valueStack.size() - 3，但是DECL和VAR_DECL沒有做reduce操作，所以符號應該在valueStack.size() - 2。這其實和前面的符號表構建算出之前符號的位置是一樣的。

  • TO_UNARY

這裡則是變數、數字或者字串的節點，如果是個變數的號，這個節點就需要一個Symbol的value了

case SyntaxProductionInit.Number_TO_Unary:
case SyntaxProductionInit.Name_TO_Unary:
case SyntaxProductionInit.String_TO_Unary:
    node = NodeFactory.createICodeNode(Token.UNARY);
    if (production == SyntaxProductionInit.Name_TO_Unary) {
        assignSymbolToNode(node, text);
    }

    node.setAttribute(NodeKey.TEXT, text);
    break;

其餘的節點無非是把一些語句拆分它的邏輯然後組成節點，真正的求值部分像Name_TO_Unary比較少，更多是比如把一個if else塊分成if節點、判斷節點、else節點，之後再按照這棵樹進行解釋執行或者程式碼生成

public AstNode buildSyntaxTree(int production, String text) {
    AstNode node = null;
    Symbol symbol = null;
    AstNode child = null;

    if (Start.STARTTYPE == Start.INTERPRETER) {
        int p1 = SyntaxProductionInit.Specifiers_DeclList_Semi_TO_Def;
        int p2 = SyntaxProductionInit.Def_To_DefList;
        int p3 = SyntaxProductionInit.DefList_Def_TO_DefList;

        boolean isReturn = production == p1 || production == p2 || production == p3;
        if (isReturn) {
            return null;
        }
    }

    switch (production) {
        case SyntaxProductionInit.Specifiers_DeclList_Semi_TO_Def:
            node = NodeFactory.createICodeNode(Token.DEF);
            symbol = (Symbol) valueStack.get(valueStack.size() - 2);
            node.setAttribute(NodeKey.SYMBOL, symbol);
            break;
        case SyntaxProductionInit.Def_To_DefList:
            node = NodeFactory.createICodeNode(Token.DEF_LIST);
            node.addChild(nodeStack.pop());
            break;
        case SyntaxProductionInit.DefList_Def_TO_DefList:
            node = NodeFactory.createICodeNode(Token.DEF_LIST);
            node.addChild(nodeStack.pop());
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.Number_TO_Unary:
        case SyntaxProductionInit.Name_TO_Unary:
        case SyntaxProductionInit.String_TO_Unary:
            node = NodeFactory.createICodeNode(Token.UNARY);
            if (production == SyntaxProductionInit.Name_TO_Unary) {
                assignSymbolToNode(node, text);
            }

            node.setAttribute(NodeKey.TEXT, text);
            break;

        case SyntaxProductionInit.Unary_LP_RP_TO_Unary:
            node = NodeFactory.createICodeNode(Token.UNARY);
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.Unary_LP_ARGS_RP_TO_Unary:
            node = NodeFactory.createICodeNode(Token.UNARY);
            node.addChild(nodeStack.pop());
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.Unary_Incop_TO_Unary:
        case SyntaxProductionInit.Unary_DecOp_TO_Unary:
        case SyntaxProductionInit.LP_Expr_RP_TO_Unary:
        case SyntaxProductionInit.Start_Unary_TO_Unary:
            node = NodeFactory.createICodeNode(Token.UNARY);
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.Unary_LB_Expr_RB_TO_Unary:
            node = NodeFactory.createICodeNode(Token.UNARY);
            node.addChild(nodeStack.pop());
            node.addChild(nodeStack.pop());

            break;

        case SyntaxProductionInit.Uanry_TO_Binary:
            node = NodeFactory.createICodeNode(Token.BINARY);
            child = nodeStack.pop();
            node.setAttribute(NodeKey.TEXT, child.getAttribute(NodeKey.TEXT));
            node.addChild(child);
            break;

        case SyntaxProductionInit.Binary_TO_NoCommaExpr:
        case SyntaxProductionInit.NoCommaExpr_Equal_NoCommaExpr_TO_NoCommaExpr:
            node = NodeFactory.createICodeNode(Token.NO_COMMA_EXPR);
            child = nodeStack.pop();
            String t = (String) child.getAttribute(NodeKey.TEXT);
            node.addChild(child);
            if (production == SyntaxProductionInit.NoCommaExpr_Equal_NoCommaExpr_TO_NoCommaExpr) {
                child = nodeStack.pop();
                t = (String) child.getAttribute(NodeKey.TEXT);
                node.addChild(child);
            }
            break;

        case SyntaxProductionInit.Binary_Plus_Binary_TO_Binary:
        case SyntaxProductionInit.Binary_DivOp_Binary_TO_Binary:
        case SyntaxProductionInit.Binary_Minus_Binary_TO_Binary:
        case SyntaxProductionInit.Binary_Start_Binary_TO_Binary:
            node = NodeFactory.createICodeNode(Token.BINARY);
            node.addChild(nodeStack.pop());
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.Binary_RelOP_Binary_TO_Binray:
            node = NodeFactory.createICodeNode(Token.BINARY);
            node.addChild(nodeStack.pop());

            AstNode operator = NodeFactory.createICodeNode(Token.RELOP);
            operator.setAttribute(NodeKey.TEXT, parser.getRelOperatorText());
            node.addChild(operator);

            node.addChild(nodeStack.pop());

            break;

        case SyntaxProductionInit.NoCommaExpr_TO_Expr:
            node = NodeFactory.createICodeNode(Token.EXPR);
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.Expr_Semi_TO_Statement:
        case SyntaxProductionInit.CompountStmt_TO_Statement:
            node = NodeFactory.createICodeNode(Token.STATEMENT);
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.LocalDefs_TO_Statement:
            node = NodeFactory.createICodeNode(Token.STATEMENT);
            if (Start.STARTTYPE == Start.CODEGEN) {
                node.addChild(nodeStack.pop());
            }
            break;

        case SyntaxProductionInit.Statement_TO_StmtList:
            node = NodeFactory.createICodeNode(Token.STMT_LIST);
            if (nodeStack.size() > 0) {
                node.addChild(nodeStack.pop());
            }
            break;

        case SyntaxProductionInit.FOR_OptExpr_Test_EndOptExpr_Statement_TO_Statement:
            node = NodeFactory.createICodeNode(Token.STATEMENT);
            node.addChild(nodeStack.pop());
            node.addChild(nodeStack.pop());
            node.addChild(nodeStack.pop());
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.StmtList_Statement_TO_StmtList:
            node = NodeFactory.createICodeNode(Token.STMT_LIST);
            node.addChild(nodeStack.pop());
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.Expr_TO_Test:
            node = NodeFactory.createICodeNode(Token.TEST);
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.If_Test_Statement_TO_IFStatement:
            node = NodeFactory.createICodeNode(Token.IF_STATEMENT);
            node.addChild(nodeStack.pop());
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.IfElseStatemnt_Else_Statemenet_TO_IfElseStatement:
            node = NodeFactory.createICodeNode(Token.IF_ELSE_STATEMENT);
            node.addChild(nodeStack.pop());
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.While_LP_Test_Rp_TO_Statement:
        case SyntaxProductionInit.Do_Statement_While_Test_To_Statement:
            node = NodeFactory.createICodeNode(Token.STATEMENT);
            node.addChild(nodeStack.pop());
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.Expr_Semi_TO_OptExpr:
        case SyntaxProductionInit.Semi_TO_OptExpr:
            node = NodeFactory.createICodeNode(Token.OPT_EXPR);
            if (production == SyntaxProductionInit.Expr_Semi_TO_OptExpr) {
                node.addChild(nodeStack.pop());
            }
            break;

        case SyntaxProductionInit.Expr_TO_EndOpt:
            node = NodeFactory.createICodeNode(Token.END_OPT_EXPR);
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.LocalDefs_StmtList_TO_CompoundStmt:
            node = NodeFactory.createICodeNode(Token.COMPOUND_STMT);
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.NewName_LP_RP_TO_FunctDecl:
        case SyntaxProductionInit.NewName_LP_VarList_RP_TO_FunctDecl:
            node = NodeFactory.createICodeNode(Token.FUNCT_DECL);
            node.addChild(nodeStack.pop());
            child = node.getChildren().get(0);
            functionName = (String) child.getAttribute(NodeKey.TEXT);
            symbol = assignSymbolToNode(node, functionName);

            break;

        case SyntaxProductionInit.NewName_TO_VarDecl:
            nodeStack.pop();
            break;

        case SyntaxProductionInit.NAME_TO_NewName:
            node = NodeFactory.createICodeNode(Token.NEW_NAME);
            node.setAttribute(NodeKey.TEXT, text);
            break;

        case SyntaxProductionInit.OptSpecifiers_FunctDecl_CompoundStmt_TO_ExtDef:
            node = NodeFactory.createICodeNode(Token.EXT_DEF);
            node.addChild(nodeStack.pop());
            node.addChild(nodeStack.pop());
            funcMap.put(functionName, node);
            break;

        case SyntaxProductionInit.NoCommaExpr_TO_Args:
            node = NodeFactory.createICodeNode(Token.ARGS);
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.NoCommaExpr_Comma_Args_TO_Args:
            node = NodeFactory.createICodeNode(Token.ARGS);
            node.addChild(nodeStack.pop());
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.Return_Semi_TO_Statement:
            node = NodeFactory.createICodeNode(Token.STATEMENT);
            break;
        case SyntaxProductionInit.Return_Expr_Semi_TO_Statement:
            node = NodeFactory.createICodeNode(Token.STATEMENT);
            node.addChild(nodeStack.pop());
            break;

        case SyntaxProductionInit.Unary_StructOP_Name_TO_Unary:
            node = NodeFactory.createICodeNode(Token.UNARY);
            node.addChild(nodeStack.pop());
            node.setAttribute(NodeKey.TEXT, text);
            break;

        default:
            break;
    }

    if (node != null) {
        node.setAttribute(NodeKey.PRODUCTION, production);
        nodeStack.push(node);
    }

    return node;
}

小結

其實構造AST和建立符號表上非常相似，都是依據reduce操作的資訊來完成。在AST的構建中的主要任務就是對原始碼語句裡的邏輯進行分塊，比如對於一個ifelse語句：

上面的圖是我依據這個意思話的，和上面構造出來的AST不完全一致

另外我的github部落格：https://dejavudwh.

相關推薦

從零寫一個編譯器（九）：語義分析之構造抽象語法樹(AST)

專案的完整程式碼在 C2j-Compiler 前言 在上一篇完成了符號表的構建，下一步就是輸出抽象語法樹(Abstract Syntax Tree，AST) 抽象語法樹（abstract syntax tree 或者縮寫為 AST），是原始碼的抽象語法結構的樹狀表現形式，這裡特指程式語言的原始碼。樹上的

從零寫一個編譯器（八）：語義分析之構造符號表

專案的完整程式碼在 C2j-Compiler 前言 在之前完成了描述符號表的資料結構，現在就可以正式構造符號表了。符號表的建立自然是要根據語法分析過程中走的，所以符號表的建立就在LRStateTableParser裡的takeActionForReduce方法 不過在此之前，當然還需要一個方便對這個符號表

從零寫一個編譯器（七）：語義分析之符號表的資料結構

專案的完整程式碼在 C2j-Compiler 前言 有關符號表的檔案都在symboltable包裡 前面我們通過完成一個LALR(1)有限狀態自動機和一個reduce資訊來構建了一個語法解析表，正式完成了C語言的語法解析。接下來就是進入語義分析部分，和在第二篇提到的一樣，語義分析的主要任務就是生成符號

從零寫一個編譯器（十三）：程式碼生成之遍歷AST

專案的完整程式碼在 C2j-Compiler 前言 在上一篇完成對JVM指令的生成，下面就可以真正進入程式碼生成部分了。通常現代編譯器都是先把生成IR，再經過程式碼優化等等，最後才編譯成目標平臺程式碼。但是時間水平有限，我們沒有IR也沒有程式碼優化，就直接利用AST生成Java位元組碼 入口 進行程式碼生

從零寫一個編譯器（五）：語法分析之自動機的缺陷和改進

專案的完整程式碼在 C2j-Compiler 前言 在上一篇，已經成功的構建了有限狀態自動機，但是這個自動機還存在兩個問題： 無法處理shift/reduce矛盾 狀態節點太多，導致自動機過大，效率較低 這一節就要解決這兩個問題 shift/reduce矛盾 看上一節那個例子的一個節點 e ->

從零寫一個編譯器（六）：語法分析之表驅動語法分析

專案的完整程式碼在 C2j-Compiler 前言 上一篇已經正式的完成了有限狀態自動機的構建和足夠判斷reduce的資訊，接下來的任務就是根據這個有限狀態自動機來完成語法分析表和根據這個表來實現語法分析 reduce資訊 在完成語法分析表之前，還差最後一個任務，那就是描述reduce資訊，來指導自動機是

從零寫一個編譯器（十）：編譯前傳之直接解釋執行

專案的完整程式碼在 C2j-Compiler 前言 這一篇不看也不會影響後面程式碼生成部分 現在經過詞法分析語法分析語義分析，終於可以進入最核心的部分了。前面那部分可以稱作編譯器的前端，程式碼生成程式碼優化都是屬於編譯器後端，如今有關編譯器的工作崗位主要都是對後端的研究。當然現在寫的這個編譯器因為水平有限

從零寫一個編譯器（完結）：總結和系列索引

前言 這個系列算作我自己的學習筆記，到現在已經有十三篇了，加上這篇一共十四篇。一步一步的從詞法分析到語法分析、語義分析，再到程式碼生成，準備在這一篇做一個總結收尾和一個這個系列以前文章的索引。 （另外，由於我現在的這個主題不能對markdown的一級標題作目錄，所以這個系列文章的目錄都是有問題的） 索引 從零

從零寫一個編譯器（十一）：程式碼生成之Java位元組碼基礎

專案的完整程式碼在 C2j-Compiler 前言 第十一篇，終於要進入程式碼生成部分了，但是但是在此之前，因為我們要做的是C語言到位元組碼的編譯，所以自然要了解一些位元組碼，但是由於C語言比較簡單，所以只需要瞭解一些位元組碼基礎 JVM的基本機制 JVM有一個執行環境叫做stack frame 這個

從零寫一個編譯器（十二）：程式碼生成之生成邏輯

專案的完整程式碼在 C2j-Compiler 前言 在上一篇解釋完了一些基礎的Java位元組碼指令後，就可以正式進入真正的程式碼生成部分了。但是這部分先說的是程式碼生成依靠的幾個類，也就是用來生成指令的操作。 這一篇用到的檔案都在codegen下： Directive.java Instruction.

從零開始學caffe（九）：在Windows下實現影象識別

本系列文章主要介紹了在win10系統下caffe的安裝編譯，運用CPU和GPU完成簡單的小專案，文章之間具有一定延續性。 step1:準備資料集 資料集是進行深度學習的第一步，在這裡我們從以下五個連結中下載所需要的資料集： animal flower plane hou

我是如何學習寫一個作業系統（九）：檔案系統

前言 這個應該是這個系列的尾聲了，一個完整的作業系統可能最主要的也就是分成這幾大模組：程序管理、記憶體管理和檔案系統。計算機以程序為基本單位進行資源的排程和分配；而與使用者的互動，基本單位則是檔案 生磁碟 檔案正是對生磁碟的抽象 磁碟的組成 一個磁碟由多個盤面串聯而成，而一個盤面又被分為磁軌，磁軌又由扇區

從零打造一個CMDB（一）資料庫設計

俠義的CMDB都是偏向純資產管理，但運維繫統往往圍繞著這些資產中心，從資產進行不斷外充擴容 在其基礎之外擴展出各功能，通過cmdb 擴展出各個子系統  涉及工具：workbench 一個例子：設計一個數據庫實現主機資訊、交換機資訊，如何將之間的資訊關聯起來 初步的傳統設計：

從零開始學caffe（四）：mnist手寫數字識別網路結構模型和超引數檔案的原始碼閱讀

下面為網路結構模型 %網路結構模型 name: "LeNet" #網路的名字"LeNet" layer { #定義一個層 name: "mnist" #層的名字"mnist" type:

從零開始學習docker（九）持久化儲存和資料共享

有些時候容器會產生一些資料，而我們不希望這些資料隨著容器的刪除而刪除。想保證資料的安全，一般用在資料庫。 首先看一下contai

從零開始學習docker（九）持久化儲存和資料共享之 bind Mounting

資料持久化的第一種方式Data Volume 使用Data Volume: 首先在Dockerfile中定義 Volu

從零開始學習熱更新（一）：搭建FTP服務器

啟動服務 ocs 手動 動態ip 手動添加 如果 信息 clas 路徑 --轉載了一部分來自http://blog.csdn.net/haibo19981/article/details/51890912 以下是在win7下的coocs2dx3.10 lua開發的 1.

SpringMVC乾貨系列：從零搭建SpringMVC+mybatis（二）：springMVC原理解析及常用註解

SpringMVC框架介紹 SpringMVC就是通過DispatcherServlet將一堆元件串聯起來的Web框架。 Spring MVC屬於SpringFrameWork的後續產品，已經融合在Spring Web Flow裡面。 Spring 框架提供了構建 We

從零開始學caffe（七）：利用GoogleNet實現影象識別

一、準備模型 在這裡，我們利用已經訓練好的Googlenet進行物體影象的識別，進入Googlenet的GitHub地址，進入models資料夾，選擇Googlenet 點選Googlenet的模型下載地址下載該模型到電腦中。 模型結構 在這裡，我們利用之前講

從零開始學caffe（十）：caffe中snashop的使用

在caffe的訓練期間，我們有時候會遇到一些不可控的以外導致訓練停止（如停電、裝置故障燈），我們就不得不重新開始訓練，這對於一些大型專案而言是非常致命的。在這裡，我們介紹一些caffe中的snashop。利用snashop我們就可以實現訓練的繼續進行。 在之前我們訓練得到的檔案中，我們發現