中间代码生成具体实验过程含代码
汇编语言中间代码生成.完整版ppt资料
t1 = b t2 = c d t3 = t1 + t2 t4 = c d t5 = t3 + t4 a = t5
uminus
7.1 中 间 语 言
三地址代码是语法树或dag的一种线性表示
a = (b + cd ) + cd
语法树的代码 dag的代码
t1 = b t2 = c d t3 = t1 + t2 t4 = c d t5 = t3 + t4 a = t5
• 过程调用param x 和call p , n
• 过程返回 return y
• 索引赋值x = y[i]和 x[i] = y
• 地址和指针赋值x = &y，x = y和x = y
7.1 中 间 语 言
赋值语句生成三地址代码的属性文法
产生式
语义规则
S id :=E S.code=E.code || gen(id.place‘=‘ E.place)
语句，但很难用栈来描述它的计算
7.1 中 间 语 言
图形表示 • 语法树是一种图形化的中间表示
assign
a
+
+
uminus c
d
c
d
b (a) 语法树
a = (b + cd ) + cd的图形表示
7.1 中 间 语 言
图形表示
• 抽象语法树是一种图形化的中间表示
• 有向无环图也是一种中间表示
E E1 +E2 E.nptr = mknode( ‘+’, E1.nptr, E2.nptr)
E E1 E2 E.nptr = mknode( ‘’, E1.nptr, E2.nptr)
第7章 语义分析与中间代码生成
(4) 无条件转移语句goto L，即下一个将被执 行的语句是标号为L的语句。 (5) 条件转移语句if x rop y goto L，其中rop为 关系运算符，如<、<=、==、!=、>、>=等。 若x和y满足关系rop就转去执行标号为L的语 句，否则继续按顺序执行本语句的下一条语 句。
(6) 过程调用语句par x和call p,n。源程序中的 过程调用语句p(x1, x2, …, xn)可用下列三地址 代码表示： par x1 par x2 par xn call p,n 其中，整数n为实参个数。 过程返回语句为return y，其中y为返回值， 可选。
{enter(, T.type, offset); offset := offset + T.width} {T.type := int; T.width := 4｝ {T.type := float; T.width := 8} {T.type := array(num.val, T(1).type); T.width := num.val * T(1).width} {T.type := pointer(T(1).type); T.width := 4}
2．三地址语句的种类 三地址语句非常类似于汇编代码，它可以 有符号标号和各种控制流语句。 常用的三地址语句： (1) x = y op z形式的赋值语句，其中op为二目 的算术运算符或逻辑运算符。 (2) x = op y形式的赋值语句，其中op为一目运 算符，如一目减uminus、逻辑否定not、移位 运算符以及类型转换符。 (3) x = y形式的复制语句，将y的值赋给x。
例如，赋值语句a = b * (c + d)的四元式代码： ① (+, c, d, t1) ② (*, b, t1, t2) ③ (=, t2, _, a) 约定：一元运算符一律使用arg1。此外，如果 op是一个算术或逻辑运算符，则result总是一 个新引进的临时变量，它用来存放运算结果。 结论：四元式出现的顺序与表达式计值的顺序 是一致的，四元式之间的联系是通过临时变量 实现的。四元式由于其表示更接近程序设计的 习惯而成为一种普遍采用的中间代码形式。
编译方法实验报告(中间代码生成器)
编译方法实验报告2011年10月一、实验目的熟悉算术表达式的语法分析与中间代码生成原理。
二、实验内容（1）设计语法制导翻译生成表达式的四元式的算法；（2）编写代码并上机调试运行通过。
输入——算术表达式；输出——语法分析结果；相应的四元式序列。
（3）设计LL(1)分析法或LR(0)分析法的属性翻译文法, 并根据这些属性翻译文法, 使用扩展的语法分析器实现语法制导翻译。
三、实验原理及基本步骤●算术表达式文法:G(E): E ( E ω0 T | TT →T ω1 F | FF → i | (E)●文法变换:G’(E) E →T {ω0 T}T →F {ω1 F}F → i | (E)●属性翻译文法:E →T {ω0“push(SYN, w)” T “QUAT”}T →F {ω1“push(SYN, w)” F “QUAT”}F →i “push(SEM, entry(w))” | (E)其中：push(SYN, w) —当前单词w入算符栈SYN;push(SEM, entry(w)) —当前w在符号表中的入口值压入语义栈SEM;QUAT —生成四元式函数i. T = newtemp;ii. QT[j] =( SYN[k], SEM[s-1], SEM[s], T);j++;iii. pop( SYN, _ ); pop( SEM, _ ); pop( SEM, _ );push( SEM, T );●递归下降子程序:数据结构: SYN —算符栈；SEM —语义栈；四、数据结构设计使用递归的结构进行四元式的设计, 同时, 运用堆栈结构将四元式的输出序列打印出来while ( exp[i]=='+' || exp[i]=='-'){syn[++i_syn]=exp[i]; //push(SYN,w)i++; //read(w)T();quat();}while ( exp[i]=='*' || exp[i]=='/'){syn[++i_syn]=exp[i]; //push(SYN,w)i++; //read(w)F();quat();}void quat(){strcpy(qt[j],"(, , , )"); //QT[j]:=(SYN[k],SEM[s-1],SEM[s],temp);qt[j][1]=syn[i_syn];qt[j][3]=sem[i_sem-1];qt[j][5]=sem[i_sem];qt[j][7]=temp;j++;i_syn--; //pop(SYN);i_sem--; //pop(SEM);i_sem--; //pop(SEM);sem[++i_sem]=temp; //push(SEM,temp);temp++;}五、关键代码分析（带注释）及运行结果#include <iostream>#include "string.h"#include "stdio.h"using namespace std;char syn[10]; //文法符号栈int i_syn;char sem[10]; //运算对象栈int i_sem;char exp[50]; //算术表达式区int i;char qt[30][15]; //四元式区int j=0;char temp='q'; //临时变量, 取值为r--zint E();int T();int F();void quat(); //生成四元式函数int main(int argc, char* argv[]){printf("please input your expression:");scanf("%s",exp); //输入四元式i=0; //read(w)E();if (exp[i]=='\0')for (i=0;i<j;i++) //输出四元式序列printf("%s\n",qt[i]);elseprintf("err");return 0;}int E(){T();while ( exp[i]=='+' || exp[i]=='-'){syn[++i_syn]=exp[i]; //push(SYN,w)i++; //read(w)T();quat();}return 1;}int T(){F();while ( exp[i]=='*' || exp[i]=='/'){syn[++i_syn]=exp[i]; //push(SYN,w)i++; //read(w)F();quat();}return 1;}int F(){if ( exp[i]=='('){i++; //read(w)E();if ( exp[i]!=')'){printf("err");return 0;}}else if ((exp[i]>='a' && exp[i]<='p')||(exp[i]>='0' && exp[i]<='9')){ sem[++i_sem]=exp[i]; } //push(SEM,w) else{printf("err");return 0;}i++; //read(w)return 1;}void quat(){strcpy(qt[j],"( , , , )"); //QT[j]:=(SYN[k],SEM[s-1],SEM[s],temp);qt[j][1]=syn[i_syn];qt[j][3]=sem[i_sem-1];qt[j][5]=sem[i_sem];qt[j][7]=temp;j++;i_syn--; //pop(SYN);i_sem--; //pop(SEM);i_sem--; //pop(SEM);sem[++i_sem]=temp; //push(SEM,temp);temp++;}六、总结与分析我们知道, 定义一种语言除了要求定义语法外, 还要求定义语义, 即对语言的各种语法单位赋予具体的意义。
中间代码生成5
S→TS2
19
if B then
x:=2 else y:=4
x:=2 else y:=4 C C.chain=(2);Gen(Jz,T1, ,xxxx)
CS1else y:=4 NXQ
(1) (2)
(3) (4) (5) (6)
y:=4 T T.chain=(4);Gen(J , , ,xxxx); backpatch((2),(5)) TS2 S backpatch((4),(6))
6
5 一些基本操作 •newtemp( ) •gen(操作符,操作数1,操作数2,结果) 产生一临时变量; 填入四元式表;
•fill( i,属性)
•entry( i ) •backpatch( m,n)
填入符号表;
查符号表,返回 i 在符号表中的位置; 把 n 填入 四元式表第 m 个四元式中;
7
第三节
简单变量说明语句的翻译
程序设计中,首先应该对程序中使用的变量进行说明.其目的 是规定变量所占用空间的大小. 编译时, 对变量说明语句的翻译工 作,本质上就是把变量名及属性登记在符号表中,以便后续工作中 使用. pascal 语言的简单变量说明语句为: x,y,z:real; 语法可表示为: 该文法代表了所有 D → NAMELIST:T 非结构型变量的说明语 NAMELIST→ NAMELIST,i | i 句. T → integer|real|boolean|char
*
B为真? F
S1 的四元式
*
S2 的四元式
转移语句;此时,由于S2未处理, 无条件转
移语句的转移地址不确定;回填条件转移语句的地址. (4)归约S2;回填无条件转移语句的地址.
18
汇编语言中间代码生成讲解
表达式x + y z翻译成的三地址语句序列是 t1 = y z t2 = x + t1
7.1 中 间 语 言
三地址代码是抽象语法树或dag的一种线性表示
a = (b + cd ) + cd 抽象语法树的代码
t1 = b t2 = c d t3 = t1 + t2 t4 = c d t5 = t3 + t4 a = t5
7.1 中 间 语 言
赋值语句生成三地址代码的属性文法
产生式
语义规则
S id :=E S.code=E.code || gen(id.place‘=‘ E.place)
E E1 +E2 E E1 E2
E.Place = newtemp;
E.Code = E1.code || E2.code || gen(E.place ‘=‘ E1.place ‘+’ E2.place)
E本身。 • 如果E是形式为E1 opE2的表达式，那么E的后
缀表示是E1 E2 op，其中E1和E2分别是E1和 E2的后缀表示。 • 如果E是形式为(E1)的表达式，那么E1的后缀 表示也是E的后缀表示。
7.1 中 间 语 言
• 后缀表示不需要括号 (8 4) + 2 的后缀表示是8 4 2 +
E.Code = E1.code || E2.code || gen(E.place ‘=‘ E1.place ‘*’ E2.place)
第七章 中间代码生成
本章内容
–介绍几种常用的中间表示：后缀表示、图 形表示和三地址代码
–用语法制导定义和翻译方案的方法来说明 程序设计语言的结构怎样被翻译成中间形式
中间代码生成
• •
6.1.2 后缀表示法 后缀表示是一个语法树的线性化表示。 它是树的结点直接出现在它的子结点之 后。 • 逆波兰表示法是波兰逻辑学家卢卡西 维奇(Lukasiewicz)发明的一种表示表达 式的方法，这种表示法把运算量(操作数) 写在前面，把运算符写在后面，因而又 称后缀表示法。例如，把a+b写成ab+， 把a*(b+c)写成abc+*。
中间代码生成
•
所谓中间代码，是指用中间语言改写了的程序。 当编写一个含有一遍以上扫描的编译程序,则中间 语言就已存在了。我们使用它作为编译程序的遍 与遍之间源文本载体，即作为前一遍的输出及其 随后一遍的输入。 首先,在词法分析之后有一个源文本,它是经过词 法分析处理后的源文本。词法分析程序把标识符、 变量以及语言保留字等长度不等的符号,替换为带 有不同标识的定长符号。因此，在词法分析之后, 源文本可以由一系列定长符号组成，其最简单形 式就是整数,其中某些整数对应于语言字，而其他 表示指向标识符表或常量表的指针，等等。所以, 我们这里所说的中间代码,是在分析阶段最后一遍 产生的中间语言类型。它更接近于机器代码，尽 管它本身与机器无关。
•
其中，t1和t2是编译时产生的临时变量。 三地址代码是语法树的一种线性表示， 如图8–4(a)所示的语法树用三地址代码 表示为： • t1=b*c • t2= a− t1 • x=t2
• 2．三地址语句的种类 • 作为中间语言的三地址语句非常类似 于汇编代码，它可以有符号标号和各种 控制流语句。常用的三地址语句有以下 几种： • (1) x=y op z形式的赋值语句，其中op 为二目的算术运算符或逻辑运算符。 • (2) x=op y形式的赋值语句，其中op为 一目运算符，如一目减uminus、逻辑否 定not、移位运算符以及将定点数转换成 浮点数的类型转换符。
编译原理中间代码生成
编译原理中间代码生成在编译原理中，中间代码生成是编译器的重要阶段之一、在这个阶段，编译器将源代码转换成一种中间表示形式，这种中间表示形式通常比源代码抽象得多，同时又比目标代码具体得多。
中间代码既能够方便地进行优化，又能够方便地转换成目标代码。
为什么需要中间代码呢？其一，中间代码可以方便地进行编译器优化。
编译器优化是编译器的一个核心功能，它能够对中间代码进行优化，以产生更高效的目标代码。
在中间代码生成阶段，编译器可以根据源代码特性进行一些优化，例如常量折叠、公共子表达式消除、循环不变式移动等。
其二，中间代码可以方便地进行目标代码生成。
中间代码通常比较高级，比目标代码更具有表达力。
通过中间代码，编译器可以将源代码转换成与目标机器无关的形式，然后再根据目标机器的特性进行进一步的优化和转换，最终生成目标代码。
中间代码生成的过程通常可以分为以下几步：1.词法分析和语法分析：首先需要将源代码转换成抽象语法树。
这个过程涉及到词法分析和语法分析两个步骤。
词法分析将源代码划分成一个个的词法单元，例如标识符、关键字、运算符等等。
语法分析将词法单元组成树状结构，形成抽象语法树。
2.语义分析：在语义分析阶段，编译器会对抽象语法树进行静态语义检查，以确保源代码符合语言的语义规定。
同时，还会进行类型检查和类型推导等操作。
3.中间代码生成：在中间代码生成阶段，编译器会将抽象语法树转换成一种中间表示形式，例如三地址码、四元式、特定的中间代码形式等。
这种中间表示形式通常比较高级，能够方便进行编译器的优化和转换。
4.中间代码优化：中间代码生成的结果通常不是最优的，因为生成中间代码时考虑的主要是功能的正确性，并没有考虑性能的问题。
在中间代码生成之后，编译器会对中间代码进行各种优化，以产生更高效的代码。
例如常量折叠、循环优化、死代码删除等等。
5.中间代码转换：在完成了中间代码的优化之后，编译器还可以对中间代码进行进一步的转换。
这个转换的目的是将中间代码转换成更具体、更低级的形式，例如目标机器的汇编代码。
编译原理中间代码生成实验报告
竭诚为您提供优质文档/双击可除编译原理中间代码生成实验报告篇一：编译原理-分析中间代码生成程序实验报告课程名称编译原理实验学期至学年第学期学生所在系部年级专业班级学生姓名学号任课教师实验成绩计算机学院制开课实验室：年月日篇二：编译原理实验中间代码生成实验四中间代码生成一．实验目的：掌握中间代码的四种形式（逆波兰式、语法树、三元式、四元式）。
二．实验内容：1、逆波兰式定义:将运算对象写在前面，而把运算符号写在后面。
用这种表示法表示的表达式也称做后缀式。
2、抽象（语法）树：运算对象作为叶子结点，运算符作为内部结点。
3、三元式：形式序号：（op,arg1,arg2）4、四元式：形式（op,arg1,arg2,result）三、以逆波兰式为例的实验设计思想及算法(1)首先构造一个运算符栈，此运算符在栈内遵循越往栈顶优先级越高的原则。
(2)读入一个用中缀表示的简单算术表达式，为方便起见,设该简单算术表达式的右端多加上了优先级最低的特殊符号“#”。
(3)从左至右扫描该算术表达式，从第一个字符开始判断，如果该字符是数字，则分析到该数字串的结束并将该数字串直接输出。
(4)如果不是数字，该字符则是运算符，此时需比较优先关系。
做法如下：将该字符与运算符栈顶的运算符的优先关系相比较。
如果，该字符优先关系高于此运算符栈顶的运算符，则将该运算符入栈。
倘若不是的话，则将此运算符栈顶的运算符从栈中弹出，将该字符入栈。
(5)重复上述操作(1)-(2)直至扫描完整个简单算术表达式，确定所有字符都得到正确处理，我们便可以将中缀式表示的简单算术表达式转化为逆波兰表示的简单算术表达式。
四、程序代码：//这是一个由中缀式生成后缀式的程序#include#include#include#include#definemaxbuffer64voidmain(){chardisplay_out(charout_ch[maxbuffer],charch[32]);//intcaculate_array(charout_ch[32]);staticinti=0;staticintj=0;charch[maxbuffer],s[maxbuffer],out[maxbuffer];cout cin>>ch;for(i=0;i {out[i]=ch[i];}cout while(out[j]!=#)cout j++;}cout display_out(s,out);//caculate_array;}chardisplay_out(charout_ch[32],charch[]) {inttop=-1;inti=0,data[maxbuffer],n;intj=0;charsta[20];while(ch[i]!=#){if(isalnum(ch[i])){while(isalnum(ch[i])){out_ch[j]=ch[i];j++;i++;}out_ch[j]=;j++;else{switch(ch[i]){case+:case-:if(sta[top]==(||top==-1) {top++;sta[top]=ch[i];i++;}else{//j--;out_ch[j]=sta[top];j++;top--;//i++;}break;//break;case*:case/:if(sta[top]==*/) {out_ch[j]=sta[top];j++;//i++;top--;}else{top++;sta[top]=ch[i];i++;}break;//break;case(:top++;sta[top]=ch[i];i++;break;case):if(sta[top]==() {top--;i++;}if(top==-1){//cout }else{//while(sta[top]!=?(?){ out_ch[j]=sta[top];top--;j++;//}break;}break;/*case?#?:out_ch[j]=?#?; j++;break;*/default:cout ch[i]=#;j=0;break;}}}while(top!=-1){out_ch[j]=sta[top];j++;top--;}out_ch[j]=#;n=0;co(:编译原理中间代码生成实验报告)utwhile(out_ch[n]!=#){cout n++;}cout j=0;returnout_ch[maxbuffer];}五、实验结果：要求：自己给出3个测试用例，观察结果。
编译原理中的中间代码生成
编译原理中的中间代码生成编译原理是计算机科学的一门重要课程。
在编译器的构造过程中，中间代码生成是其核心部分之一。
它是将源代码翻译为目标代码的重要中间阶段。
中间代码生成的过程涉及到链表、树，生成三元式、四元式等多种中间形式。
本文将介绍中间代码生成的过程和其在编译中的作用。
一、中间代码的概念中间代码是指在源程序和目标程序之间所生成的一系列指令的集合。
目标代码是指机器可执行的二进制代码，而中间代码则是一种可传递、可处理和可修改的编译代码形式。
中间代码属于一种中间状态，它不是源代码也不是目标代码，但可以被转换成目标代码。
中间代码可以基于语法树、语法分析栈、语法分析表进行生成，生成的中间代码需要满足语言语法结构和语义规则。
二、中间代码生成的流程在编译过程中，中间代码生成是指将源代码转换成中间代码的过程。
它是在词法分析、语法分析和语义分析阶段之后完成的。
下面介绍一下中间代码生成的流程。
1.源代码转换为语法树编译器通过词法分析和语法分析将源代码转换成语法树。
语法树是一种树形结构，它记录了源代码中各个语句的组成情况。
2.语法树进行语义分析在语法分析之后，编译器进行语义分析，检查语法树的合法性，然后根据语言的语义规则对语法树进行标注。
标注的内容包括符号表信息、数据类型等。
3.中间代码的生成在语义分析后，编译器进入中间代码的生成阶段，生成语句的中间代码。
中间代码通常采用三元式或四元式等形式。
三元式包含操作符、操作数以及结果的地址，四元式中还包括了类型信息。
4.中间代码优化在中间代码生成的过程中，编译器会尽可能地优化中间代码。
可以对中间代码进行多种优化，如常量合并、变量替换、公共子表达式消除等。
5.中间代码转换为目标代码在中间代码生成后，编译器将中间代码转换为目标代码。
目标代码可以是汇编代码或机器代码等不同形式的二进制代码。
三、中间代码生成优化的意义编译器中间代码优化的目标是提高程序的执行效率和降低其资源消耗。
执行效率的提高可以通过以下方式实现：1.减少内存使用编译器可以通过删除冗余代码、去除死代码和不必要的变量等方式来减少中间代码的内存使用。
中间代码生成
例子程序： （2）-（19）都 是说明部分
（4） procedure readarray； （ 5） var i ： integer； （ 6） begin … a… end { readarray};
（7） procedure exchange（i，j： integer）； （ 8） begin （ 9） x：= a[i] ；a[i]:=a[j]; a[j]:＝x （10） end { exchange}; （11） procedure quicksort（m，n： integer）； （12） var k，v： integer； （13） function partition（y，z： integer） ： integer； （14） var i，j ： integer； （15） begin …a… （16） …v… （17） …exchange（i，j）；… （18） end { partition}; （19） begin … end { quicksort}; （20） 2019/1/16 begin … end. { sort｝
2019/1/16 12
7.2
说明语句
注意语义动作 enter 对第一条产生式及翻译模式进行改写（见 P474），引入标记非终结符号，改写后的 语法制导定义是 S-属性定义，适合于自底 向上翻译
P M D
M
{}
{ offset := 0 }
13
2019/1/16
7.2
说明语句
例子：处理语句 id1 : real ; id2 : ↑integer
sort readarray exchange quicksort
partition
18
第7章 语义分析与中间代码生成
•
第6章小结
• 注释分析树和相应的依赖图是属性值的关联 关系和计算顺序的表达形式，语义关系可以 使用抽象语法树表示。 依据语法分析方法有自底向上的和自顶向下 的，语法制导翻译既可以按照自底向上的策 略进行，也可以按照自顶向下的策略进行。
•
2013-7-25
3
第7章 语义分析与中间代码生成
第6章小结
• • 语法分析中进行静态语义检查和中间代码生 成的技术称为语法制导翻译技术。 为了通过将语义属性关联到文法符号、将语 义规则关联到产生式，有效地将语法和语义 关联起来，人们引入了语法制导定义。没有 副作用的语法制导定义又称为属性文法。
2013-7-25
1
第6章小结
• 为相应的语法成分设置表示语义的属性，属 性的值是可以计算的，根据属性值计算的关 联关系，将其分成综合属性和继承属性，根 据属性文法中所含的属性将属性文法分成S属性文法和L-属性文法。 如果不仅将语义属性关联到文法符号、将语 义规则关联到产生式，而且还通过将语义动 作嵌入到产生式的适当位置来表达该语义动 作的执行时机，这就是翻译模式。翻译模式 给语义分析的实现提供了更好的支持。
2013-7-25
arg2 result t1 d t2 d t4 t2 t3 t4 t5 a
5 assign
图7.2(a) 图7.1中三地址码的四元式表示
11
三元式
• 为了节省临时变量的开销，有时也可以使用只有三个域的三 元式来表示三地址码。三元式的三个域分别称为op，arg1和 arg2，op，arg1和arg2的含义与四元式类似，区别只是arg1和 arg2可以是某个三元式的编号(图7.2(b)中用圆括号括起来的数 字)，表示用该三元式的运算结果作为运算对象。
编译原理-分析中间代码生成程序
实验报告课程名称编译原理实验学期至学年第学期学生所在系部年级专业班级学生姓名学号任课教师实验成绩计算机学院制开课实验室：年月日实验题目分析中间代码生成程序一、实验目的分析PL/0编译程序的总体结构、代码生成的方法和过程；具体写出一条语句的中间代码生成过程。
二、设备与环境PC兼容机、Windows操作系统、Turbo Pascal软件等。
三、实验内容1.分析PL/0程序的Block子程序，理清PL/0程序结构和语句格式。
画出Block子程序的流程图，写出至少两条PL/0程序语句的语法格式。
2.分析PL/0程序的Block子程序和Gen子程序，了解代码生成的方法和过程。
使用概要算法来描述语句的代码生成过程。
3.自己编写一个简单的PL/0程序，能够正确通过编译，得到中间代码。
列出自己编写的源程序和编译后得到的中间代码。
4.从中选择一个语句或表达式，写出代码生成的过程。
要求从自己的源程序中选择一条语句，结合这条语句写出语义分析和代码生成过程。
在描述这个过程中，要说清楚每个功能有哪个子程序的哪条语句来完成，说清楚语句和参数的含义和功能。
四、实验结果及分析(一)程序标注levmax = 3; { max depth of block nesting } { 最大允许的块嵌套层数}{ 语法分析过程block }{ 参数：lev:这一次语法分析所在的层次}{ tx:符号表指针}{ fsys:用于出错恢复的单词集合}procedure block(lev, tx: integer; fsys: symset);vardx: integer; { data allocation index } { 数据段内存分配指针，指向下一个被分配空间在数据段中的偏移位置}tx0: integer; { initial table index } { 记录本层开始时符号表位置}cx0: integer; { initial code index } { 记录本层开始时代码段分配位置}{ 登陆符号表过程enter }procedure enter(k: object1);begin { enter object into table } { 参数：k:欲登陆到符号表的符号类型}tx := tx + 1; { 符号表指针指向一个新的空位}with table[tx] do { 开始登录}beginname := id; { name是符号的名字，对于标识符，这里就是标识符的名字}kind := k; { 符号类型，可能是常量、变量或过程名}case k of { 根据不同的类型进行不同的操作}constant: { 如果是常量名}beginif num > amax then { 在常量的数值大于允许的最大值的情况下}beginerror(31); { 抛出31号错误}num := 0; { 实际登陆的数字以0代替}end;val := num { 如是合法的数值，就登陆到符号表}end;variable: { 如果是变量名}beginlevel := lev; { 记下它所属的层次号}adr := dx; { 记下它在当前层中的偏移量}dx := dx+1; { 偏移量自增一，为下一次做好准备}end;procedur: { 如果要登陆的是过程名}level := lev { 记录下这个过程所在层次}EndEndend { enter };{ 登录符号过程没有考虑到重复的定义的问题。
语法制导翻译和中间代码生成
继承属性L.in
语 义 规 则
语句： real id1， id2， id3 的分析树，采用自上而下的分析方法
产 生 式
D TL
T int
T real
L L1,id
L id
L.in:=T.type
T.type=integer
F.val=3
F.val=5
digit.lexval=4
digit.lexval=5
digit.lexval=3
+
*
3*5+4的带注释的分析树
如果一个语法制导定义仅仅使用综合属性，则称这种语法制导定义为S属性定义。通常采用自底向上的方法对其分析树加注释，即从树叶到树根，按照语义规则计算每个节点的属性值。
表达式文法 E→T+T| T or T T → n | true | false
E → T1 + T2 { T1.type = int AND T2.type = T1. type E.type :=int } E → T1 or T2 { T1.type = bool AND T2.type= T1.type E.type :=bool } T → n { T.type := int } T → true { T.type := bool } T → false { T.type := bool }
T.type:=real
L1.in:=L.in
addtype(id.entry,L.in)
addtype(id.entry,L.in)
D
L.in= real
L.in= real
L.in= real
T.type=real
6编译原理之中间代码生成
三地址代码（3）
• 指令
–过程调用/返回：
• • • • • param x1 param x2 … param xn call p, n //设置参数
//调用子过程p，n为参数个数
–带下标的复制指令：x=y[i] –地址/指针赋值指令：
• x=&y x=*y *x=y
x[i]=y
• 注意：i表示离开数组位置第i个字节，而不是数组的第i 个元素
–P{D.off=0} D –D T id; {D1.off = D.off + T.width;} D1
记录中的域的处理
• 我们可以为每个记录创建单独的符号表 • 处理时
–首先创建一个新的符号表，压到栈顶； –然后处理对应于字段声明的D，字段都被加入到新 符号表中； –最后根据栈顶的符号表构造record类型表达式； 符号表出栈
新的产生式
• • • • 数组元素L：LL[E] | id[E] 以数组元素为左部的赋值：SL=E; 数组元素作为因子：EL L的代码的功能是计算偏移量，存放于L.addr所指 的临时变量中。
数组元素作为因子
• L的代码只计算了偏移量； • 数组元素的值应该根据偏移量进一步计算即L 的数组基址加上偏移量 • 使用三地址指令x=a[i]
例：if (flag) x=-1; else x = 1; y = x*a • if (flag) x1=-1; else x2 = 1; x3=φ(x1,x2)； • y = x3*a • 若控制流经过该条件语句的真分支， φ(x1,x2)的值为x1； 否则，若控制流经过该条件语句的假分支， φ(x1,x2)的值为x2
处理类型转换的SDT
图6.27 在表达式计算中引入类型转换
实验报告后附代码
一、实验背景随着互联网的快速发展，网络上的信息量呈爆炸式增长，人们获取信息的渠道也越来越丰富。
然而，大量的信息也带来了信息过载的问题，使得人们在海量的信息中难以找到自己所需的内容。
为了解决这一问题，文本分类技术应运而生。
文本分类是指将文本数据按照一定的规则和标准划分到预定义的类别中，从而实现信息组织和检索的自动化。
近年来，随着机器学习技术的快速发展，基于机器学习的文本分类方法在各个领域得到了广泛应用。
本实验旨在通过构建一个基于机器学习的文本分类模型，实现对文本数据的自动分类。
二、实验目标1. 了解文本分类的基本原理和方法。
2. 掌握机器学习在文本分类中的应用。
3. 构建一个基于机器学习的文本分类模型，并对模型进行评估。
三、实验方法1. 数据集：本实验选用中文文本数据集，包括新闻、论坛、博客等类型的文本数据。
2. 数据预处理：对文本数据进行分词、去除停用词、词性标注等操作。
3. 特征提取：采用TF-IDF等方法提取文本特征。
4. 模型构建：选用朴素贝叶斯、支持向量机等机器学习算法构建文本分类模型。
5. 模型评估：使用准确率、召回率、F1值等指标评估模型性能。
四、实验步骤1. 数据集准备本实验选用中文文本数据集，数据集包含新闻、论坛、博客等类型的文本数据，共10万条。
数据集的类别分布如下：- 新闻：3万条- 论坛：3万条- 博客：4万条2. 数据预处理对文本数据进行分词、去除停用词、词性标注等操作，将文本转换为机器学习模型可处理的格式。
3. 特征提取采用TF-IDF方法提取文本特征，将文本数据转换为特征向量。
4. 模型构建选用朴素贝叶斯、支持向量机等机器学习算法构建文本分类模型。
5. 模型评估使用准确率、召回率、F1值等指标评估模型性能。
五、实验结果与分析1. 模型训练使用训练集对模型进行训练，训练完成后，模型可以用于对未知文本数据进行分类。
2. 模型评估使用测试集对模型进行评估，评估指标如下：- 准确率：模型正确分类的样本数占总样本数的比例。
第六章 中间代码生成
第六章中间代码生成在编译器的分析-综合模型中，前端对源程序进行分析并产生中间表示，后端在此基础上生成目标代码。
在理想情况下，和源语言相关的细节在前端分析中处理，而关于目标机器的细节则在后端处理。
基于一个适当定义的中间表示形式，可以把针对源语言i的前端和针对目标机器j的后端组合起来，构造得到源语言i在目标机器j上的一个编译器。
这种创建编译器组合的方法可以节约大量的工作量：只要写出m种前端和n种后端处理程序，就可以得到m×n种编译程序。
本章的内容处理中间代码表示、静态类型检查和中间代码生成。
为简单起见，我们假设一个编译程序的前端处理按照图6.1所示方式进行组织，顺序地进行语法分析、静态检查和中间代码生成。
有时候这几个过程也可以组合起来，在语法分析中一并完成。
我们将使用第二章和第五章中的语法制导定义来描述类型检查和翻译过程。
大部分的翻译方案可以基于第五章中给出的自顶向下或自底向上的技术来实现。
所有的方案都可以通过生成并遍历抽象语法树来实现。
静态检查包括类型检查，保证运算符被作用于兼容的运算分量。
静态检查还包括在语法分析之后进行的所有语法检查。
例如，静态检查保证了C语言中的一条break指令必然位于一个while/for/switch语句之内。
如果不存在这样的语句，静态检查将报告一个错误。
本章介绍的方法可以用于多种中间表示，包括抽象语法树和三地址代码。
这两种中间表示方法都在本书的2.8节中介绍过。
名为“三地址代码”的原因是这些指令的一般形式x=y op z 具有三个地址：两个运算分量y和z，一个结果变量x。
在将给定源语言的一个程序翻译成特定的目标机器代码的过程中，一个编译器可能构造出一系列的中间表示，如图6.2所示。
高层的表示接近于源语言，而低层的表示接近于目标机器。
语法树是高层的表示，它刻画了源程序的自然的层次性结构，并且很适合进行诸如静态类型检查这样的处理。
低层的表示形式适合进行机器相关的处理任务，比如寄存器分配、指令选择等。
编译原理教程实验报告
一、实验目的本次实验旨在使学生通过编译原理的学习，了解编译程序的设计原理及实现技术，掌握编译程序的各个阶段，并能将所学知识应用于实际编程中。
二、实验内容1. 词法分析2. 语法分析3. 语义分析4. 中间代码生成5. 代码优化6. 目标代码生成三、实验步骤1. 词法分析（1）设计词法分析器，识别输入源代码中的各种词法单元；（2）使用C语言实现词法分析器，并进行测试。
2. 语法分析（1）根据文法规则设计语法分析器，识别输入源代码的语法结构；（2）使用C语言实现语法分析器，并进行测试。
3. 语义分析（1）设计语义分析器，检查语法分析后的语法树，确保语义正确；（2）使用C语言实现语义分析器，并进行测试。
4. 中间代码生成（1）设计中间代码生成器，将语义分析后的语法树转换为中间代码；（2）使用C语言实现中间代码生成器，并进行测试。
5. 代码优化（1）设计代码优化器，对中间代码进行优化，提高程序性能；（2）使用C语言实现代码优化器，并进行测试。
6. 目标代码生成（1）设计目标代码生成器，将优化后的中间代码转换为特定目标机的汇编语言；（2）使用C语言实现目标代码生成器，并进行测试。
四、实验结果与分析1. 词法分析实验结果：成功识别输入源代码中的各种词法单元，包括标识符、关键字、运算符、常量等。
2. 语法分析实验结果：成功识别输入源代码的语法结构，包括表达式、语句、程序等。
3. 语义分析实验结果：成功检查语法分析后的语法树，确保语义正确。
4. 中间代码生成实验结果：成功将语义分析后的语法树转换为中间代码，为后续优化和目标代码生成提供基础。
5. 代码优化实验结果：成功对中间代码进行优化，提高程序性能。
6. 目标代码生成实验结果：成功将优化后的中间代码转换为特定目标机的汇编语言，为程序在目标机上运行做准备。
五、实验心得1. 编译原理是一门理论与实践相结合的课程，通过本次实验，我对编译程序的设计原理及实现技术有了更深入的了解。
实验五+中间代码生成器
实验5 中间代码生成器一、实验目的掌握语法制导定义和翻译的原理和技术，在语法分析器的基础上，加上语义分析，构造一个中间代码生成器。
二、实验内容在实验四用Yacc生成的语法分析器基础上加入语义动作，编写一个中间代码生成程序。
1．文法（见教材附录A.1，p394）program→ blockblock→{ decls stmts }decls →decls decl | εdecl →type id ;type →type [num] //数组可以不做| basic //四种基本数据类型int | float | char | bool stmts→stmts stmt | εstmt→id=expr;| if(bool)stmt| if( bool)stmt else stmt| while(bool)stmt| do stmt while(bool ) ;| break ;//break可以不做| blockbool →bool || join| joinjoin →join&& equality | equalityequality →equality == rel | equality != rel | relrel →expr < expr| expr <= expr| expr > expr| expr >= expr| exprexpr→ expr + term| expr - term| termterm→ term * unary| term / unary| unaryunary →!unary| - unary| factorfactor→ ( e xpr ) | id| num2．中间代码的形式见教材p221~222，若有必要，可以适当扩展（加以说明）。
三、实验过程3.1符号表的定义和相关函数struct SymbolElemstruct SymbolListSymbolList CreateSymbolList( SymbolList PrevList, int StartAddr )/*创建并返回一个新的符号表（SymbolList就是书上的Env），PrevList是其的上一层符号表*/void DestroySymbolList( SymbolList List )struct SymbolElem * LookUpSymbolList( SymbolList List, char * IdName )/*在符号表List中查找是否存在标识符IdName，如果存在，则返回该结点指针，否则返回空*/struct SymbolElem * LookUpAllSymbolList( SymbolList List, char * IdName )/*从符号表List开始并不断地往上一层符号表中查找是否存在标识符IdName，如果存在，则返回该结点指针，否则返回空*/struct SymbolElem * AddToSymbolList( SymbolList List, char * IdName,int IdType, int Width )/*创建一个新的符号结点,并添加到符号表中，而后返回该结点指针*/3.2常数表的定义和相关函数union ConstVal/*存放一个常数*/struct ConstElem/*常量表*/struct ConstList/*创建并返回常量表*/void CreateConstList( int StartAddr )void DestroyConstList( void )/*在常量表ConstList中查找是否存在常量，如果存在，则返回该结点指针，否则返回空*/struct ConstElem * LookUpConstList( int ConstType, union ConstVal ConstValue, int Width )/*创建一个新的常数结点,并添加到常数表中，而后返回该结点指针*/struct ConstElem * AddToConstList( char * Str, int ConstType, union ConstVal ConstValue, int Width )3.3四元式的定义和函数/*四元式数据结构*/struct Quadruple/*四元式表*/struct QuadTablevoid CreateQuadTable(int StartAddr)void DestroyQuadTable( void )/*当Arg1是变量或临时变量时，Arg1Name是该变量的名称,用于演示时使用，其余参数类同*/int Gen( int Op, int Arg1, int Arg2, int Arg3, char *Arg1Name, char *Arg2Name, char *Arg3Name )/*把四元式所对应的三地址代码写入到文件中*/void WriteQuadTableToFile( const char * FileName )四、实验结果源程序片断运行状态图运行结果本次实验很难，做了很久都没做出来。
实验报告代码
实验报告代码一、引言本实验旨在通过编写代码，实现一个简单的实验报告生成器。
实验报告生成器能够自动根据用户提供的实验数据，生成具有格式规范和内容准确的实验报告，并以文本文件的形式保存。
二、代码实现下面是实验报告生成器的代码实现：```pythondef generate_report(data):# 生成实验报告的代码实现report = "实验报告内容：\n"# 添加实验数据分析结果report += "实验数据分析结果：\n"report += "实验数据总数：" + str(len(data)) + "\n"report += "最大值：" + str(max(data)) + "\n"report += "最小值：" + str(min(data)) + "\n"report += "平均值：" + str(sum(data) / len(data)) + "\n"# 添加实验结论report += "实验结论：\n"if sum(data) > 0:report += "根据实验数据分析结果，实验结果为正面。
\n"else:report += "根据实验数据分析结果，实验结果为负面。
\n"return report# 测试代码data = [1, 2, 3, 4, 5]report = generate_report(data)print(report)```三、实验结果根据给定的实验数据 [1, 2, 3, 4, 5]，运行上述代码，生成的实验报告内容如下：实验报告内容：实验数据分析结果：实验数据总数：5最大值：5最小值：1平均值：3.0实验结论：根据实验数据分析结果，实验结果为正面。
编译原理中间代码生成
文法规则
语义规则
exp1→id=exp2 exp→aexp
= exp1.tacode= exp2.tacode++ id.strval ||”=” ||
= exp.tacode=aexp.tacode
machunyan
P-机器在不同的平台上由不同的解释器实现。 该思想使得pascal编译器变得容易移植，
只需对新平台重写P-机器解释器即可。
machunyan
西北工业大学软件与微电子学院
13
6.1.3 P-代码（续）
例6.3:算术表达式：2*a+(b-3)的P-代码如下： ldc 2 ; load constant 2 lod a ; load value of variable a mpi ; integer multiplication lod b ; load value of variable b ldc 3 ; load constant 3 sbi ; integer subtraction adi ; integer addition
exp1→id=exp2
{= emit(id.strval ‘=’)}
exp→aexp
{= }
aexp1→aexp2+factor
{ =newtemp() emit(’=’ aexp2 .name ’+’ )
三地址码是中间代码的一种抽象形式。在编译器中， 这些语句可以以带有操作符和操作数域的记录来实现。 三地址码常见的实现有四元式和三元式。
四元式是带有四个域的记录结构，即 op,arg1,arg2,result，可以写成 (op,arg1,arg2,result) 。arg1,arg2及result域的内 容正常情况下是指这些域所代表的名字在符号表表项的 指针。临时名字result在生成时一定要被填入符号表。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验三中间代码生成学号：1152185；姓名：马小军实验目的1.了解并掌握中间代码的生成过程和作用2.了解并掌握四元式3.体会属性文法在中间代码生成过程中的作用。
实验环境Windows7操作系统vs2010编程环境实验内容从文件中读入表达式，输出其四元式的结果序列本程序只能生成赋值语句及算数表达式中间代码的四元式不能生成逻辑表达式及其他复杂语句中间代码的四元式实验原理三、以逆波兰式为例的实验设计思想及算法(1)首先构造一个运算符栈，此运算符在栈内遵循越往栈顶优先级越高的原则。
(2)从左至右扫描该算术表达式，从第一个字符开始判断，如果该字符数字，则分析到该数字串的结束并将该数字存入数组。
(3)如果不是数字，该字符则是运算符，此时需比较优先关系。
做法如下：将该字符与运算符栈顶的运算符的优先关系相比较。
如果，该字符优先关系高于此运算符栈顶的运算符，则将该运算符入栈。
倘若不是的话，则将此运算符栈顶的运算符从栈中弹出，将该字符入栈。
(4)重复上述操作(2)-(3)直至扫描完整个简单算术表达式，确定所有字符都得到正确处理，我们便可以将中缀式表示的简单算术表达式转化为四元式。
下面给出算法流程图实验步骤打开并运行软件根据提示输入要分析的源程序（文件目录下有写好的文件源文件1.txt输入即可）运行输出结果例如将以下源文件放入test.txt运行结果a:=b*c+b*d思考同样的思路对算法进行适当改动就可以生成其它形式的中间代码【其他部分】设计原理和算法思想参考《程序设计语言编译原理》第三版国防工业出版社作者陈火旺等附录代码#include<stdlib.h>#include<fstream>#include<iostream>#include<stdio.h>using namespace std;#define MAX 100int m=0,sum=0;//sum用®?于®¨²计?算?运?算?符¤?的Ì?个?数ºy//m用®?于®¨²标À¨º记?输º?入¨?表À¨ª达ä?式º?中D字Á?符¤?的Ì?个?数ºychar JG='A';char str[MAX];//用®?于®¨²存ä?输º?入¨?表À¨ª达ä?式º?int token=0;//左Á¨®括¤¡§号?的Ì?标À¨º志?/***********用®?于®¨²更¨¹改?计?算?后¨®数ºy组Á¨¦中D的Ì?值¦Ì**************/void change(int e){int f=e+2;char ch=str[f];if(ch>='A'&&ch<='Z'){for(int l=0;l<m+10;l++){if(str[l]==ch)str[l]=JG;}}if(str[e]>='A'&&str[e]<='Z'){for(int i=0;i<m;i++){if(str[i]==str[e])str[i]=JG;}}}void chengchuchuli(int i,int m){i++;for( ;i<=m-1;i++)//处ä|理¤¨ª乘?除y运?算?{if(str[i]=='*'||str[i]=='/'){cout<<"("<<str[i]<<" "<<str[i-1]<<" "<<str[i+1]<<" "<<JG<<")"<<endl;change(i-1);str[i-1]=str[i]=str[i+1]=JG;sum--;JG=(char)(int)JG++;}}}void jiajianchuli(int j,int m){j++;for( ;j<=m-1;j++)//处ä|理¤¨ª加¨®减?运?算?{if(str[j]=='+'||str[j]=='-'){cout<<"("<<str[j]<<" "<<str[j-1]<<" "<<str[j+1]<<" "<<JG<<")"<<endl;change(j-1);str[j-1]=str[j]=str[j+1]=JG;sum--;JG=(char)(int)JG++;}}}/*扫¦¡§描¨¨一°?遍À¨¦从䨮文?件t中D读¨¢入¨?表À¨ª达ä?式º?*/void scan(FILE *fin){int p[MAX];char ch='a';int c=-1,q=0;while(ch!=EOF){ch=getc(fin);while(ch==' '||ch=='\n'||ch=='\t') ch=getc(fin);//消?除y空?格?和¨ª换?行D 符¤?str[m++]=ch;if(ch=='='||ch=='+'||ch=='-'||ch=='*'||ch=='/') sum++;else if(ch=='('){p[++c]=m-1;}else if(ch==')'){q=m-1;chengchuchuli(p[c],q);//从䨮左Á¨®括¤¡§号?处ä|理¤¨ª到Ì?又®?括¤¡§号?jiajianchuli(p[c],q);JG=(char)(int)JG--;str[p[c]]=str[m-1]=JG;c--;JG=(char)(int)JG++;}}}void sanyuanshi(){for(int i=0;i<=m-1;i++)//处ä|理¤¨ª乘?除y运?算?{if(str[i]=='*'||str[i]=='/'){cout<<"("<<str[i]<<" "<<str[i-1]<<" "<<str[i+1]<<" "<<JG<<")"<<endl;change(i-1);str[i-1]=str[i]=str[i+1]=JG;sum--;JG=(char)(int)JG++;}}for(int j=0;j<=m-1;j++)//处ä|理¤¨ª加¨®减?运?算?{if(str[j]=='+'||str[j]=='-'){cout<<"("<<str[j]<<" "<<str[j-1]<<" "<<str[j+1]<<" "<<JG<<")"<<endl;change(j-1);str[j-1]=str[j]=str[j+1]=JG;sum--;JG=(char)(int)JG++;}}for(int k=0;k<=m-1;k++)//处ä|理¤¨ª赋3值¦Ì运?算?{if(str[k]=='='){JG=(char)(int)--JG;cout<<"("<<str[k]<<" "<<str[k+1]<<" "<<" "<<" "<<str[k-1]<<")"<<endl;sum--;change(k+1);str[k-1]=JG;}}}void main(){char in[MAX]; //用®?于®¨²接¨®收º?输º?入¨?输º?出?文?件t名?FILE *fin; //用®?于®¨²指?向¨°输º?入¨?输º?出?文?件t的Ì?指?针?cout<<"请?输º?入¨?源¡ä文?件t名?（ꡧ包㨹括¤¡§后¨®缀Áo名?）ê?"<<endl;// scanf("%s",in);cin>>in;;if ((fin=fopen(in,"r"))==NULL) //判D断?输º?入¨?文?件t名?是º?否¤?正y确¨¡¤{cout<<"打䨰开a词䨺法¤¡§分¤?析?输º?入¨?文?件t出?错䨪!"<<endl;}cout<<"*********三¨y元a式º?如¨?下?：êo*********"<<endl;scan(fin);//调Ì¡Â用®?函¡¥数ºy从䨮文?件t中D读¨¢入¨?表À¨ª达ä?式º?sanyuanshi();if(sum==0) printf("成¨¦功|！ê?");else printf("有®D错䨪误¨®！ê?");//关?闭À?文?件tfclose(fin);system("pause");}。