小白說編譯原理-8-簡單minus-c語言編譯樹(支撐類)
前言
這個編譯原理是一個系列，系列地址為： https://blog.csdn.net/lpstudy/article/category/937055
考慮到很多小夥伴諮詢程式碼的問題，現把連結發出來：https://github.com/lpstudy/compile
這個連結裡面具有這個系列所有的VS工程和程式碼，工程是按照系列中的一個教程環境配置6來配置的，不過lib我好像沒有上傳到github。
如果大家發現任何問題，可以在github或者csdn，我有空的時候完善一下，爭取做到下載github工程即可跑。
簡介
本章在上一節7的基礎上對編譯樹進行完善。 上一節7的編譯樹僅僅支援算術表示式的+-基本運算，本節對其進行擴充，使其支援不僅支援基本的算術運算，還支援變數，支援語句(if, while,input, ouput)，經過這次擴充，它形成的語法樹已經基本具備了表達minus-c語言的能力。
簡單說來，它可以表示下面的c語言程式碼：
a = 1
if(a>10){
a = 11
}else{
a = 7
}
print(a)
a =1
sum = 0
while(a <= 10){
sum = sum + a
a = a+1;
}
print(sum)
根據上述的c語言程式碼，通過手動構建對應的語法樹，然後後序遍歷語法樹，就可以執行程式碼，輸出結果。本節的編譯樹程式碼並不關注如何根據c語言程式碼自動構建語法樹(lex和yacc支援)， 而是著眼於對手動構建的語法樹進行遍歷執行。
語句的處理
if語句
if(expr) {stmt1} else {stmt2}
對於if樹節點，它具有3個孩子，expr，stmt1，stmt2. 當後序遍歷到if節點時候，它首先判斷expr是否為真，如果為真，則執行stmt1，否則執行stmt2，因此當執行後序遍歷的時候，我們會有這樣的程式碼：
if(t->kind == STMT_NODE){
if(t->kind_kind == IF_STMT){
//if條件判斷結果，第二個孩子儲存if成功的程式碼，第三個孩子儲存else成功的程式碼
recursive_execute(t->children[0]);
if (my_mem[t->children[0]->addr] )
recursive_execute(t->children[1]);
else
recursive_execute(t->children[2]);
}//IF_STMT
}//STMT_NODE
如上面的程式碼所示，首先根據t->kind判斷是否是語句節點，然後根據子型別t->kind_kind判斷是否是if節點。如果是的話，首先遞迴執行第一個孩子，執行完畢後，結果儲存在my_mem[t->children[0]->addr]中，然後判斷它的值是否為真，如果為真，則執行stmt1，否則執行stmt2。
while語句
while(expr) {stmt}
與if不同的是，while只有兩個孩子，expr和stmt， 同時當expr為真的時候，stmt會迴圈執行，直到expr為假。因此遍歷程式碼如下：
if(t->kind_kind == WHILE_STMT){
//第一個孩子儲存條件判斷結果，第二個孩子儲存while成功的程式碼
recursive_execute(t->children[0]);
while (my_mem[t->children[0]->addr])
{
recursive_execute(t->children[1]);
recursive_execute(t->children[0]);
}
}
輸入輸出語句
輸入輸出相當於修改或者列印給定節點對應的記憶體的值，因此就非常簡單，程式碼如下：
else if(t->kind_kind == INPUT_STMT){//input statement has one expr child
cout<<"please input data:";
cin>>my_mem[t->children[0]->addr];
}else if(t->kind_kind == PRINT_STMT){//print statement has one expr child to print.
recursive_execute(t->children[0]);
cout<<my_mem[t->children[0]->addr];
}
複合語句
複合語句是用來包裝多個簡單語句的，例如如果有3個語句，它們之間是順序執行的關係，但是最後生成是一棵樹，因此需要將3個語句組合在一起，簡單來說就是將這3個語句的Node作為一個複合語句Node的孩子，當遍歷執行的時候，只需要逐個執行每一個孩子即可。
程式碼如下：
else if(t->kind_kind == COMP_STMT){//組合語句，逐個語句執行即可。
for (int i = 0; i < MAX_CHILDREN; ++i)
recursive_execute(t->children[i]);
}
表示式語句
表示式語句就是基本的表示式後面加上分號，例如b=1;這就是一個語句，它是一個賦值表示式然後加上分號構成的語句。為了簡單起見，對於表示式語句，它只有一個孩子就是表示式，因此表示式語句的執行就是執行它的孩子(表示式)
程式碼如下：
else if(t->kind_kind == EXPR_STMT){
recursive_execute(t->children[0]);
}
表示式的處理
表示式有很多種，例如二元的加減乘除，邏輯運算與或非，比較運算子，一元的取非，自增自減等等，以及還是純粹的數字，變數表示式。簡單起見，本程式碼只考慮支援基本的二元運算以及數字和變數表示式，它的執行程式碼比較簡單，不具體闡述，示意如下：
if (t->kind == EXPR_NODE){ // 表示式結點
recursive_execute(t->children[0]);
recursive_execute(t->children[1]);
if (t->kind_kind == OP_EXPR) { // 運算型別表示式
if (t->attr.op == PLUS) // 加法表示式
// 從記憶體（my_mem）中取出兩個孩子的值，進行加法，結果寫回記憶體
my_mem[t->addr] = my_mem[t->children[0]->addr] + my_mem[t->children[1]->addr];
else if (t->attr.op == MINUS) // 減法的處理類似加法
my_mem[t->addr] = my_mem[t->children[0]->addr] - my_mem[t->children[1]->addr];
else if (t->attr.op == TIMES)
my_mem[t->addr] = my_mem[t->children[0]->addr] * my_mem[t->children[1]->addr];
else if (t->attr.op == OVER){
if(my_mem[t->children[1]->addr] == 0){
cout<<"error: divide by zero"<<endl;
my_mem[t->addr] = 0;
}else{
my_mem[t->addr] = my_mem[t->children[0]->addr] / my_mem[t->children[1]->addr];
}
}
else if (t->attr.op == AND)
my_mem[t->addr] = my_mem[t->children[0]->addr] && my_mem[t->children[1]->addr];
else if (t->attr.op == OR)
my_mem[t->addr] = my_mem[t->children[0]->addr] || my_mem[t->children[1]->addr];
else if (t->attr.op == EQ)
my_mem[t->addr] = (my_mem[t->children[0]->addr] == my_mem[t->children[1]->addr]);
else if (t->attr.op == GT)
my_mem[t->addr] = my_mem[t->children[0]->addr] > my_mem[t->children[1]->addr];
else if (t->attr.op == LT)
my_mem[t->addr] = (my_mem[t->children[0]->addr] < my_mem[t->children[1]->addr]);
else if (t->attr.op == NE)
my_mem[t->addr] = !(my_mem[t->children[0]->addr] == my_mem[t->children[1]->addr]);
else if (t->attr.op == GE)
my_mem[t->addr] = (my_mem[t->children[0]->addr] > my_mem[t->children[1]->addr]) || (my_mem[t->children[0]->addr] == my_mem[t->children[1]->addr]);
else if (t->attr.op == LE)
my_mem[t->addr] = (my_mem[t->children[0]->addr] < my_mem[t->children[1]->addr]) || (my_mem[t->children[0]->addr] == my_mem[t->children[1]->addr]);
else if(t->attr.op == ASSIGN){
my_mem[t->addr] = my_mem[t->children[0]->addr] = my_mem[t->children[1]->addr];
}
}
else if (t->kind_kind == CONST_EXPR) // 常量表示式，將值（在vali中）儲存至分配的記憶體中
my_mem[t->addr] = t->attr.vali;
else if(t->kind_kind == ID_EXPR){
//do nothing
}
}//EXPR_NODE
其中比較特別就是對於ID_EXPR(變數)型別，不作處理。這是因為此程式碼並沒有支援符號表，變數節點的記憶體直接儲存的是變數的值，而不是如正規的符號表中儲存是變數所處於的符號表的位置。 當碰到ID_EXPR型別，不需要進行額外的處理，變數的記憶體更新由具體的賦值運算決定。
樹構建程式碼
先針對一個具體的while例子，說明如何構建一顆語法樹，可以表達while語句。
要表達的while語句如下：
a =1
sum = 0
while(a <= 10){
sum = sum + a
a = a+1;
}
print(sum)
它包含2個變數，輸出結果是1+2+…+10。
對應的構建語法樹的程式碼：
void whileTest()
{
tree expr;
Node *p, *q, *r, *s, *o, *u, *t,*p1,*q1;
p = createId(expr);//a
q = createId(expr);//sum
p1 = createAssignStmt(expr,p, 1);//a=1
q1 = createAssignStmt(expr, q, 0);//sum=0
Node *a, *b, *c, *d, *e, *f, *g;
a = createOpExpr(expr, p, createConst(expr, 10), LE);//a<=10
b = createOpExpr(expr, p, q, PLUS);//sum+a
c = createAssignStmt(expr, q, b);//sum = sum+a
d = createOpExpr(expr, p, createConst(expr, 1), PLUS);
e = createAssignStmt(expr, p, d); //a=a+1
f = createCompStmt(expr, c, e); //{sum = sum+a, a= a+1}
r = createWhileStmt(expr, a, f);//while
t = createOutStmt(expr, q);//print sum
o = createCompStmt(expr, p1, q1, r, t);
executeTree(expr, o);
}
上面有很多createXXX的函式，並不需要關注其具體實現也可以讀懂上面的構建程式碼。
首先建立兩個變數，然後建立兩個賦值語句, ，隨後建立while語句和print語句，最後將個語句組裝成一個組合語句並將作為語法樹的根，啟動execute執行。
實現程式碼
考慮到便於大家自己擴充，我將我自己擴充的版本放在這裡，大家可以根據自己的想法繼續擴充，例如實現多種一元運算子，實現for迴圈等等。大家將下面的程式碼直接貼上到vs工程中，編譯就可以執行。注意main函式中有多種test，可以專注於某一種情況的測試。
#include <iostream>
#include <malloc.h>
using namespace std;
#define MAX_CHILDREN 4
int my_mem[100]; // “記憶體”
int offset;
enum // 結點型別——kind
{
STMT_NODE = 0,
EXPR_NODE,
DECL_NODE
};
enum // 語句結點子型別——kindkind
{
IF_STMT = 0,
WHILE_STMT,
INPUT_STMT,
PRINT_STMT,
COMP_STMT,
EXPR_STMT, //只是一個包裝而已
};
enum // 表示式結點子型別——kindkind
{
TYPE_EXPR = 0,
OP_EXPR,
NOT_EXPR,
ARRAY_EXPR,
CONST_EXPR,
ID_EXPR,
};
enum // 宣告結點子型別——kindkind
{
VAR_DECL = 0,
ARRAY_DECL
};
enum // 運算——op
{
//加減乘除，算術運算子
PLUS = 0,
MINUS,
TIMES,
OVER,
//與或，邏輯運算子
AND,
OR,
//比較運算子
EQ,
LT,
GT,
GE,
LE,
NE,
ASSIGN,
};
enum
{
Integer = 0,
};
union NodeAttr {
int op; // 表示式結點，子型別是運算型別時，用op儲存具體運算
double vali; // 表示式結點，常量表示式時，用vali儲存整型常量值
char valc; // 字元值
NodeAttr(void) { op = 0; } // 幾種建構函式
NodeAttr(int i) { op = i; }
NodeAttr(double i) { vali = i; }
NodeAttr(char c) { valc = c; }
};
struct Node
{
struct Node *children[MAX_CHILDREN]; // 孩子結點
int kind; // 結點型別
int kind_kind; // 子型別
NodeAttr attr; // 結點屬性
int addr; // 分配的記憶體空間（陣列下標）
};
class tree // 語法樹類
{
private:
Node *root; // 根結點
private:
void recursive_get_addr(Node *t); // 為臨時變數（如表示式）分配儲存空間
void recursive_execute(Node *t); // 遍歷樹，執行源程式
public:
void setRoot(Node* p){root = p;}
Node *NewRoot(int kind, int kind_kind, NodeAttr attr, int type,
Node *child1 = NULL, Node *child2 = NULL, Node *child3 = NULL, Node *child4 = NULL); // 建立一個結點，設定其屬性，連線孩子結點
void get_addr(void); // 分配空間和執行程式碼的介面
void execute(void);
};
Node * tree::NewRoot(int kind, int kind_kind, NodeAttr attr, int type,
Node *child1, Node *child2, Node *child3 , Node *child4)
{
Node* node = new Node();
node->kind = kind;
node->kind_kind = kind_kind;
node->attr = attr;
node->children[0] = child1;
node->children[1] = child2;
node->children[2] = child3;
node->children[3] = child4;
return node;
}
void tree::get_addr(void)
{
cout << "allocate memory..." << endl;
offset = 0;
recursive_get_addr(root); // 介面函式直接呼叫實際分配空間的遞迴函式
}
void tree::recursive_get_addr(Node *t)
{
if (t) { // 空指標什麼也不做
if (t->kind == EXPR_NODE) { // 為表示式結點分配儲存空間
t->addr = offset++;
//cout << t->addr << endl;
}
for (int i = 0; i < MAX_CHILDREN; i++) // 遞迴處理所有子樹——先序遍歷
recursive_get_addr(t->children[i]);
}
}
void tree::execute(void)
{
cout << "execute..." << endl;
recursive_execute(root); // 介面函式呼叫遞迴函式
//cout << my_mem[root->addr] << endl; // 從記憶體取出執行結果，輸出
}
/*
功能逐步新增摘要：
if條件判斷功能：
根據if的condition來決定是否執行statement程式碼，因此不能首先對其所有的孩子進行後續遍歷，需要根據第一個孩子的執行結果來決定是否執行第二個孩子。
while迴圈功能：
此功能框架程式碼與if功能相似，只是多了一個while迴圈而已
變數賦值：
讀取使用者輸入，並賦值到變數，支援input(a)，它將使用者的輸入賦值到變數a，a為其第一個孩子。
賦值語句：
支援a=2，包括兩個孩子，左邊為變數，右邊為值，當前值為左邊的值。
輸入功能：
能夠接收使用者輸入，並賦值到變數中，前提需要增加賦值功能
輸出功能：
構建輸出語句，它只有一個孩子，即要輸出的變數。
*/
void tree::recursive_execute(Node *t)
{
if (t) {
if(t->kind == STMT_NODE){
if(t->kind_kind == IF_STMT){
//if條件判斷結果，第二個孩子儲存if成功的程式碼，第三個孩子儲存else成功的程式碼
recursive_execute(t->children[0]);
if (my_mem[t->children[0]->addr] )
recursive_execute(t->children[1]);
else
recursive_execute(t->children[2]);
}else if(t->kind_kind == WHILE_STMT){
//第一個孩子儲存條件判斷結果，第二個孩子儲存while成功的程式碼
recursive_execute(t->children[0]);
while (my_mem[t->children[0]->addr])
{
recursive_execute(t->children[1]);
recursive_execute(t->children[0]);
}
}else if(t->kind_kind == INPUT_STMT){//input statement has one expr child
cout<<"please input data:";
cin>>my_mem[t->children[0]->addr];
}else if(t->kind_kind == PRINT_STMT){//print statement has one expr child to print.
recursive_execute(t->children[0]);
cout<<my_mem[t->children[0]->addr];
}else if(t->kind_kind == COMP_STMT){//組合語句，逐個語句執行即可。
for (int i = 0; i < MAX_CHILDREN; ++i)
recursive_execute(t->children[i]);
}else if(t->kind_kind == EXPR_STMT){
recursive_execute(t->children[0]);
}
}
if (t->kind == EXPR_NODE){ // 表示式結點
recursive_execute(t->children[0]);
recursive_execute(t->children[1]);
if (t->kind_kind == OP_EXPR) { // 運算型別表示式
if (t->attr.op == PLUS) // 加法表示式
// 從記憶體（my_mem）中取出兩個孩子的值，進行加法，結果寫回記憶體
my_mem[t->addr] = my_mem[t->children[0]->addr] + my_mem[t->children[1]->addr];
else if (t->attr.op == MINUS) // 減法的處理類似加法
my_mem[t->addr] = my_mem[t->children[0]->addr] - my_mem[t->children[1]->addr];
else if (t->attr.op == TIMES)
my_mem[t->addr] = my_mem[t->children[0]->addr] * my_mem[t->children[1]->addr];
else if (t->attr.op == OVER){
if(my_mem[t->children[1]->addr] == 0){
cout<<"error: divide by zero"<<endl;
my_mem[t->addr] = 0;
}else{
my_mem[t->addr] = my_mem[t->children[0]->addr] / my_mem[t->children[1]->addr];
}
}
else if (t->attr.op == AND)
my_mem[t->addr] = my_mem[t->children[0]->addr] && my_mem[t->children[1]->addr];
else if (t->attr.op == OR)
my_mem[t->addr] = my_mem[t->children[0]->addr] || my_mem[t->children[1]->addr];
else if (t->attr.op == EQ)
my_mem[t->addr] = (my_mem[t->children[0]->addr] == my_mem[t->children[1]->addr]);
else if (t->attr.op == GT)
my_mem[t->addr] = my_mem[t->children[0]->addr] > my_mem[t->children[1]->addr];
else if (t->attr.op == LT)
my_mem[t->addr] = (my_mem[t->children[0]->addr] < my_mem[t->children[1]->addr]);
else if (t->attr.op == NE)
my_mem[t->addr] = !(my_mem[t->children[0]->addr] == my_mem[t->children[1]->addr]);
else if (t->attr.op == GE)
my_mem[t->addr] = (my_mem[t->children[0]->addr] > my_mem[t->children[1]->addr]) || (my_mem[t->children[0]->addr] == my_mem[t->children[1]->addr]);
else if (t->attr.op == LE)
my_mem[t->addr] = (my_mem[t->children[0]->addr] < my_mem[t->children[1]->addr]) || (my_mem[t->children[0]->addr] == my_mem[t->children[1]->addr]);
else if(t->attr.op == ASSIGN){
my_mem[t->addr] = my_mem[t->children[0]->addr] = my_mem[t->children[1]->addr];
}
}
else if (t->kind_kind == CONST_EXPR) // 常量表示式，將值（在vali中）儲存至分配的記憶體中
my_mem[t->addr] = t->attr.vali;
else if(t->kind_kind == ID_EXPR){
//do nothing
}
}//EXPR_NODE
}
}
/*
if: st_if -> (condition, action)
while: st_while->(condition, action)
*/
void basicTest()
{
tree expr;
Node *p, *q, *r;
// 建立結點a
p = expr.NewRoot(EXPR_NODE, CONST_EXPR, NodeAttr(9), Integer);
// 建立結點5
q = expr.NewRoot(EXPR_NODE, CONST_EXPR, NodeAttr(5), Integer);
// 建立減法結點，孩子結點為9和5
r = expr.NewRoot(EXPR_NODE, OP_EXPR, NodeAttr(MINUS), Integer, p, q);
// q = expr.NewRoot(EXPR_NODE, CONST_EXPR, NodeAttr(2), Integer);
// p = expr.NewRoot(EXPR_NODE, OP_EXPR, NodeAttr(PLUS), Integer, r, q);
expr.setRoot(r);
expr.get_addr(); // 為（子）表示式（們）分配儲存空間
expr.execute(); // 執行程式碼
}
void assignTest()
{
/*
a = 1
output(a)
兩個語句
*/
tree expr;
Node *p, *q, *r, *s, *o, *u, *t;
//構建賦值語句
// 建立結點a
p = expr.NewRoot(EXPR_NODE, ID_EXPR, NodeAttr(0), Integer);
// 建立結點1
q = expr.NewRoot(EXPR_NODE, CONST_EXPR, NodeAttr(5), Integer);
//賦值
r = expr.NewRoot(EXPR_NODE, OP_EXPR, NodeAttr(ASSIGN), Integer, p, q);
s = expr.NewRoot(STMT_NODE, EXPR_STMT, NodeAttr(0), Integer, r);//賦值語句：孩子賦值表示式
//構建輸出語句
t = expr.NewRoot(STMT_NODE, PRINT_STMT, NodeAttr(), Integer, p);
//構建組合語句
o = expr.NewRoot(STMT_NODE, COMP_STMT, NodeAttr(), Integer, s, t);
expr.setRoot(o);
expr.get_addr(); // 為（子）表示式（們）分配儲存空間
expr.execute(); // 執行程式碼
cout<<endl;
}
Node* createOpExpr(tree& expr, Node* p, Node* q, int type)
{
Node* p1;
p1 = expr.NewRoot(EXPR_NODE, OP_EXPR, NodeAttr(type), Integer, p,q);
return p1;
}
Node* createId(tree& expr)
{
Node* p;
p = expr.NewRoot(EXPR_NODE, ID_EXPR, NodeAttr(0), Integer);
return p;
}
Node* createConst(tree& expr, double value)
{
Node* q2;
q2 = expr.NewRoot(EXPR_NODE, CONST_EXPR, NodeAttr(value), Integer);
return q2;
}
Node* createSTMT(tree& expr, int type, Node* p1, Node* p2=NULL, Node* p3 = NULL, Node* p4=NULL)
{
Node* r;
r = expr.NewRoot(STMT_NODE, type, NodeAttr(), Integer, p1,p2,p3,p4);
return r;
}
Node* createIfStmt(tree& expr,Node* p1, Node* p2, Node* p3 = NULL )
{
return createSTMT(expr, IF_STMT, p1, p2, p3);
}
Node* createWhileStmt(tree& expr, Node* p1, Node* p2)
{
return createSTMT(expr, WHILE_STMT, p1, p2);
}
Node* createInputStmt(tree& expr, Node* p)
{
return createSTMT(expr, INPUT_STMT, p);
}
Node* createOutStmt(tree& expr, Node* p)
{
return createSTMT(expr, PRINT_STMT, p);
}
Node* createExprStmt(tree& expr, Node* p)
{
return expr.NewRoot(STMT_NODE, EXPR_STMT, NodeAttr(0), Integer, p);//xxxx; xxxx為表示式，組合成語句
}
Node* createAssignStmt(tree& expr, Node* variable, int value)
{
Node* p = variable;
Node *q, *r, *s;
q = createConst(expr, value);
r = createOpExpr(expr, p,q, ASSIGN);
return createExprStmt(expr, r);
}
Node* createAssignStmt(tree& expr, Node* variable, Node* q)
{
Node* p = variable;
Node *r, *s;
r = createOpExpr(expr, p,q, ASSIGN);
return createExprStmt(expr, r);
}
Node* createCompStmt(tree& expr, Node* p1, Node* p2=NULL, Node* p3 = NULL, Node* p4=NULL)
{
return createSTMT(expr, COMP_STMT, p1,p2,p3,p4);
}
void executeTree(tree& expr, Node* root)
{
expr.setRoot(root);
expr.get_addr(); // 為（子）表示式（們）分配儲存空間
expr.execute(); // 執行程式碼
cout<<endl;
}
void inputOutTest()
{
/*
input(a)
output(a)
*/
tree expr;
Node *p, *q, *r, *s, *o, *u, *t;
//輸入語句
// 建立結點a
p = expr.NewRoot(EXPR_NODE, ID_EXPR, NodeAttr(0), Integer);
s = createInputStmt(expr, p);
q = createOutStmt(expr, p);
o = createCompStmt(expr, s, q);
executeTree(expr, o);
}
void ifTest()
{
/*
a = 1
if(a>10){
a = 11
}else{
a = 7
}
print(a)
*/
tree expr;
Node *p, *q, *r, *s, *o, *u, *t;
//輸入語句
// 建立結點a
p = expr.NewRoot(EXPR_NODE, ID_EXPR, NodeAttr(0), Integer);
s = createAssignStmt(expr, p, 1);//a=1
//if語句
q = createOpExpr(expr, p, createConst(expr, 10), GT);//a>10
r = createIfStmt(expr, q, createAssignStmt(expr, p, 11), createAssignStmt(expr, p, 7));//if(a>10) a=11 else a=7
//構建輸出語句
t = createOutStmt(expr, p);//print(a)
//構建組合語句
o = createCompStmt(expr,s ,r, t );
executeTree(expr , o);
}
void whileTest()
{
/*
a =1
sum = 0
while(a <= 10){
sum = sum + a
a = a+1;
}
print(sum)
*/
tree expr;
Node *p, *q, *r, *s, *o, *u, *t,*p1,*q1;
p = createId(expr);//a
q = createId(expr);//sum
p1 = createAssignStmt(expr,p, 1);//a=1
q1 = createAssignStmt(expr, q, 0);//sum=0
Node *a, *b, *c, *d, *e, *f, *g;
a = createOpExpr(expr, p, createConst(expr, 10), LE);//a<=10
b = createOpExpr(expr, p, q, PLUS);//sum+a
c = createAssignStmt(expr, q, b);//sum = sum+a
d = createOpExpr(expr, p, createConst(expr, 1), PLUS);
e = createAssignStmt(expr, p, d); //a=a+1
f = createCompStmt(expr, c, e); //{sum = sum+a, a= a+1}
r = createWhileStmt(expr, a, f);//while
t = createOutStmt(expr, q);//print sum
o = createCompStmt(expr, p1, q1, r, t);
executeTree(expr, o);
}
void whileInputTest()
{
/*
a = 1
sum = 0
input(x)
while(a <= x){
sum = sum + a
a = a+1;
}
print(sum)
*/
tree expr;
Node *p, *q, *r, *s, *o, *u, *t,*p1,*q1;
p = createId(expr);//a
q = createId(expr);//sum
p1 = createAssignStmt(expr, p, 1);//a=1
q1 = createAssignStmt(expr, q, 0);//sum=0
Node *a, *b, *c, *d, *e, *f, *g;
g = createId(expr);//x
f = createInputStmt(expr,g);
u = createCompStmt(expr, p1, q1, f);//first 3 sentences. because Comp not support more than 4 children.
a = createOpExpr(expr, p, g, LE);//a<=x, x from input
b = createOpExpr(expr, p, q, PLUS);//sum+a
c = createAssignStmt(expr, q, b);//sum = sum+a
d = createOpExpr(expr, p, createConst(expr, 1), PLUS);
e = createAssignStmt(expr, p, d); //a=a+1
f = createCompStmt(expr, c, e); //{sum = sum+a, a= a+1}
r = createWhileStmt(expr, a, f);//while
t = createOutStmt(expr, q);//print sum
o = createCompStmt(expr, u, r, t);
executeTree(expr, o);
}
int main(int argc, char *argv[])
{
//assignTest();
//inputOutTest();
//ifTest();
//whileTest();
whileInputTest();
}
實現效果
最後放上一個支援使用者輸入的while迴圈，它支援使用者手動輸入一個值x，然後程式會計算1+2+…+x的結果，並列印輸出。它對應的c語言程式碼如下：
a = 1
sum = 0
input(x)
while(a <= x){
sum = sum + a
a = a+1;
}
print(sum)
效果：
相關文章
- 小白說編譯原理-9-最簡單minus-c語言編譯器編譯原理C語言
- 小白說編譯原理-7-算術表示式編譯樹(支撐類)編譯原理
- C語言編譯過程簡介C語言編譯
- javascript編寫一個簡單的編譯器(理解抽象語法樹AST)JavaScript編譯抽象語法樹AST
- 現代編譯原理C語言描述pdf編譯原理C語言
- C語言編譯工具C語言編譯
- java編譯、編碼、語言設定Java編譯
- Android-NDK-11-C語言編譯原理AndroidC語言編譯原理
- Go編譯原理系列5（抽象語法樹構建）Go編譯原理抽象語法樹
- Go 語言編譯期斷言Go編譯
- 源語言、目標語言、翻譯器、編譯器、直譯器編譯
- 編譯原理編譯原理
- 【編譯原理】語法分析（三）編譯原理語法分析
- 淺談，C語言編譯原理的個人見解C語言編譯原理
- gcc 從語言編譯全過程 預處理---->編譯---->彙編----->連結GC編譯
- C語言編譯和連結過程簡介C語言編譯
- 編譯型語言與解釋型語言編譯
- go語言編譯過程概述Go編譯
- Go語言交叉編譯工具goxGo編譯
- c語言多檔案編譯C語言編譯
- C語言編譯全過程C語言編譯
- Flutter 編譯原理Flutter編譯原理
- 編譯原理概述編譯原理
- Java 實現《編譯原理》簡單詞法分析功能Java編譯原理詞法分析
- 深入淺出編譯原理-1-C語言的文法編譯原理C語言
- 說說 方舟編譯器編譯
- 解釋型語言、編譯型語言 區別編譯
- javascript編寫一個簡單的編譯器JavaScript編譯
- Go編譯原理系列4（語法分析）Go編譯原理語法分析
- 編譯原理實驗2：語法分析編譯原理語法分析
- 編譯原理 START 龍虎鯨書簡介編譯原理
- 小C語言--詞法分析程式（編譯原理實驗一）C語言詞法分析編譯原理
- 使用 Sublime Text 3 編譯 C 語言編譯
- C語言編譯器手機版C語言編譯
- 3- C語言編譯過程C語言編譯
- Typescript編譯原理（一）TypeScript編譯原理
- 編譯原理概覽編譯原理
- Vue 模板編譯原理Vue編譯原理