C语言编译器设计与实现毕业论文设计(8)

2019-01-10 10:19

{ decalration_list.nodeInfo=declaration.nodeInfo}

16 decalration_list -> decalration_list declaration

{ decalration_list .nodeInfo.code=declaration_list.nodeInfo.code||declaration.nodeInfo.code}

17 statement_list -> statement

{ statement_list .nodeInfo = statement.nodeInfo}

18 statement_list -> statement_list statement

{ statement_list.nodeInfo.code = statement_list.nodeInfo.code+statement.nodeInfo.code}

19 statement -> compound_statement

{statement.nodeInfo=compound_statement.nodeInfo}

20 statement -> expression_statement

{statement.nodeInfo=expression_statement.nodeInfo}

21 statement -> selection_statement M

{statement.nodeInfo=selection_statement.nodeInfo,

backpatch(selection_statement.nodeInfo.nextlist, M.nodeInfo.instr)}//回填选择跳转出口 {statement.nodeInfo=iteration_statement.nodeInfo

backpatch(iteration_statement.nodeInfo.nextlist, M.nodeInfo.nextlist)} //回填循环跳转出口

23 statement -> jump_statement

{statement.nodeInfo=jump_statement.nodeInfo}

24 expression_statement -> ;

{statement.nodeInfo.code=null}

25 expression_statement -> expression ;

{expression_statement.nodeInfo=expression.nodeInfo}

26 expression -> assignment_expression

{expression.nodeInfo=assignment_expression.nodeInfo}

27 assignment_expression -> primary_expression = assignment_expression

{assignment_expression.nodeInfo.addr=new Temp()

assignment_expression.nodeInfo.code=primary_expression.nodeInfo.code

||assignment_expression.nodeInfo.code|| gen(assignment_expression.nodeInfo.addr,“=”, primary_expression.nodeInfo.addr, “=”assignment_expression.nodeInfo.addr) assignment_expression.nodeInfo.nextlist=nextInstr;

28 assignment_expression -> logical_or_expression

{ assignment_expression .nodeInfo=logical_or_expression.nodeInfo}

29 logical_or_expression -> logical_or_expression || M logical_and_expression

{ logical_or_expression.nodeInfo.addr=new Temp();

logial_or_expression.nodeInfo.truelist=merge(logical_or_expression.nodeInfo.truelist, logical_and_expression.nodeInfo.truelist);

logial_or_expression.nodeInfo.falselist= logial_and_expression.nodeInfo.falselist; logical_or_expression.nodeInfo.code=logical_or_expression.nodeInfo.code ||logical_and_expression.nodeInfo.code;

logical_or_expression.nodeInfo.nextlist=nextInstr;

backpatch(logical_or_expression.nodeInfo.falselist, M.instr)} //回填布尔表达式假出口 30 logical_or_expression -> logical_and_expression

22 statement -> iteration_statement M

{ logical_or_expression.nodeInfo =logical_and_expression.nodeInfo} { logical_and_expression.nodeInfo.addr=new Temp();

logical_and_expression.nodeInfo .truelist=equality_expression.nodeInfo.truelist; logical_and_expression.nodeInfo.falselist=merge(logical_and_expression.nodeInfo.false, equality_expression.nodeInfo.falselist);

logical_and_expression.nodeInfo.nextlist=nextInstr; logical_and_expression.nodeInfo.code

= logical_and_expression.nodeInfo.code||equality_expression.nodeInfo.code;

backpatch(logical_and_expression.nodeInfo.truelist, M.instr)} //回填布尔表达式真出口

31 logical_and_expression -> logical_and_expression && M equality_expression

32 logical_and_expression -> equality_expression

{ logical_and_expression.nodeInfo = equality_expression.nodeInfo} { equality_expression.nodeInfo.addr=new Temp(); equality_expression.nodeInfo.truelist=nextInstr; equality_expression.nodeInfo.falselist=nextInstr+1; equality_expression.nodeInfo.code =

equality_expression.nodeInfo.code || relational_expression .nodeInfo.code

|| gen(“goto-”, equality_expression.nodeInfo.addr, “==”, relational_expression.nodeInfo.addr) || gen(“goto-”)}

34 equality_expression -> relational_expression

{ equality_expression.nodeInfo = relational_expression.nodeInfo} { relational_expression.nodeInfo.addr=new Temp(); relational_expression.nodeInfo .truelist=nextInstr; relational_expression.nodeInfo.falselist=nextInstr+1; relational_expression.nodeInfo .nodeInfo.code=

relational_expression .nodeInfo.code || additive_expression.nodeInfo.code || gen(“goto-”, relational_expression ,“<”,additive_expression ) || gen(“goto-”)}

36 relational_expression -> relational_expression > additive_expression

{ relational_expression.nodeInfo.addr=new Temp(); relational_expression.nodeInfo .truelist=nextInstr; relational_expression.nodeInfo.falselist=nextInstr+1; relational_expression.nodeInfo .nodeInfo.code=

relational_expression .nodeInfo.code || additive_expression.nodeInfo.code || gen(“goto-”, relational_expression ,“>”,additive_expression ) || gen(“goto-”)}

37 relational_expression -> relational_expression <= additive_expression

33 equality_expression -> equality_expression == relational_expression

35 relational_expression -> relational_expression < additive_expression

relational_expression .nodeInfo.code || additive_expression.nodeInfo.code || gen(“goto-”, relational_expression ,“<=”,additive_expression ) || gen(“goto-”)}

