中间代码生成实验报告
中间代码生成实验报告
一、实验目的1. 理解编译原理中中间代码生成的基本概念和作用。
2. 掌握中间代码生成的常用算法和策略。
3. 提高对编译器构造的理解和实际操作能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：Java3. 开发工具：Eclipse三、实验内容1. 中间代码生成的基本概念2. 中间代码的表示方法3. 中间代码生成算法4. 实现一个简单的中间代码生成器四、实验步骤1. 了解中间代码生成的基本概念中间代码生成是编译过程中的一个重要环节，它将源程序转换成一种中间表示形式，便于后续的优化和目标代码生成。
中间代码生成的目的是提高编译器的灵活性和可维护性。
2. 研究中间代码的表示方法中间代码通常采用三地址代码（Three-Address Code，TAC）表示。
TAC是一种低级表示，由三个操作数和一个操作符组成，例如：(t1, t2, t3) = op，其中t1、t2、t3为临时变量，op为操作符。
3. 学习中间代码生成算法中间代码生成算法主要包括以下几种：（1）栈式中间代码生成算法（2）归约栈中间代码生成算法（3）递归下降中间代码生成算法4. 实现一个简单的中间代码生成器本实验采用递归下降中间代码生成算法，以一个简单的算术表达式为例，实现中间代码生成器。
（1）定义语法规则设表达式E由以下语法规则表示：E → E + T | E - T | TT → T F | T / F | FF → (E) | i（2）设计递归下降分析器根据语法规则，设计递归下降分析器，实现以下功能：①识别表达式E②识别项T③识别因子F（3）生成中间代码在递归下降分析器中，针对不同语法规则，生成相应的中间代码。
例如：当遇到表达式E时，生成以下中间代码：(t1, t2, t3) = op1(t1, t2) // op1表示加法或减法(t4, t5, t6) = op2(t4, t5) // op2表示乘法或除法(t7, t8, t9) = op3(t7, t8) // op3表示赋值（4）测试中间代码生成器编写测试用例，验证中间代码生成器的正确性。
中间代码生成实验报告doc
中间代码生成实验报告篇一：编译方法实验报告(中间代码生成器)编译方法实验报告XX年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#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--z int 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 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]='0' && exp[i] 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++;}篇二：中间代码生成实验报告一、实验目的通过在实验二的基础上，增加中间代码生成部分，使程序能够对实验二中的识别出的赋值语句，if语句和while语句进行语义分析，生成四元式中间代码。
编译原理综合性实验报告-分析中间代码生成程序
<VarDef>-><idList>:T
<idList>->id[,<idList>]
程序的主要任务是：
(1).扫描整个变量声明部分，并进行语义错误检查。
分析PL/0编译程序的总体结构、代码生成的方法和过程；具体写出一条语句的中间代码生成过程。
二、设备与环境
PC兼容机、Windows操作系统、Turbo Pascal软件等。
三、实验内容
1.分析PL/0程序的Block子程序，理清PL/0程序结构和语句格式。画出Block子程序的流程图，写出至少两条PL/0程序语句的语法格式。
2.分析PL/0程序的Block子程序和Gen子程序，了解代码生成的方法和过程。使用概要算法来描述语句的代码生成过程。
3.自己编写一个简单的PL/0程序，能够正确通过编译，得到中间代码。列出自己编写的源程序和编译后得到的中间代码。
4.从中选择一个语句或表达式，写出代码生成的过程。要求从自己的源程序中选择一条语句，结合这条语句写出语义分析和代码生成过程。在描述这个过程中，要说清楚每个功能有哪个子程序的哪条语句来完成，说清楚语句和参数的含义和功能。
四、实验结果及分析
（一）Block子程序分析
1.常量声明的分析:
常量声明部分的语法结构定义为如下形式：
<ConstDecPart> -> const <ConstDefList>;
<ConstDefList> -> <ConstDef>[;<ConstDefList>]
编译方法实验报告（中间代码生成器）
编译方法实验报告（中间代码生成器）编译方法实验报告20xx年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--z int 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);/ p > p c l a s s = " t " > q t [ j ] [ 1 ] = s y n [ i _ s y n ] ; / p > p c l a s s = " t " > q t [ j ] [ 3 ] = s e m [ i _ s e m - 1 ] ; / p > p c l a s s = " t " > q t [ j ] [ 5 ] = s e m [ i _ s e m ] ; / p > p c l a s s = " t " > q t [ j ] [ 7 ] = t e m p ; / p > p c l a s s = " t " > j + + ; / p > p c l a s s = " t " > i _ s y n - - ; / / p o p ( S Y N ) ; / p > p c l a s s = " t " > i _ s e m - - ; / / p o p ( S E M ) ; / p > p c l a s s = " t " > i _ s e m - - ; / / p o p ( S E M ) ; / p > p c l a s s = " t " > s e m [ + + i _ s e m ] = t e m p ; / / p u s h ( S E M , t e m p ) ; / p > p c l a s s = " t " > t e m p + + ; } / p > p c l a s s = " g " >。
编译方法实验报告(中间代码生成器)
编译方法实验报告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++;}六、总结与分析我们知道, 定义一种语言除了要求定义语法外, 还要求定义语义, 即对语言的各种语法单位赋予具体的意义。
中间代码生成实验报告
一、实验目的通过在实验二的基础上，增加中间代码生成部分，使程序能够对实验二中的识别出的赋值语句，if语句和while语句进行语义分析，生成四元式中间代码。
二、实验方法实验程序由c语言完成，在Turboc 2.0环境中调试通过。
语义分析程序的基本做法是对文法中的每个产生式分别编写一个语义分析子程序，当程序语法部分进行推倒或规约时，就分别调用各自的语义分析程序。
当语法分析结束时，语义分析也就结束了。
在本实验程序中，当语法分析部分识别出语法正确的句子时，就进入content函数（当语法分析识别出不正确的句子时，不进入content函数，也就是不进行语义分析），然后根据句子的类型进行分类，进入不同的语义处理部分。
对于赋值语句，关键是产生正确的处理算术表达式E的四元式。
程序中的ec函数的功能就是产生算术表达式的四元式，在ec函数中使用了两个栈idshed，opshed，分别是算术表达式的数据栈和符号栈。
每次提取一个数字和一个算符，然后将算符与与栈顶算符进行优先级比较，优先级高则将单前数字和算符进栈，低或者相等的话则将当前栈顶元素进行合并，产生四元式。
直至整个算术表达式结束。
其中还有一些细节问题，具体的做法可以参看程序。
对于实验给定的if语句的文法格式，条件判断式C只中可能是>或者<=两种关系，不可能是布尔表达式，这样程序就简单的多了。
通过ec函数可以产生条件判断式C中的E的四元式，然后只要加上转向四元式就可以了。
本实验程序中只给出真出口的转向四元式，没有给出假出口的转向四元式，这在实际中是不可以的，但在本实验中，实际上是对每条独立的语句进行语法分析，给出假出口转向四元式实际上意义不大，而且假出口转向语句的转移目标必须要到整个语句分析结束以后才可以知道，这样就要建立栈，然后回填，这样会使程序复杂很多，所以没有加上假出口转向四元式。
对于while语句，具体的做法和if语句差不多，所不同的是当while语句结束时，要多出一条无条件转向四元式，重新转到条件判断式C的第一条四元式。
中间代码生成实验报告
中间代码生成实验报告《中间代码生成实验报告》摘要：本实验旨在通过编写中间代码生成程序，实现将高级语言源代码转换为中间代码的功能。
通过实验，我们掌握了中间代码的生成过程和相关算法，并对编译器的工作原理有了更深入的理解。
本实验采用了C语言作为源语言，通过词法分析、语法分析和语义分析，生成了对应的中间代码。
一、实验目的1. 理解编译器的工作原理，掌握中间代码生成的基本概念和方法；2. 掌握中间代码的表示方法和生成算法；3. 通过实践，提高编程能力和对编译原理的理解。
二、实验环境1. 操作系统：Windows 10；2. 编程语言：C语言；3. 开发工具：Visual Studio 2019。
三、实验内容1. 设计并实现中间代码生成程序，将给定的C语言源代码转换为中间代码；2. 实现词法分析、语法分析和语义分析，生成对应的中间代码；3. 测试程序，验证中间代码的正确性和有效性。
四、实验步骤1. 设计中间代码的表示方法，包括四元式、三地址码等；2. 实现词法分析器，将源代码转换为词法单元序列；3. 实现语法分析器，将词法单元序列转换为语法树；4. 实现语义分析器，对语法树进行语义检查并生成中间代码；5. 测试程序，验证中间代码的正确性和有效性。
五、实验结果经过测试，中间代码生成程序能够正确地将C语言源代码转换为中间代码，并且生成的中间代码能够正确地表达源代码的语义和逻辑结构。
通过实验，我们成功地掌握了中间代码的生成过程和相关算法，加深了对编译器工作原理的理解。
六、实验总结通过本次实验，我们深入了解了编译器的工作原理和中间代码生成的基本概念和方法。
通过实践，我们提高了编程能力和对编译原理的理解，为进一步深入学习编译原理和设计编译器打下了良好的基础。
希望通过不断的实践和学习，能够更加熟练地掌握编译原理的知识，为今后的学习和工作打下坚实的基础。
编译原理中间代码生成实验报告
竭诚为您提供优质文档/双击可除编译原理中间代码生成实验报告篇一：编译原理-分析中间代码生成程序实验报告课程名称编译原理实验学期至学年第学期学生所在系部年级专业班级学生姓名学号任课教师实验成绩计算机学院制开课实验室：年月日篇二：编译原理实验中间代码生成实验四中间代码生成一．实验目的：掌握中间代码的四种形式（逆波兰式、语法树、三元式、四元式）。
二．实验内容：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、三元式：形式序号：（op,arg1,arg2）4、四元式：形式（op,arg1,arg2,result）三、以逆波兰式为例的实验设计思想及算法(1)首先构造一个运算符栈，此运算符在栈内遵循越往栈顶优先级越高的原则。
(2)读入一个用中缀表示的简单算术表达式，为方便起见,设该简单算术表达式的右端多加上了优先级最低的特殊符号“#”。
(3)从左至右扫描该算术表达式，从第一个字符开始判断，如果该字符是数字，则分析到该数字串的结束并将该数字串直接输出。
(4)如果不是数字，该字符则是运算符，此时需比较优先关系。
做法如下：将该字符与运算符栈顶的运算符的优先关系相比较。
如果，该字符优先关系高于此运算符栈顶的运算符，则将该运算符入栈。
倘若不是的话，则将此运算符栈顶的运算符从栈中弹出，将该字符入栈。
(5)重复上述操作(1)-(2)直至扫描完整个简单算术表达式，确定所有字符都得到正确处理，我们便可以将中缀式表示的简单算术表达式转化为逆波兰表示的简单算术表达式。
四、程序代码：//这是一个由中缀式生成后缀式的程序#include<iostream.h>#include<string.h>#include<math.h>#include<ctype.h>#define maxbuffer 64void main(){char display_out(char out_ch[maxbuffer], char ch[32]);//int caculate_array(char out_ch[32]);static int i=0;static int j=0;char ch[maxbuffer],s[maxbuffer],out[maxbuffer];cout<<"请输入中缀表达式: ";cin>>ch;for(i=0;i<maxbuffer;i++){out[i]=ch[i];}cout<<"请确认您输入的表达式："; while(out[j]!='#'){cout<<out[j];j++;}cout<<'#'<<endl;display_out(s,out);//caculate_array;}char display_out(char out_ch[32],char ch[]) {int top=-1;int i=0,data[maxbuffer],n;int j=0;char sta[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]=='*'&&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<<"错误: 第"<<j<<"个位置的")"没有找到与之匹配的"(""; ch[i]='#';j=0;}else{//while(sta[top]!=‘(‘){out_ch[j]=sta[top];top--;j++;//}break;}break;/*case ‘#‘: out_ch[j]=‘#‘;j++;break;*/default:cout<<" your input is error"<<endl; ch[i]='#';j=0;break;}}}while(top!=-1){out_ch[j]=sta[top];j++;top--;}out_ch[j]='#';n=0;cout<<"逆波兰表达式为: ";while(out_ch[n]!='#'){cout<<out_ch[n];n++;}cout<<endl;j=0;return out_ch[maxbuffer];}五、实验结果：要求：自己给出3个测试用例，观察结果。
编译原理实验 中间代码生成
实验四中间代码生成一．实验目的：掌握中间代码的四种形式（逆波兰式、语法树、三元式、四元式）。
二．实验内容：1、逆波兰式定义:将运算对象写在前面，而把运算符号写在后面。
用这种表示法表示的表达式也称做后缀式。
2、抽象（语法）树：运算对象作为叶子结点，运算符作为内部结点。
3、三元式：形式序号：（op,arg1,arg2）4、四元式：形式（op,arg1,arg2,result）三、以逆波兰式为例的实验设计思想及算法(1)首先构造一个运算符栈，此运算符在栈内遵循越往栈顶优先级越高的原则。
(2)读入一个用中缀表示的简单算术表达式，为方便起见,设该简单算术表达式的右端多加上了优先级最低的特殊符号“#”。
(3)从左至右扫描该算术表达式，从第一个字符开始判断，如果该字符是数字，则分析到该数字串的结束并将该数字串直接输出。
(4)如果不是数字，该字符则是运算符，此时需比较优先关系。
做法如下：将该字符与运算符栈顶的运算符的优先关系相比较。
如果，该字符优先关系高于此运算符栈顶的运算符，则将该运算符入栈。
倘若不是的话，则将此运算符栈顶的运算符从栈中弹出，将该字符入栈。
(5)重复上述操作(1)-(2)直至扫描完整个简单算术表达式，确定所有字符都得到正确处理，我们便可以将中缀式表示的简单算术表达式转化为逆波兰表示的简单算术表达式。
四、程序代码：//这是一个由中缀式生成后缀式的程序#include<iostream.h>#include<string.h>#include<math.h>#include<ctype.h>#define maxbuffer 64void main(){char display_out(char out_ch[maxbuffer], char ch[32]);//int caculate_array(char out_ch[32]);static int i=0;static int j=0;char ch[maxbuffer],s[maxbuffer],out[maxbuffer];cout<<"请输入中缀表达式: ";cin>>ch;for(i=0;i<maxbuffer;i++){out[i]=ch[i];}cout<<"请确认您输入的表达式："; while(out[j]!='#'){cout<<out[j];j++;}cout<<'#'<<endl;display_out(s,out);//caculate_array;}char display_out(char out_ch[32],char ch[]) {int top=-1;int i=0,data[maxbuffer],n;int j=0;char sta[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]=='*'&&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<<"错误: 第"<<j<<"个位置的")"没有找到与之匹配的"(""; ch[i]='#';j=0;}else{//while(sta[top]!=‘(‘){out_ch[j]=sta[top];top--;j++;//}break;}break;/*case ‘#‘: out_ch[j]=‘#‘;j++;break;*/default:cout<<" your input is error"<<endl; ch[i]='#';j=0;break;}}}while(top!=-1){out_ch[j]=sta[top];j++;top--;}out_ch[j]='#';n=0;cout<<"逆波兰表达式为: ";while(out_ch[n]!='#'){cout<<out_ch[n];n++;}cout<<endl;j=0;return out_ch[maxbuffer];}五、实验结果：要求：自己给出3个测试用例，观察结果。
编译原理实验 中间代码生成
实验四中间代码生成一．实验目的：掌握中间代码的四种形式（逆波兰式、语法树、三元式、四元式）。
二．实验内容：1、逆波兰式定义:将运算对象写在前面，而把运算符号写在后面。
用这种表示法表示的表达式也称做后缀式。
2、抽象（语法）树：运算对象作为叶子结点，运算符作为内部结点。
3、三元式：形式序号：（op,arg1,arg2）4、四元式：形式（op,arg1,arg2,result）三、以逆波兰式为例的实验设计思想及算法(1)首先构造一个运算符栈，此运算符在栈内遵循越往栈顶优先级越高的原则。
(2)读入一个用中缀表示的简单算术表达式，为方便起见,设该简单算术表达式的右端多加上了优先级最低的特殊符号“#”。
(3)从左至右扫描该算术表达式，从第一个字符开始判断，如果该字符是数字，则分析到该数字串的结束并将该数字串直接输出。
(4)如果不是数字，该字符则是运算符，此时需比较优先关系。
做法如下：将该字符与运算符栈顶的运算符的优先关系相比较。
如果，该字符优先关系高于此运算符栈顶的运算符，则将该运算符入栈。
倘若不是的话，则将此运算符栈顶的运算符从栈中弹出，将该字符入栈。
(5)重复上述操作(1)-(2)直至扫描完整个简单算术表达式，确定所有字符都得到正确处理，我们便可以将中缀式表示的简单算术表达式转化为逆波兰表示的简单算术表达式。
四、程序代码：//这是一个由中缀式生成后缀式的程序#include<iostream.h>#include<string.h>#include<math.h>#include<ctype.h>#define maxbuffer 64void main(){char display_out(char out_ch[maxbuffer], char ch[32]);//int caculate_array(char out_ch[32]);static int i=0;static int j=0;char ch[maxbuffer],s[maxbuffer],out[maxbuffer];cout<<"请输入中缀表达式: ";cin>>ch;for(i=0;i<maxbuffer;i++){out[i]=ch[i];}cout<<"请确认您输入的表达式："; while(out[j]!='#'){cout<<out[j];j++;}cout<<'#'<<endl;display_out(s,out);//caculate_array;}char display_out(char out_ch[32],char ch[]) {int top=-1;int i=0,data[maxbuffer],n;int j=0;char sta[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]=='*'&&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<<"错误: 第"<<j<<"个位置的")"没有找到与之匹配的"(""; ch[i]='#';j=0;}else{//while(sta[top]!=‘(‘){out_ch[j]=sta[top];top--;j++;//}break;}break;/*case ‘#‘: out_ch[j]=‘#‘;j++;break;*/default:cout<<" your input is error"<<endl; ch[i]='#';j=0;break;}}}while(top!=-1){out_ch[j]=sta[top];j++;top--;}out_ch[j]='#';n=0;cout<<"逆波兰表达式为: ";while(out_ch[n]!='#'){cout<<out_ch[n];n++;}cout<<endl;j=0;return out_ch[maxbuffer];}五、实验结果：要求：自己给出3个测试用例，观察结果。
哈工大威海编译原理实验三语义分析与中间代码生成(DOC X页)
哈工大威海编译原理实验三语义分析与中间代码生成（DOCX页）哈尔滨工业大学(威海)计算机学院编译原理实验报告姓名院系计算机学院学号 090410任课教师指导教师实验地点宋健二楼机房实验时间实验三语义分析及中间代码生成实验名称同组人无预习报告(对实验主要内容的认识) 得分(1) 通过本次试验，我应该加深对于编译原理制导方案的理解，并且加深对于语法变换的所起到的作用;(2) 对于试验中要用到得中间代码的格式规范，也应该进一步的分析和掌握(3) 能够很好的使用到前面开发出来的词法分析器和语法分析器，将它们与语义分析器结合起来，跟好的更系统的掌握编译原理这门专业技能 (4) 关于符号表以及token串表的维护，现在终于使其有所作用实验内容(问题，思路，程序，结果) 得分(1)开发环境:vs2010(2)输入:在运行打开的软件下(win32格式)，输入相应的代码(即要进行词法分析的字符串)(比如:int a;)(3)输出:在输入字符串后，按回车键后，既可以得到相应的词法分析的结果(比如:int a 的输入对应的输出如下:int a;首先对于词法分析打印出:Int --- key //关键字A ---str //字符串; ---bor //边界符号对于语法分析:Accept //编译语句分析成功对于输入字符串的语义分析和中间代码的生成如下中间代码:)(4)在相应的运行程序的文件夹中生成一个txt文件，用来存储生成的Token 链表(5)系统功能:(2) 开发平台(操作系统、设计语言):1、操作系统:windows 72、设计语言:c++3、编译器:vs2010(3) 设计方案;1) 主数据流图开始词法分析Token表的生成及修改语法分析修改token表语义分析语句是否为变量声明对语句按照文法的action表进行归约加一个四元式结点向下进行语义分析生成中间代码结束2) 主要数据结构:符号表、TOKEN串表等。
语义分析及中间代码生成程序设计原理与实现技术--实验报告及源代码-北京交通大学
语义分析及中间代码生成程序设计原理与实现技术XXX 1028XXX2 计科1XXX班1.程序功能描述完成以下描述赋值语句和算术表达式文法的语法制导生成中间代码四元式的过程。
G[A]:A→V:=EE→E+T∣E-T∣T→T*F∣T/F∣FF→(E)∣iV→i说明：终结符号i 为用户定义的简单变量,即标识符的定义。
2. 设计要求（1）给出每一产生式对应的语义动作；（2）设计中间代码四元式的结构（暂不与符号表有关）。
（3）输入串应是词法分析的输出二元式序列，即某算术表达式“实验项目一”的输出结果。
输出为输入串的四元式序列中间文件。
（4）设计两个测试用例（尽可能完备），并给出程序执行结果四元式序列。
3.主要数据结构描述：本程序采用的是算符优先文法，文法以及算符优先矩阵是根据第四次实验来修改的，所以主要的数据结构也跟第四次差不多，主要为文法的表示，FirstVT集和LastVT集以及算符优先矩阵：算符优先矩阵采用二维字符数组表示的：char mtr[9][9]; //算符优先矩阵4.程序结构描述：本程序一共有8功能函数：void get(); //获取文法void print(); //打印文法void fun(); //求FirstVT 和 LastVTvoid matrix(); //求算符优先矩阵void test(); //测试文法int cmp(char a,char b); 比较两个运算符的优先级 1 0 -1void out(char now,int avg1,int avg2); //打印四元式int ope(char op,int a,int b); //定义四元式计算方法5.实验代码详见附件6.程序测试6.1 功能测试程序运行显示如下功能菜单：选择打印文法：选择构造FirstVt集和LastVT集：选择构造算符优先矩阵：6.2 文法测试测试1:1+2*3测试2:2+3+4*5+(6/2)7.学习总结本次实验完成了语义及中间代码生成的设计原理与实现，所采用的方法为算符优先分析方法，首先根据文法求出此文法的FirstVT集和LastVT集，然后根据他们求出此文法的算符优先矩阵。
编译原理语义分析与中间代码生成实验报告
编译原理语义分析与中间代码生成实验报告专题6_语法制导翻译程序设计原理与实现技术***-***** 李若森计科1301一、实验目的语法制导的基本概念；目标代码结构分析的基本方法；赋值语句语法制导生成四元式的基本原理和方法；该过程包括语法分析和语义分析过程。
二、实验内容2.1 实验项目完成以下描述赋值语句和算术表达式文法的语法制导生成中间代码四元式的过程。
G[A]:A→V=EE→E+T|E-T|T T→T*F|T/F|F F→(E)|i V→i2.2 设计说明终结符号i为用户定义的简单变量，即标识符的定义。
2.3 设计要求(1) 设计语法制导翻译过程，给出每一产生式对应的语义动作；(2) 设计中间代码四元式的结构（暂不与符号表有关）；(3) 输入串应是词法分析的输出二元式序列，即某算术表达式“专题1”的输出结果。
输出为输入串的四元式序列中间文件；(4) 设计两个测试用例（尽可能完备），并给出程序执行结果。
2.4 任务分析重点解决赋值语句文法的改写和语义动作的添加。
三、实现过程3.1 扩展文法G[s]:S→AA→V=EE→E+T|E-T|T T→T*F|T/F|F F→(E)|i V→i3.2 非终结符FOLLOW集FOLLOW(S) = { # } FOLLOW(A) = { # } FOLLOW(V) = { = }FOLLOW(E) = { +, -, ), # }FOLLOW(T) = { +, -, *, /, ), # } FOLLOW(F) = { +, -, *, /, ), # }3.3 LR(0)分析器的构造设DFA M的一个状态为i，该状态识别出的所有活前缀的有效项目集为Ci。
则DFA M的状态集Q={C0, C1, C2, … , Cn}=C。
C称为文法的LR(0)有效项目集规范族。
对Ci有三种操作：求文法的LR(0)有效项目集规范族C的算法：由上述算法可求得有效项目集规范族C={C0, C1, C2, … , C19}。
实验 6 简单中间代码生成
实验 6 简单中间代码生成1、实验目的：综合运用所学知识，集成词法分析、符号表管理等程序的成果，在语法分析和文法属性计算的基础上，完成中间代码的生成工作。
让学生全面了解一个编译器工作的全过程，真正全面掌握编译的思想和方法。
2、实验的基本原理对于一个给定文法，通过改写文法，使其满足LR（1）文法的要求，根据语义确定文法符号的属性，确定语义规则或翻译方案；根据文法特点构造LR(1)分析表，进而构造语法分析和属性计算程序。
分析程序在分析表的驱动下，完成对给定的句子进行语法分析和属性计算工作，最后生成三地址中间代码序列。
3、实验内容及要求a.实验所用文法如下。
statmt → id = expexp → exp addop term | termaddop →+ | -term→ term mulop factor | factormulop → * | /factor → ( exp ) | id | num其中id和num为实验二中定义的标识符和常数，因此这里还需要一个小的词法分析器来得到id和num。
b.构造文法LR（1）项目集，构造ACTION和GOTO矩阵，确认文法满足LR（1）文法要求。
c.按一般高级语言赋值语句的计算要求定义文法的属性和语义规则，属性计算的结果是将给定赋值语句翻译成三地址代码序列，并输出此序列。
d.从数据文件中读出赋值语句，并对其进行语法分析，对合法语句，输出其翻译结果。
e.实验数据文件中应该有多个语句，可能有正确的也应该有错误的语句；语句中的表达式有形式简单的也应该有复杂的。
每个表达式写在一行，以$结束。
4、实验步骤准备好用于实验的赋值语句序列，并存储在文件中。
a.编写单词分析子程序，能从源程序中分离出单词（包括标识符和常数）；词法分析器以子程序形式出现，当需要进行词法分析时进行调用；b.构造分析表，确认上述文法为LR（1）文法，定义属性和语义规则。
c.确定临时变量生成方案，构造其生成程序。
中间代码生成实验报告
中间代码生成实验报告中间代码生成实验报告一、引言在计算机编程领域中，中间代码生成是编译器的一个重要阶段。
它将源代码转化为一种中间表示形式，以便于后续的优化和目标代码生成。
本实验旨在通过实现一个简单的中间代码生成器，深入理解编译器的工作原理和中间代码的作用。
二、实验背景中间代码是一种介于源代码和目标代码之间的表示形式。
它通常是一种抽象的、与机器无关的形式，具有较高的可读性和可维护性。
中间代码生成是编译器的一个重要阶段，它将源代码转化为中间代码，为后续的优化和目标代码生成提供基础。
三、实验目的本实验的主要目的是通过实现一个简单的中间代码生成器，加深对编译器工作原理的理解，并掌握中间代码的生成过程。
具体目标包括：1. 学习使用编程语言实现中间代码生成算法；2. 理解中间代码的数据结构和语义；3. 掌握将源代码转化为中间代码的过程；4. 分析和优化生成的中间代码。
四、实验设计与实现本实验采用C++语言实现一个简单的中间代码生成器。
具体步骤如下：1. 词法分析：使用词法分析器对输入的源代码进行扫描，将其划分为一个个的词法单元。
2. 语法分析：使用语法分析器对词法单元进行解析，构建语法树。
3. 语义分析：对语法树进行语义分析，检查语法的正确性，并生成中间代码。
4. 中间代码生成：根据语义分析的结果，生成对应的中间代码。
5. 中间代码优化：对生成的中间代码进行优化，提高执行效率和代码质量。
6. 目标代码生成：将优化后的中间代码转化为目标代码。
五、实验结果与分析经过实验，我们成功实现了一个简单的中间代码生成器，并生成了相应的中间代码。
通过对生成的中间代码进行分析，我们发现其中存在一些冗余和不必要的指令，可以进一步进行优化。
例如，可以通过常量折叠、死代码删除等技术，减少中间代码的长度和执行时间。
六、实验总结通过本次实验，我们深入理解了中间代码生成的过程和作用，并通过实践掌握了中间代码生成器的实现方法。
在实验过程中，我们遇到了一些困难和挑战，但通过不断的学习和尝试，最终取得了满意的结果。
编译原理综合性实验报告-分析中间代码生成程序分析
编译原理综合性实验报告-分析中间代码⽣成程序分析编译原理综合性实验报告-分析中间代码⽣成程序分析XXXXXX计算机系综合性实验实验报告课程名称编译原理实验学期 XXXX ⾄ XXXX 学年第 X 学期学⽣所在系部计算机系年级 X 专业班级 XXXXXX 学⽣姓名 XXX学号 XXXXXXXXXXXX 任课教师XXX 实验成绩计算机系制《编译原理》课程综合性实验报告开课实验室: 年⽉⽇实验题⽬分析中间代码⽣成程序⼀、实验⽬的分析PL/0编译程序的总体结构、代码⽣成的⽅法和过程;具体写出⼀条语句的中间代码⽣成过程。
⼆、设备与环境PC兼容机、Windows操作系统、Turbo Pascal软件等。
三、实验内容1. 分析PL/0程序的Block⼦程序，理清PL/0程序结构和语句格式。
画出Block⼦程序的流程图，写出⾄少两条PL/0程序语句的语法格式。
2. 分析PL/0程序的Block⼦程序和Gen⼦程序，了解代码⽣成的⽅法和过程。
使⽤概要算法来描述语句的代码⽣成过程。
3. ⾃⼰编写⼀个简单的PL/0程序，能够正确通过编译，得到中间代码。
列出⾃⼰编写的源程序和编译后得到的中间代码。
4. 从中选择⼀个语句或表达式，写出代码⽣成的过程。
要求从⾃⼰的源程序中选择⼀条语句，结合这条语句写出语义分析和代码⽣成过程。
在描述这个过程中，要说清楚每个功能有哪个⼦程序的哪条语句来完成，说清楚语句和参数的含义和功能。
四、实验结果及分析(⼀)Block⼦程序分析1.常量声明的分析:常量声明部分的语法结构定义为如下形式:-> const ;-> [;]->id = C其中C可以是常量标识符或字符串或整数(可带符号)或实数(可带符号)。
常量声明分析程序的主要任务是:(1).扫描整个常量声明部分。
(2).为被声明的常量标识符建⽴符号表项。
(3).检查重复的声明。
2.变量声明部分的分析:变量声明部分的语法结构定义为如下形式:-> var-> [;]->:T->id[,]其中idList是被定义的变量标识符序列，T是类型表达式。
实验-中间代码生成
四、程序实现（续） ： 2.代码设计 :
void Syntax::E() { T(); while (Token.code==9||Token.code==10) { sExam.Read(&Token); //read(w) T(); output(exp_operator[--top]); } }
NEXT(w)
F •R5
output(*)
F •R6
output(/)
NEXT(w)
E •R7 ) y
n
err2
出口
出口
Ri 返回地址
四、程序实现 ： 1.数据结构 :
SemRecord ID[10]; int m=0; double Cons[10]; int n=0; TokenType pos[20]; int num=0; //符号表 //标识符个数 //常数表 //常数个数 //逆波兰式区 //元素个数
Syntax s(ID,&m,Cons,&n,pos,&num); //语法分析类对象x { private: TokenType *p_pos; int *p_num; TokenType Token; Scan sExam; //语法分析类，递归子程序分析 //逆波兰式区指针 //单词Token //扫描器对象
例如，对于符号串 a*(b+c)的分析(翻译)过程，可得出： 导出序列： a{a}*(b{b}+c{c}{+}){*} ※ 分解导出序列：
去掉动作符号： a*(b+c) ………. 源表达式； 去掉文法符号： abc+* ………. 逆波兰式；
算法设计：
主 程 序
Z 开始 初始化 NEXT(w) 入口 T •R1 + y
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一、实验目的通过在实验二的基础上，增加中间代码生成部分，使程序能够对实验二中的识别出的赋值语句，if语句和while语句进行语义分析，生成四元式中间代码。
二、实验方法实验程序由c语言完成，在Turboc 2.0环境中调试通过。
语义分析程序的基本做法是对文法中的每个产生式分别编写一个语义分析子程序，当程序语法部分进行推倒或规约时，就分别调用各自的语义分析程序。
当语法分析结束时，语义分析也就结束了。
在本实验程序中，当语法分析部分识别出语法正确的句子时，就进入content函数（当语法分析识别出不正确的句子时，不进入content函数，也就是不进行语义分析），然后根据句子的类型进行分类，进入不同的语义处理部分。
对于赋值语句，关键是产生正确的处理算术表达式E的四元式。
程序中的ec函数的功能就是产生算术表达式的四元式，在ec函数中使用了两个栈idshed，opshed，分别是算术表达式的数据栈和符号栈。
每次提取一个数字和一个算符，然后将算符与与栈顶算符进行优先级比较，优先级高则将单前数字和算符进栈，低或者相等的话则将当前栈顶元素进行合并，产生四元式。
直至整个算术表达式结束。
其中还有一些细节问题，具体的做法可以参看程序。
对于实验给定的if语句的文法格式，条件判断式C只中可能是>或者<=两种关系，不可能是布尔表达式，这样程序就简单的多了。
通过ec函数可以产生条件判断式C中的E的四元式，然后只要加上转向四元式就可以了。
本实验程序中只给出真出口的转向四元式，没有给出假出口的转向四元式，这在实际中是不可以的，但在本实验中，实际上是对每条独立的语句进行语法分析，给出假出口转向四元式实际上意义不大，而且假出口转向语句的转移目标必须要到整个语句分析结束以后才可以知道，这样就要建立栈，然后回填，这样会使程序复杂很多，所以没有加上假出口转向四元式。
对于while语句，具体的做法和if语句差不多，所不同的是当while语句结束时，要多出一条无条件转向四元式，重新转到条件判断式C的第一条四元式。
当要产生无条件转向四元式时，它的转向目标C的第一条四元式已经产生了，所以具体的做起来是不太困难的。
只要记下当前while中的C的第一条四元式的位置，填上就可以了。
整个程序的结束是当读入“ . ”时，程序就中止。
程序中还有很多细节问题，具体的可以后面的附录：程序的完整代码。
三、测试程序ff:=6+6*6-;if sl>89+56*67then f:=7*7+4;ff:=6+6*6-6%4+8;if sl+78*76>89*56+67then while a-7>98+45*45 do f:=7*7+4;.四、运行结果首先对测试程序进行语法分析，识别出正确的句子，当识别出正确的句子时，就对当前句子进行语义分析，而语法不正确的句子不进行语义分析。
ff:=6+6*6- Error(4):Except ID or NUM; Error(2):Syntax errorif sl>89+56*67 then f:=7*7+4; success!!!(1) [ *, 56, 67, T1 ](2) [ +, 89, T1, T2 ](3) [j>, sl, T2, (4) ](4) [ *, 7, 7, T3 ](5) [ +, T3, 4, T4 ](6) [ :=, T4, -, f ]ff:=6+6*6-6%4+8; success!!!(7) [ *, 6, 6, T5 ](8) [ +, 6, T5, T6 ](9) [ %, 6, 4, T7 ](10) [ -, T6, T7, T8 ](11) [ +, T8, 8, T9 ](12) [ :=, T9, -, ff ]if sl+78*76>89*56+67 then while a-7>98+45*45 do f:=7*7+4; success!!!(13) [ *, 78, 76, T10 ](14) [ +, sl,T10, T11 ](15) [ *, 89, 56, T12 ](16) [ +,T12, 67, T13 ](17) [j>, T11, T13, (18) ](18) [ -, a, 7, T14 ](19) [ *, 45, 45, T15 ](20) [ +, 98,T15, T16 ](21) [j>, T14, T16, (22) ](22) [ *, 7, 7, T17 ](23) [ +,T17, 4, T18 ](24) [ :=, T18, -, f ](25) [j, _, _, (18)]. Error(2):Syntax error五、实验小结终于完成了编译原理的三次实验，这几次实验使我们更彻底地巩固了编译原理。
从詷法分析到语法分析直到这次的中间代码都是看似简单的基础知识，却花了不少时间对课本多次反复研究、请教学习，进行深层次地探讨才找出编程时出现的种种问题。
还有很多程序方面很细节的问题，很容易被突略，却往往又是关键。
总地来说，虽然实验做得很辛苦，但真的可以从实验当中学习到很多，认识到很多。
并对编译理解也透彻了许多，比较清晰地掌握了编译程序的原理和方法。
附录：#include<string.h>#include<stdio.h>#include<stdlib.h>#define reser 20char *charstring="abcdefghijklmnopqrstuvwxyz";char *numstring="0123456789";char *strstring="abcdefghijklmnopqrstuvwxyz0123456789";char reserve[reser][10];char idshed[40][10],opshed[40][10];char token[15],id[15],sym[15];char line[80],tempp[240];char ch,ch1,temp,tem;char tx[10];char tn[4],signt1[20],signt2[20],ju[20];int cc,ii,k,num,kind,t,e4=0,e3=0,judge=1,row1=0;int startc,idsh=0,opsh=0,tt=1,nn=1,signwh,over=0,adds=0,whs=0,pp=0;int li=0;char filename[15];FILE *fp;void getch(){if(li==0) {if (cc==ii){cc=1; ii=0;if (row1==1) fseek(fp,-1,1); /*读行首字符将指针退回一格，若是整个文本的开头，则不需要*/line[0]=fgetc(fp);row1=1;while(((temp=fgetc(fp))!='\n') && (temp!=EOF)){ line[cc]=temp;cc++;tempp[pp]=temp;pp++;}line[cc]=' '; /*将缓冲带后加上一个空字符，以便行和行之间号区分*/cc++;tempp[pp]=' ';pp++;while(((temp=fgetc(fp))=='\n') && (temp!=EOF)); /* 跳过空行*/line[cc]='\0';}tem=line[ii];ii++;ch=tem;}else{ch=tempp[pp];pp++;}}void getnbc(){getch();while (ch==' ')getch();if (ch=='{'){do{getch();}while( ch=='}');getnbc();}}void retract(){ii--;}void ret(){pp--;}int jchar(char ch){ /* 判断ch是不是字母*/ if(strchr(charstring,ch)==0)return 0;else return 1;}int jnum(char ch){ /* 判断ch是不是数字*/ if(strchr(numstring,ch)==0)return 0;else return 1;}int jstr(char ch){ /* 判断ch是不是字母或数字*/ if(strchr(strstring,ch)==0)return 0;else return 1;}void advance(){getnbc();kind=0;if (jchar(ch)==1){k=0;do {if(k<15){ token[k]=ch; k++;}getch(); }while(jstr(ch)==1);if (li==0)retract();else ret();token[k]='\0'; /*截去token中的无用字符*/strcpy(id,token);for(t =0;t<=20;t++){if(strcmp(reserve[t],id)==0)break;}if ( t<=20 ) kind=t ;else kind=21;strcpy(sym,id);}elseif (jnum(ch)==1){k=0;do{if ( k<15 ) {token[k]=ch; k++;}getch();}while( jstr(ch)==1);if (li==0)retract();else ret();kind=22;token[k]='\0';strcpy(sym,token);}else{if(ch=='.') kind=26;k=0;do{sym[k]=' '; k++;}while(k!=15);sym[0]=ch;sym[1]='\0';}}void error(int n){judge=0; /*出错退出，将judge＝0*/switch(n){case 0:{printf(" Error(0):Expect ':' \n"); break;}case 1:{printf(" Error(1):Expect '=' \n"); break;}case 2:{printf(" Error(2):Syntax error \n");break;}case 3:{printf(" Error(3):Except Operater \n");break;}case 4:{printf(" Error(4):Except ID or NUM \n");break;}case 5:{printf(" Error(5):Except ';' \n");break;}case 6:{printf(" Error(6):Except '<' or '>'\n");break;}case 7:{printf(" Error(7):Except '=' \n" );break;}case 8:{printf(" Error(8):Except 'then' \n");break;}case 9:{printf(" Error(9):Except Condition Expression\n ");break;}case 10:{printf(" Error(10):Except 'do' ");break;}default:; }}void e(){advance();if((strcmp(sym,"+")==0)||(strcmp(sym,"-")==0)||(strcmp(sym,"*")==0)||(strcmp(sym,"%")==0)){ printf("%s",sym);advance();if((kind==21) || (kind==22)){ /* kind为21，22分别表示的是标志符和数字*/ printf("%s",sym);e();}else { e4=1 ;error(4);} } /*出错退出，e4=1*/}void c(){advance();if((kind==21) || (kind==22)){printf("%s",sym);e();if(e4==1); /*e4的作用是判断程序从e()中是不是出错退出*/ else {if(strcmp(sym,">")==0){printf("%s",sym);advance();if((kind==21) || (kind==22)) {printf("%s",sym);e();}else{error(4);}}else {if(strcmp(sym,"<")==0){printf("%s",sym);advance();if(strcmp(sym,"=")==0){printf("%s",sym);advance();if((kind==21) || (kind==22)){printf("%s",sym);e();}else{error(4);}} else{error(7);}} else{error(6);}}}}else{e3=1; error(9);} /*出错退出，e3=1*/}void statement(){if(judge==1) /*judge的作用为判断程序是不是出错退出，若是，则无需advance()*/advance();switch (kind){case 21:{ /* id */printf("%s",sym);advance();if(strcmp(sym,":")==0){ printf("%s",sym);advance();if(strcmp(sym,"=")==0){printf("%s",sym);advance();if((kind==21) || (kind==22)){printf("%s",sym);e();if(e4==1) ;else{if(strcmp(sym,";")==0){printf("%s",sym);judge=1;printf(" success!!!\n");startc=1;}else error(5); }e4=0; /*将e4重新置为0，以免对下面程序有影响*/}else error(4);} else{ error(1);}} else { error(0);}break;}case 8:{ printf("%s ",sym); /* if */c();if(e4==1);else{ if(e3==1); /*e3的作用是判断程序从c()中是不是出错退出*/ else{if(strcmp(sym,"then")==0){printf(" %s ",sym);statement();}else{error(8);}}e3=0; /*将e3重新置为0，以免对下面程序有影响*/}e4=0;break;}case 19:{ /* while */printf("%s ",sym);c();if(e4==1);else{ if(e3==1);else{if(strcmp(sym,"do")==0){printf(" %s ",sym);statement();}else{error(10);}}e3=0;}e4=0;break;}default: { printf("%s ",sym);error(2);judge=1;break;} }}void pushid(){strcpy(idshed[idsh],sym);idsh++;}void pushop(){strcpy(opshed[opsh],sym);opsh++;}void gen(char op[10],char a[10],char b[10]){printf("(%d) [ %2s,%3s,%3s, T%d ]\n",nn,op,a,b,tt);tt++;nn++;itoa(tt-1,tn,10);strcpy(tx,"T");strcat(tx,tn);}void ec(){advance();pushop();advance();pushid();if((strcmp(opshed[opsh-1],"*")==0)||(strcmp(opshed[opsh-1],"%")==0)){gen(opshed[opsh-1],idshed[idsh-2],idshed[idsh-1]);opsh--;idsh=idsh-1;strcpy(idshed[idsh-1],tx);} else{if((strcmp(opshed[opsh-1],"+")==0)||(strcmp(opshed[opsh-1],"-")==0)){ adds=1;if((strcmp(opshed[opsh-2],"+")==0)||(strcmp(opshed[opsh-2],"-")==0)){gen(opshed[opsh-2],idshed[idsh-3],idshed[idsh-2]);strcpy(idshed[idsh-2],tx);}} }advance();if((strcmp(sym,"+")==0)||(strcmp(sym,"-")==0)||(strcmp(sym,"*")==0)||(strc mp(sym,"%")==0)){if (li==0)retract();else ret();ec(); }}void content(){int reu;reu=nn;switch(kind){ case 21:{advance();advance();advance();pushid();advance();if((strcmp(sym,"+")==0)||(strcmp(sym,"-")==0)||(strcmp(sym,"*")==0)||(strcmp (sym,"%")==0)){if (li==0)retract();else ret();ec();if (adds==1)gen(opshed[opsh-1],idshed[idsh-2],idshed[idsh-1]);adds=0;printf("(%d) [ :=, %s, -, %s ]\n",nn,tx,idshed[0]);nn++;idsh=0;opsh=0;}else{printf("(%d) [ :=, %s, -, %s ]\n",nn,idshed[1],idshed[0]);nn++;}break;}case 8:{idsh=0;opsh=0;advance();pushid();advance();if((strcmp(sym,"+")==0)||(strcmp(sym,"-")==0)||(strcmp(sym,"*")==0)||(strcmp( sym,"%")==0)){if (li==0)retract();else ret();ec();if(adds==1)gen(opshed[opsh-1],idshed[idsh-2],idshed[idsh-1]);adds=0;strcpy(signt1,tx);idsh=0;opsh=0;}else{strcpy(signt1,idshed[0]);}if(strcmp(sym,">")==0)strcpy(ju,"j>");else{strcpy(ju,"j<=");advance();}idsh=0;advance();pushid();advance();if((strcmp(sym,"+")==0)||(strcmp(sym,"-")==0)||(strcmp(sym,"*")==0)||(strcmp( sym,"%")==0)){if (li==0)retract();else ret();ec();if (adds==1)gen(opshed[opsh-1],idshed[idsh-2],idshed[idsh-1]);adds=0;strcpy(signt2,tx);idsh=0;opsh=0;}else{strcpy(signt2,idshed[0]);}printf("(%d) [%s, %s, %s, (%d) ]\n",nn,ju,signt1,signt2,nn+1);nn++;advance();idsh=0;opsh=0;if(kind==21) pushid();content();break;}case 19:{opsh=0;advance();pushid();advance();if((strcmp(sym,"+")==0)||(strcmp(sym,"-")==0)||(strcmp(sym,"*")==0)||(strcmp( sym,"%")==0)){if (li==0)retract();else ret();ec();if(adds==1)gen(opshed[opsh-1],idshed[idsh-2],idshed[idsh-1]);adds=0;strcpy(signt1,tx);idsh=0;opsh=0;}else{strcpy(signt1,idshed[0]);}if(strcmp(sym,">")==0)strcpy(ju,"j>");else{strcpy(ju,"j<=");advance();}idsh=0;opsh=0;advance();pushid();advance();if((strcmp(sym,"+")==0)||(strcmp(sym,"-")==0)||(strcmp(sym,"*")==0)||(strcmp( sym,"%")==0)){if (li==0)retract();else ret();ec();if (adds==1)gen(opshed[opsh-1],idshed[idsh-2],idshed[idsh-1]);adds=0;strcpy(signt2,tx);idsh=0;opsh=0;}else{strcpy(signt2,idshed[0]);}printf("(%d) [%s, %s, %s, (%d) ]\n",nn,ju,signt1,signt2,nn+1);nn++;advance();idsh=0;opsh=0;if(kind==21) pushid();content();printf("(%d) [j, _, _, (%d)]\n",nn,reu);nn++;break; }default:{break; }}}main(){strcpy(reserve[8],"if");strcpy(reserve[19],"while");strcpy(reserve[4],"do");strcpy(reserve[16],"then");printf("Please Input Source Program Filename:");scanf("%s",filename);fp=fopen(filename,"r");cc=0;ii=0;ch='\0';while (kind!=26) /*kind==26为读到了'.'，程序结束*/ {startc=0;pp=0;statement();li=1;if(startc==1){pp=0;advance();pushid();content(); }li=0;}}。