2. 程式人生 > >從零寫一個編譯器（十）：編譯前傳之直接解釋執行

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

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

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

前言

這一篇不看也不會影響後面程式碼生成部分

現在經過詞法分析語法分析語義分析，終於可以進入最核心的部分了。前面那部分可以稱作編譯器的前端，程式碼生成程式碼優化都是屬於編譯器後端，如今有關編譯器的工作崗位主要都是對後端的研究。當然現在寫的這個編譯器因為水平有限，並沒有優化部分。

在進行程式碼生成部分之前，我們先來根據AST來直接解釋執行，其實就是對AST的遍歷。現代直譯器一般都是生成一個比較低階的指令然後跑在虛擬機器上，但是簡單起見我們就直接根據AST解釋執行的直譯器。（原本這部分是不想寫的，是可以直接寫程式碼生成的）

這次的檔案在interpreter包裡，這次涉及到的檔案比較多，就不列舉了

一個小問題

在開始說直譯器的部分前我們看一下，認真觀察之前在構造符號表對賦初值的推導式的處理是有問題的，但是問題不大，只要稍微改動一下

在github原始碼的部分已經改了，改動如下：

case SyntaxProductionInit.VarDecl_Equal_Initializer_TO_Decl:
    attributeForParentNode = (Symbol) valueStack.get(valueStack.size() - 3);
    ((Symbol) attributeForParentNode).value = initialValue;
break;

case SyntaxProductionInit.Expr_TO_Initializer:
    initialValue = (Integer) valueStack.get(valueStack.size() - 1);
    System.out.println(initialValue);
    break;

其實就是一個拿到賦的初值放到Symbol的value裡

示例

先看一下這篇完成之後解釋執行的效果

