支撑数c语言,小白说编译原理-8-简单minus-c语言编译树(支撑类)

最新推荐文章于 2024-04-11 19:57:42 发布
最新推荐文章于 2024-04-11 19:57:42 发布
阅读量813 收藏 1
点赞数
文章标签： 支撑数c语言

前言

这个编译原理是一个系列，系列地址为： https://blog..net/lpstudy/article/category/937055

考虑到很多小伙伴咨询代码的问题，现把链接发出来：https://github.com/lpstudy/compile

这个链接里面具有这个系列所有的VS工程和代码，工程是按照系列中的一个教程环境配置6来配置的，不过lib我好像没有上传到github。

如果大家发现任何问题，可以在github或者，我有空的时候完善一下，争取做到下载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}

9ef3a7ab6d966ee6662556d10a41720c.png

对于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<

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<children[0]->addr];

}

复合语句

复合语句是用来包装多个简单语句的，例如如果有3个语句，它们之间是顺序执行的关系，但是最后生成是一棵树，因此需要将3个语句组合在一起，简单来说就是将这3个语句的Node作为一个复合语句Node的孩子，当遍历执行的时候，只需要逐个执行每一个孩子即可。

7c5031eb14f6250e1da118fa89d3de44.png

代码如下：

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<

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的函数，并不需要关注其具体实现也可以读懂上面的构建代码。

首先创建两个变量，然后创建两个赋值语句p1p1p1, q1q1q1，随后创建while语句rrr和print语句ttt，最后将444个语句组装成一个组合语句ooo并将ooo作为语法树的根，启动execute执行。

实现代码

考虑到便于大家自己扩充，我将我自己扩充的版本放在这里，大家可以根据自己的想法继续扩充，例如实现多种一元运算符，实现for循环等等。大家将下面的代码直接粘贴到vs工程中，编译就可以执行。注意main函数中有多种test，可以专注于某一种情况的测试。

#include

#include

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<

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<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<

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<

}

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<

}

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)

效果：

32d5a36145d91e86204f81404ccf5775.png