38 relational_expression -> relational_expression >= additive_expression

relational_expression .nodeInfo.code || additive_expression.nodeInfo.code || gen(“goto-”, relational_expression ,“>=”,additive_expression ) || gen(“goto-”)}

39 relational_expression -> additive_expression

{ relational_expression.nodeInfo = additive_expression.nodeInfo} { additive_expression .nodeInfo.addr=new Temp();

additive_expression.nodeInfo.code= additive_expression.nodeInfo.code || multiplicative_expression.nodeInfo.code

|| gen(additive_expression.nodeInfo.addr, “=”, additive_expression.nodeInfo.addr, “-”, multiplicative_expression.nodeInfo.addr) additiove_expression.nodeInfo.nextlist=nextInstr}

41 additive_expression -> additive_expression + multiplicative_expression

{ additive_expression .nodeInfo.addr=new Temp();

additive_expression.nodeInfo.code= additive_expression.nodeInfo.code || multiplicative_expression.nodeInfo.code

|| gen(additive_expression.nodeInfo.addr, “=”, additive_expression.nodeInfo.addr, “+”, multiplicative_expression.nodeInfo.addr) additiove_expression.nodeInfo.nextlist=nextInstr}

42 additive_expression -> multiplicative_expression

{ additive_expression .nodeInfo=multiplicative_expression.nodeInfo} { multiplicative_expression .nodeInfo.addr=new Temp();

multiplicative_expression.nodeInfo.code= multiplicative_expression.nodeInfo.code || primary_expression.nodeInfo.code

|| gen(multiplicative_expression.nodeInfo.addr, “=”, multiplicative_expression.nodeInfo.addr, “*”, primary_expression.nodeInfo.addr)

multiplicative_expression.nodeInfo.nextlist=nextInstr}

44 multiplicative_expression -> multiplicative_expression / primary_expression

{ multiplicative_expression .nodeInfo.addr=new Temp();

multiplicative_expression.nodeInfo.code= multiplicative_expression.nodeInfo.code || primary_expression.nodeInfo.code

|| gen(multiplicative_expression.nodeInfo.addr, “=”, multiplicative_expression.nodeInfo.addr, “/”, primary_expression.nodeInfo.addr)

multiplicative_expression.nodeInfo.nextlist=nextInstr}

40 additive_expression -> additive_expression - multiplicative_expression

43 multiplicative_expression -> multiplicative_expression * primary_expression

45 multiplicative_expression -> multiplicative_expression % primary_expression

{ multiplicative_expression .nodeInfo.addr=new Temp();

multiplicative_expression.nodeInfo.code= multiplicative_expression.nodeInfo.code || primary_expression.nodeInfo.code

|| gen(multiplicative_expression.nodeInfo.addr, “=”, multiplicative_expression.nodeInfo.addr, “%”, primary_expression.nodeInfo.addr)

multiplicative_expression.nodeInfo.nextlist=nextInstr}

