小白說編譯原理-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)
效果:
相關文章
- 現代編譯原理C語言描述pdf編譯原理C語言
- Android-NDK-11-C語言編譯原理AndroidC語言編譯原理
- 源語言、目標語言、翻譯器、編譯器、直譯器編譯
- Go編譯原理系列5(抽象語法樹構建)Go編譯原理抽象語法樹
- C語言 - 條件編譯C語言編譯
- 編譯原理編譯原理
- C語言編譯和連結過程簡介C語言編譯
- 編譯型語言與解釋型語言編譯
- c語言多檔案編譯C語言編譯
- Go語言交叉編譯工具goxGo編譯
- go語言編譯過程概述Go編譯
- Flutter 編譯原理Flutter編譯原理
- 淺談,C語言編譯原理的個人見解C語言編譯原理
- Java 實現《編譯原理》簡單詞法分析功能Java編譯原理詞法分析
- 說說 方舟編譯器編譯
- 解釋型語言、編譯型語言 區別編譯
- 使用 Sublime Text 3 編譯 C 語言編譯
- 3- C語言編譯過程C語言編譯
- C語言編譯器手機版C語言編譯
- Go編譯原理系列4(語法分析)Go編譯原理語法分析
- 編譯程式(compiler)的簡單分析編譯Compile
- 小C語言--詞法分析程式(編譯原理實驗一)C語言詞法分析編譯原理
- Go編譯器簡介【譯】Go編譯
- 【譯】Ruby2.6的JIT功能,編譯和解釋型語言的相關說明編譯
- Typescript編譯原理(一)TypeScript編譯原理
- Vue 模板編譯原理Vue編譯原理
- 編譯原理概覽編譯原理
- Python 既是解釋型語言,也是編譯型語言Python編譯
- Linux下C語言編譯的問題LinuxC語言編譯
- 【C語言】linux下多檔案編譯C語言Linux編譯
- C語言-->(十四)結構體、巨集、編譯C語言結構體編譯
- 【編譯原理】手工打造語法分析器編譯原理語法分析
- 編譯原理之語法分析-自下而上分析(四)編譯原理語法分析
- 編譯原理之語法分析-自下而上分析(三)編譯原理語法分析
- 程式語言和編譯器書單(1)編譯
- 精讀《手寫 SQL 編譯器 - 語法樹》SQL編譯
- 模板函式編譯原理函式編譯原理
- 編譯原理實戰入門:用 JavaScript 寫一個簡單的四則運算編譯器(修訂版)編譯原理JavaScript
- CSS預編譯語言Less的用法總結CSS編譯