weixin_39623750
关注
图的应用 最小支撑树 ----c语言
weixin_53272394的博客
07-29 1112
Prim算法 普里姆算法(Prim算法)，图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点(英语:Vertex (graph theory))，且其所有边的权值之和亦为最小。 假设V是图中顶点的集合，E是图中边的集合，TE为最小生成树中的边的集合，则prim算法通过以下步骤可以得到最小生成树： 1：初始化：U={u 0},TE={f}。此步骤设立一个只有结点u 0的结点集U和一个空的边集TE作为最小生成树的初始形态，在随后的算法执行
小白说编译原理-8-简单minus-c语言编译树(支撑类)
字节跳动 内推找我
05-07 4773
简介本章在上一节7的基础上对编译树进行完善。 上一节7的编译树仅仅支持算术表达式的+-基本运算，本节对其进行扩充，使其支持不仅支持基本的算术运算，还支持变量，支持语句(if, while,input, ouput)，经过这次扩充，它形成的语法树已经基本具备了表达minus-c语言的能力。简单说来，它可以表示下面的c语言代码：a = 1 if(a>10){ a = 11 }else{ a =
支撑数c语言,C语言复习（一） - osc_91g5cdgs的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_39605278的博客
05-19 1179
一. 什么是C语言C语言是一种计算机编程语言(人和计算机交流的语言)。国家标准：ANSIC-C89/C90。二. 第一个C语言程序使用V2013软件操作1.新建空项目 2.在源文件下新建.c文件，并输入以下程序：#include int main(){printf("hello world\n");return 0;}3.右击工程名进入属性，修改子系统为控制台模式 4.运行按ctrl+F5运行，结...
支撑数c语言,用C语言实现常见的三种中文内码转换
weixin_39671467的博客
05-19 558
常见的中文内码一般有GB2312(简体中文)，GBK和台湾那边用的BIG5(繁体中文)，有时候看一些台湾编程论坛里的资料，都是乱码，如果在IE中浏览，则要求安装繁体字库的支持。网上也有很多中文内码的转换工具，什么专家，大师，巨匠之类所有光辉灿烂的名字都被使用了，但是在自己的程序中集成这些功能岂不是更好。以前曾广泛流传过使用码表来转换中文内码的Code，但毕竟不完美，而且还要携带或内置一个巨大的表，...
C++找支撑数
最新发布
m0_72914941的博客
04-11 414
题目描述在已知一组整数中，有这样一种数非常怪，它们不在第一个，也不在最后一个，而且刚好都比左边和右边相邻的数大，你能找到它们吗？输入第一行为整数 �m，表示输入的整数个数。第二行为 �m 个整数。输出若干个支撑数，每行一个。样例。
支撑数c++
m0_63706031的博客
12-14 4201
在已知一组整数中，有这样一种数非常怪，它们不在第一个，也不在最后一个，而且刚好都比左边和右边相邻的数大，你能找到它们吗？ 输入 第一行为整数m，表示输入的整数个数。（ 3<= m <=100 ) 第二行为m个整数。 输出 若干个支撑数，每行一个。 样例 输入复制 14 1 3 2 4 1 5 3 9 7 10 8 23 85 43 输出复制 3 4 5 9 10 85 #include using namespace std; int main() { int m,a[100],i; cin&g
小白说编译原理-9-最简单minus-c语言编译器
字节跳动 内推找我
05-07 7684
简介继上节8说到利用手动构建的语法树解析下面的c语言代码： a = 1 sum = 0 input(x) while(a <= x){ sum = sum + a a = a+1; } print(sum)而一个编译器不应该依赖用户去手动构建对应语言的语法树，我们需要的是一种支持自动构建语法树的策略。本节将要说明的就是如何利用
C--编译原理
01-20
《C--编译原理详解：构建语法分析树的实践》 C--编译原理是计算机科学中的一个重要领域，它涉及到程序设计语言的处理过程，包括词法分析、语法分析、语义分析以及代码生成等阶段。这个项目的目标是通过使用flex和...
C-Minus编译器 编译原理实验
05-14
参照TINY语法分析器的实现，运用所学知识用C语言或者C++语言实现C-MINUS词法分析器,可输出token，再在词法分析的基础上实现C-MINUS语法分析器，可输出语法树。 本资源是运用自顶向下方法中的递归下降分析方法进行...
小白说编译原理-7-算术表达式编译树(支撑类)
字节跳动 内推找我
05-07 3908
简介本章讲述的是编译树的实现，它包含树节点，树的构建，树的遍历三个部分。利用编译树，我们可以构建基本的运算节点以及数字节点，然后遍历树的过程就是执行算术运算的过程。 例如如下的一棵树 叶子节点和分支节点都是一个个的Node，它具有不同的类型(运算符和数字)。代码如下#include <iostream> #include <malloc.h> using namespace std;#def
【HUSTOJ】1088: 查找“支撑数”
cisordeng's space
05-07 6947
1088: 查找“支撑数” Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 49  Solved: 18 原题链接 Description 在已知一组整数中，有这样一种数非常怪，它们不在第一个，也不在最后一个，而且刚好都比左边和右边相邻的数大，你能找到它们吗？ Input 第一行为
minus用法c语言,Minus-C 一个最小化的C语言规范
weixin_31354669的博客
05-26 545
资深C++程序员都不会对C++编程规范太陌生，C++实在太复杂，以至于所有项目都需要裁剪一个子集共项目组内使用。经过在家休息这一小段时间，我发现其实C语言更需要一个相同的规范，这就是本文的目标，最大可能规避C语言的黑暗面。大体上分成这几个部分1.语言标准和编译器如果我说出建议使用C99和GCC是不是有很多人长叹一口气，不过C99事实只用到了很少一点特性，大部分编译器都支持，比如说//注释。选择GC...
【入门】查找“支撑数”
LYK_0910的博客
03-08 728
时间限制 : 1 秒内存限制 : 128 MB在已知一组整数中，有这样一种数非常怪，它们不在第一个，也不在最后一个，而且刚好都比左边和右边相邻的数大，你能找到它们吗？
编译（树形DP）
weixin_30751947的博客
08-03 82
编译器 【问题描述】 CCF是信奥班的成员，因为喜欢玩Android系统而出名。 CCF写出了一个伟大的C++工程，一共包含N个源文件。在CCF的脑海中，N个源文件构成一个树形结构。每一个源文件是树上的一个节点，其中1号节点是树根。 现在，CCF开始编译这个工程。每次他会从树上选择一条链（包含两个端点）迚行编译。由于编译器的特性，要求这条链的一个端点必须是另一个端点的祖先。一条链可以退化...
查找“支撑数”c++
D_31415926的博客
02-21 735
在已知一组整数中，有这样一种数非常怪，它们不在第一个，也不在最后一个，而且刚好都比左边和右边相邻的数大，你能找到它们吗？第一行为整数m，表示输入的整数个数（3
编译 树形DP
weixin_30814319的博客
10-20 75
[Description]山山是 2017 级信奥班的成员,因为喜欢玩 Android 系统而出名。山山写出了一个伟大的 C++工程,一共包含 N 个源文件。在山山的脑海中,N 个源文件构成一个树形结构。每一个源文件是树上的一个节点,其中 1 号节点是树根。现在,山山开始编译这个工程。每次他会从树上选择一条链(包含两个端点)进行编译。由于编译器的特性,要求这条链的一个端点必须是另一个端点的祖先。一...
用c语言编译二叉树,C语言实现二叉树的基本操作
weixin_39987138的博客
05-19 212
我在前面的博客中解说了链表、栈和队列。这些数据结构事实上都是线性表，而且给出了具体的实现。从今天開始。我们将要来学习树，树作为一种数据结构我们常常会用到，作为起步和基础。我们先来实现二叉树。也就是每一个节点有不超过2个子节点的树。对于树的操作，最主要的创建、遍历、求树高、节点数等。代码上传至 https://github.com/chenyufeng1991/BinaryTree。(1)节点的定...
c语言慕课浙江大学,C语言程序设计CAP
weixin_39717443的博客
05-20 113
“数据结构”是计算机科学与技术专业、软件工程专业甚至于其它电气信息类专业的重要专业基础课程。它所讨论的知识内容和提倡的技术方法，无论对进一步学习计算机领域的其它课程，还是对从事大型信息工程的开发，都是重要而必备的基础。程序设计解决问题往往有多种方法，且不同方法之间的效率可能相差甚远。程序的时间和空间效率，不仅跟数据的组织方式有关，也跟处理流程的巧妙程度有关。本课程将介绍并探讨有关数据组织、算法设计...
深入理解C语言编译原理
"C语言编译原理001，涵盖了编译器的基础概念、结构、相关程序、翻译步骤以及编译器的主要数据结构。通过学习，可以了解编译器的工作原理，掌握编译器设计与实现的核心技术。" C语言编译原理是计算机科学中的一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值