46 multiplicative_expression -> primary_expression

{ multiplicative_expression.nodeInfo= primary_expression.nodeInfo} { primary_expression.nodeInfo= id.nodeInfo; primary_expression.nodeInfo.nextlist=nextInstr}

48 primary_expression -> double_num

{ primary_expression.nodeInfo= double_num.nodeInfo; primary_expression.nodeInfo.nextlist=nextInstr}

49 primary_expression -> int_num

{ primary_expression.nodeInfo= int_num.nodeInfo; primary_expression.nodeInfo.nextlist=nextInstr}

50 primary_expression -> ( expression )

{ primary_expression.nodeInfo= expression.nodeInfo} {

selection_statement

.nodeInfo.nextlist=merge(expression.nodeInfo.nextlist,

51 selection_statement -> if ( expression ) M statement statement.nodeInfo.nextlist);

selection_statement .nodeInfo.code = expression .nodeInfo.code||statement.nodeInfo.code; backpatch(expression.nodeInfo.truelist, M.instr)}

//回填if表达式真出口

52 iteration_statement -> while ( M1 expression ) M2 statement

{ iteration_statement .code = while.nodeInfo.code||statement.nodeInfo.code || gen(“goto ” M2.instr);

backpatch(statement.nodeInfo.nextlist, M1.instr); backpatch(expression.nodeInfo.truelist, M1.instr);

53 jump_statement -> continue ;

{ jump_statement.nodeInfo=continue.nodeInfo} { jump_statement.nodeInfo=break.nodeInfo } { jump_statement.nodeInfo=return.nodeInfo } { jump_statement.nodeInfo=expresion.nodeInfo} {M.nodeInfo.nextlist=nextInstr}

54 jump_statement -> break ; 55 jump_statement -> return ;

56 jump_statement -> return expression ; 57 M -> e

//回填statement的跳转出口 //回填expression的真出口

47 primary_expression -> id

iteration_statement .nodeInfo.nextlist=expression.nodeInfo.falselist;}

在词法分析总控程序分析的时候同步进行语义分析，语义的分析按每一个产生式的语义指导定义。

4.4 中间代码生成阶段

4.4.1 概述

中间代码生成是本实验编译器的最后的必需阶段——用来生成针对特定的目标代码。这个目标代码是源代码语义的忠实体现。

本实验采取三地址格式的四元式来表示中间代码。四元式是一种更接近于目标代码的中间语言形式。由于这种形式的中间语言便于优化处理（虽然本实验不做优化处理，但考虑到扩展性），因此是一种普遍采用的中间代码形式。

四元式实际上是一种“三地址语句”的等价表示。四元式的四个组成部分是：算符op，第一和第二分量arg1和arg2，以及运算结果result。运算分量和运算救过十指用户自定义的变量，又是指编译程序引进的临时变量。如果op是一个算术或逻辑运算符，则result总是一个引进的临时变量，用来存放运算结果。它的一般形式为：

（op，arg1，arg2，result）。

其中包括两个运算分量的地址个结果地址，所以也称为“三地址代码”。需要指出的是，每个四元式只能有一个运算符，所以一个复杂的表达式须由多个四元式构成的序列来表示。

4.5 C编译器的使用方法及测试

4.5.1 使用方法

1．在某种编辑器（如记事本）中输入源程序并保存为“test1.c”文件； 2．编译运行本实验“解决方案“；

3．程序会对test1.c逐行进行扫描分析，如果源程序无错误，C编译器将输出编译成功的信息，并打印test1.c源程序的中间代码 4.5.2 测试源文件

测试文件test1.c的源程序： int main() {

int a; int b; a = 1; b = 2;

a = (a+b*100+a/b)*5; if (a

共8页:

C语言编译器设计与实现毕业论文设计(8).doc 将本文的Word文档下载到电脑下载失败或者文档不完整，请联系客服人员解决！

下载这篇word文档