void swap(int arr[10], int i, int j) {
    int temp;
    temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

void quickSort(int a[10], int p, int r) {
    int x;
    int i;
    i = p - 1;
    int j;
    int t;
    int v;
    v = r - 1;
    if (p < r) {
        x = a[r];
        for (j = p; j <= v; j++) {
            if (a[j] <= x) {
                i++;
                swap(a, i, j);
            }
        }
        v = i + 1;
        swap(a, v, r);
        t = v - 1;
        quickSort(a, p, t);
        t = v + 1;
        quickSort(a, t, r);
    }
}


void main () {
    int a[10];
    int i;
    int t;

    printf("Array before quicksort:");
    for(i = 0; i < 10; i++) {
        t = (10 - i);
        a[i] = t;
        printf("value of a[%d] is %d", i, a[i]);
    }

    quickSort(a, 0, 9);

    printf("Array after quicksort:");
    for (i = 0; i < 10; i++) {
        printf("value of a[%d] is %d", i, a[i]);
    }
}

Executor介面

所有能夠執行結點的類都要實現這個介面，所以以此來達到遍歷AST來執行程式碼

直譯器的啟動在Interpreter類裡，它也實現了Executor介面

Interpreter類的execute傳入的引數就是整棵抽象語法樹的頭節點了，ExecutorFactory的getExecutor則是根據當前結點的TokenType返回一個可以解釋當前節點的類，而其它執行節點的類都繼承了BaseExecutor

@Override
public Object execute(AstNode root) {
    if (root == null) {
        return null;
    }

    ExecutorFactory factory = ExecutorFactory.getInstance();
    Executor executor = factory.getExecutor(root);
    executor.execute(root);

    return root;
}

BaseExecutor的兩個主要方法就是執行它的子節點，並且可以指定執行哪個子節點。可以先忽略Brocaster，這些是用來實現執行節點類之前的通訊的，現在還沒有用。reverseChildren是用來對節點的反轉，因為在建立的AST的過程由於堆疊的原因，所以節點順序的相反的。continueExecute是標誌位，後面可能會執行到設定它的節點來結束執行

protected void executeChildren(AstNode root) {
    ExecutorFactory factory = ExecutorFactory.getInstance();
    root.reverseChildren();

    int i = 0;
    while (i < root.getChildren().size()) {
        if (!continueExecute) {
            break;
        }

        AstNode child = root.getChildren().get(i);
        executorBrocaster.brocastBeforeExecution(child);
        Executor executor = factory.getExecutor(child);
        if (executor != null) {
            executor.execute(child);
        } else {
            System.err.println("Not suitable Generate found, node is: " + child.toString());
        }

        executorBrocaster.brocastAfterExecution(child);

        i++;
    }
}

protected AstNode executeChild(AstNode root, int childIdx) {
    root.reverseChildren();
    AstNode child;
    ExecutorFactory factory = ExecutorFactory.getInstance();
    child = (AstNode)root.getChildren().get(childIdx);
    Executor executor = factory.getExecutor(child);
    AstNode res = (AstNode)executor.execute(child);

    return res;
}

解釋執行

我們可以知道一個C語言的原始檔一般都是一些函式定義和一個main的函式來啟動，所以在AstBuilder裡返回給Interpreter的節點就是從main開始的

public AstNode getSyntaxTreeRoot() {
    AstNode mainNode = funcMap.get("main");
    return mainNode;
}

執行函式ExtDefExecutor

用來執行函式的Executor是ExtDefExecutor

  • 在進入execute會先執行FunctDecl節點，再執行CompoundStmt節點
  • saveArgs和restoreArgs屬於保護當前的環境，就是進入其它作用域的時候保證這個符號不變修改，不比如當作引數傳遞的時候
  • returnVal也是屬於由其它節點設定的屬性
  • root.setAttribute的作用就是對節點設定屬性，把值往上傳遞
@Override
public Object execute(AstNode root) {
    this.root = root;
    int production = (Integer) root.getAttribute(NodeKey.PRODUCTION);
    switch (production) {
        case SyntaxProductionInit.OptSpecifiers_FunctDecl_CompoundStmt_TO_ExtDef:
            AstNode child = root.getChildren().get(0);
            funcName = (String) child.getAttribute(NodeKey.TEXT);
            root.setAttribute(NodeKey.TEXT, funcName);
            saveArgs();
            executeChild(root, 0);

            executeChild(root, 1);
            Object returnVal = getReturnObj();
            clearReturnObj();

            if (returnVal != null) {
                root.setAttribute(NodeKey.VALUE, returnVal);
            }
            isContinueExecution(true);
            restoreArgs();
            break;

        default:
            break;
    }
    return root;
}

函式定義 FunctDeclExecutor

執行函式會先執行它的括號的前部分也就是識別符號和引數那部分，對引數進行初始化，函式的傳遞的引數用單獨一個類FunctionArgumentList來表示

@Override
public Object execute(AstNode root) {
    int production = (Integer) root.getAttribute(NodeKey.PRODUCTION);
    Symbol symbol;
    currentNode = root;

    switch (production) {
        case SyntaxProductionInit.NewName_LP_RP_TO_FunctDecl:
            root.reverseChildren();
            copyChild(root, root.getChildren().get(0));
            break;

        case SyntaxProductionInit.NewName_LP_VarList_RP_TO_FunctDecl:
            symbol = (Symbol) root.getAttribute(NodeKey.SYMBOL);

            Symbol args = symbol.getArgList();
            initArgumentList(args);

            if (args == null || argsList == null || argsList.isEmpty()) {
                System.err.println("generate function with arg list but arg list is null");
                System.exit(1);
            }
            break;

        default:
            break;
    }

    return root;
}

執行語句部分 CompoundStmtExecutor

執行語句的部分就開始對樹的遍歷執行，但是我們來看一下這個節點的推導式

COMPOUND_STMT-> LC LOCAL_DEFS STMT_LIST RC

在構建AST的時候我們並沒有構建LOCAL_DEFS，並且在之前符號表也沒有進行處理，所以我們直接執行第0個節點就可以了

@Override
public Object execute(AstNode root) {
    return executeChild(root, 0);
}

一元操作

下面看UnaryNodeExecutor，UnaryNodeExecutor應該是所有Executor最複雜的之一了，其實對於節點執行，先執行子節點，並且向上傳遞執行結果的值。

只說其中的幾個

  • 指標

這個就是對指標的操作了，本質是對記憶體分配的一個模擬，再設定實現ValueSetter的DirectMemValueSetter，讓它的父節點可以通過這個節點的setter對指標指向進行賦值

ValueSetter是一個可以對變數進行賦值的介面，陣列、指標、簡單的變數都有各自的valueSetter

case SyntaxProductionInit.Start_Unary_TO_Unary:
    child = root.getChildren().get(0);
    int addr = (Integer) child.getAttribute(NodeKey.VALUE);
    symbol = (Symbol) child.getAttribute(NodeKey.SYMBOL);

    MemoryHeap memHeap = MemoryHeap.getInstance();
    Map.Entry<Integer, byte[]> entry = memHeap.getMem(addr);
    int offset = addr - entry.getKey();
    if (entry != null) {
        byte[] memByte = entry.getValue();
        root.setAttribute(NodeKey.VALUE, memByte[offset]);
    }

    DirectMemValueSetter directMemSetter = new DirectMemValueSetter(addr);
    root.setAttribute(NodeKey.SYMBOL, directMemSetter);
    break;

  • 指標和陣列操作：

這是執行陣列或者是指標的操作，對於陣列和指標的操作會在節點中的Symbol裡設定一個可以進行賦值的介面：ArrayValueSetter、PointerValueSetter，邏輯都不是很複雜。對於指標的操作其實是對於記憶體地址分配的一個模擬。

case SyntaxProductionInit.Unary_LB_Expr_RB_TO_Unary:
    child = root.getChildren().get(0);
    symbol = (Symbol) child.getAttribute(NodeKey.SYMBOL);

    child = root.getChildren().get(1);
    int index = (Integer) child.getAttribute(NodeKey.VALUE);

    try {
        Declarator declarator = symbol.getDeclarator(Declarator.ARRAY);
        if (declarator != null) {
            Object val = declarator.getElement(index);
            root.setAttribute(NodeKey.VALUE, val);
            ArrayValueSetter setter = new ArrayValueSetter(symbol, index);
            root.setAttribute(NodeKey.SYMBOL, setter);
            root.setAttribute(NodeKey.TEXT, symbol.getName());
        }
        Declarator pointer = symbol.getDeclarator(Declarator.POINTER);
        if (pointer != null) {
            setPointerValue(root, symbol, index);

            PointerValueSetter pv = new PointerValueSetter(symbol, index);
            root.setAttribute(NodeKey.SYMBOL, pv);
            root.setAttribute(NodeKey.TEXT, symbol.getName());
        }

    } catch (Exception e) {
        System.err.println(e.getMessage());
        e.printStackTrace();
        System.exit(1);
    }
    break;

  • 函式呼叫

函式呼叫也是屬於一元操作，對於函式呼叫有兩種情況：一種是自定義的函式，還有一種是直譯器提供的函式

  1. 如果是自定義函式，就找到這個函式的頭節點，從這個頭節點開始執行
  2. 如果是直譯器提供的函式，就交由ClibCall處理，比如printf就是屬於庫函式
case SyntaxProductionInit.Unary_LP_RP_TO_Unary:
case SyntaxProductionInit.Unary_LP_ARGS_RP_TO_Unary:
    String funcName = (String) root.getChildren().get(0).getAttribute(NodeKey.TEXT);
    if (production == SyntaxProductionInit.Unary_LP_ARGS_RP_TO_Unary) {
        AstNode argsNode = root.getChildren().get(1);
        ArrayList<Object> argList = (ArrayList<Object>) argsNode.getAttribute(NodeKey.VALUE);
        ArrayList<Object> symList = (ArrayList<Object>) argsNode.getAttribute(NodeKey.SYMBOL);
        FunctionArgumentList.getInstance().setFuncArgList(argList);
        FunctionArgumentList.getInstance().setFuncArgSymbolList(symList);
    }

    AstNode func = AstBuilder.getInstance().getFunctionNodeByName(funcName);
    if (func != null) {
        Executor executor = ExecutorFactory.getInstance().getExecutor(func);
        executor.execute(func);
        Object returnVal = func.getAttribute(NodeKey.VALUE);
        if (returnVal != null) {
            ConsoleDebugColor.outlnPurple("function call with name " + funcName + " has return value that is " + returnVal.toString());
            root.setAttribute(NodeKey.VALUE, returnVal);
        }
    } else {
        ClibCall libCall = ClibCall.getInstance();
        if (libCall.isApiCall(funcName)) {
            Object obj = libCall.invokeApi(funcName);
            root.setAttribute(NodeKey.VALUE, obj);
        }
    }
    break;

邏輯語句處理

邏輯語句處理無非就是根據節點值判斷該執行哪些節點

  • FOR、WHILE語句

程式碼邏輯和語句的邏輯是一樣，比如對於

for(i = 0; i < 5; i++){}

就會先執行i = 0部分，在執行{}和i++部分，然後再判斷條件是否符合

case SyntaxProductionInit.FOR_OptExpr_Test_EndOptExpr_Statement_TO_Statement:
executeChild(root, 0);

while (isLoopContinute(root, LoopType.FOR)) {
    //execute statement in for body
    executeChild(root, 3);
    //execute EndOptExpr
    executeChild(root, 2);
}
break;

case SyntaxProductionInit.While_LP_Test_Rp_TO_Statement:
while (isLoopContinute(root, LoopType.WHILE)) {
    executeChild(root, 1);
}
break;

  • IF語句

if語句就是先執行判斷部分，再根據判斷的結果來決定是否執行{}塊

@Override
public Object execute(AstNode root) {

    AstNode res = executeChild(root, 0);
    Integer val = (Integer)res.getAttribute(NodeKey.VALUE);
    copyChild(root, res);

    if (val != null && val != 0) {
        executeChild(root, 1);
    }

    return root;
}

小結

這一篇寫的很亂，一是直譯器部分還是蠻大的，想在一篇之內寫完比較難。所以省略了很多東西。但其實對於直譯器實現部分對於AST的遍歷才比較涉及編譯原理部分，其它的主要是邏輯實現

對於直譯器部分，因為沒有采用虛擬機器那樣的實現，而是直接對AST的遍歷。所以對AST的遍歷是關鍵，主要在於遍歷到該執行的子節點部分，然後處理邏輯，再把資訊通過子節點傳遞到父節點部分。

相關推薦

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

我是如何學習寫一個作業系統（五）：故事的高潮之程序和執行緒1

前言 為什麼取這個標題呢？一是程序和執行緒是作為作業系統裡最重要最核心的一部分。二是確實吃冰棍拉冰棍，沒話，強行湊標題和之前的標題差不多字數。 前一章寫了系統呼叫的過程，算是一個小插曲，這個部分不管在哪裡應該都是可以的。 現在的這個系列已經和之前的標題漸行漸遠了，原本是想以之前寫的一個玩具型作業系統Fragi

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

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

我是如何學習寫一個作業系統（二）：作業系統的啟動之Bootloader

前言 今天本來的任務看書和把之前寫的FragileOS整理一下，但是到現在還在摸魚，書也只看一點。後來整理了一下寫這個系列的思路，原本的目的是對作業系統原理性的學習和對之前寫的一個玩具型作業系統的回顧，就是想對作業系統的知識的輪廓能有一個瞭解，現在想來想減少對之前寫的系統的回顧，畢竟也只有2000多行，但是還

我是如何學習寫一個作業系統（三）：作業系統的啟動之保護模式

前言 上一篇其實已經說完了boot的大致工作，但是Linux在最後進入作業系統之前還有一些操作，比如進入保護模式。在我自己的FragileOS裡進入保護模式是在載入程式結束後完成的。 真實模式到保護模式屬於作業系統的一個大坎，所以需要先提一下 從真實模式到保護模式 真實模式和保護模式都是CPU的工作模式，它

從零開始學習html（十）CSS格式化排版——下

而是 復習 nbsp 1.5 如果 spl 排版 居住 blog 六、文字排版--刪除線 1 <!DOCTYPE HTML> 2 <html> 3 <head> 4 <meta http-equiv="Content-T

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

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

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

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

從零開始學習docker（十）介紹Docker Compose

我們從這一節開始介紹一個非常非常重要的工具--Docker Compose，這個工具會經常使用。 先從一個案例介紹一下我們為什麼

從零開始のcocos2dx生活（十）ScrollView

目錄 簡介 基礎變數 ScrollViewDelegate Direction _dragging _container _touchMoved

從零開始學習MXnet（五）MXnet的黑科技之顯存節省大法

無法 返回 deep logs all 筆記 linear call data 　　寫完發現名字有點拗口。。- -# 　　大家在做deep learning的時候，應該都遇到過顯存不夠用，然後不得不去痛苦的減去batchszie，或者砍自己的網絡結構呢？ 最後跑出來的效果不