编译原理语义分析实验报告
北邮 编译原理 语义分析实验报告
编译原理第六章语义分析目录1. 实验题目和要求 (2)2. 实验分析和思考 (3)3. 翻译方案 (4)4. LR实现自底向上分析（摘自语法分析实验） (5)4.1.构造识别所有活前缀的DFA (5)5.1. 扩充分析栈 ................................................................................................................ 7 5.2. 改造分析程序 ............................................................................................................ 7 5.3. 编程实现 .................................................................................................................... 76.运行结果截图： (13)1. 实验题目和要求题目：语义分析程序的设计与实现。
实验内容：编写语义分析程序，实现对算术表达式的类型检查和求值。
要求所分析算术表达式由如下的文法产生。
numE idF F F T F T T T T E T E E |)(||/|*||→→-+→ 实验要求：用自底向上的语法制导翻译技术实现对表达式的分析和翻译。
(1) 写出满足要求的语法制导定义或翻译方案。
(2) 编写分析程序，实现对表达式的类型进行检查和求值，并输出： ① 分析过程中所有产生式。
② 识别出的表达式的类型。
③ 识别出的表达式的值。
(3) 实验方法：可以选用以下两种方法之一。
① 自己编写分析程序。
② 利用YACC 自动生成工具。
2.实验分析和思考由于要求进行类型检查和求值，所以可以定义两个综合属性，一个记录值一个记录类型，存放在结构中，一并传入传出。
编译原理实验报告
编译原理实验报告一、实验目的和要求本次实验旨在对PL_0语言进行功能扩充，添加新的语法特性，进一步提高编译器的功能和实用性。
具体要求如下：1.扩展PL_0语言的语法规则，添加新的语法特性；2.实现对新语法的词法分析和语法分析功能；3.对扩展语法规则进行语义分析，并生成中间代码；4.验证扩展功能的正确性。
二、实验内容1.扩展语法规则本次实验选择扩展PL_0语言的语句部分，添加新的控制语句，switch语句。
其语法规则如下：<switch_stmt> -> SWITCH <expression> CASE <case_list><default_stmt> ENDSWITCH<case_list> -> <case_stmt> ， <case_stmt> <case_list><case_stmt> -> CASE <constant> : <statement><default_stmt> -> DEFAULT : <statement> ，ε2.词法分析和语法分析根据扩展的语法规则，需要对新的关键字和符号进行词法分析，识别出符号类型和记号类型。
然后进行语法分析，建立语法树。
3.语义分析在语义分析阶段，首先对switch语句的表达式进行求值，判断其类型是否为整型。
然后对case语句和default语句中的常量进行求值，判断是否与表达式的值相等。
最后将语句部分生成中间代码。
4.中间代码生成根据语法树和语义分析的结果，生成对应的中间代码。
例如，生成switch语句的跳转表，根据表达式的值选择相应的跳转目标。
5.验证功能的正确性设计一些测试用例，验证新语法的正确性和扩展功能的实用性。
三、实验步骤与结果1.扩展语法规则，更新PL_0语法分析器的词法规则和语法规则。
编译原理实验报告 语义分析
.编译原理课程实验报告实验3：语义分析. .. ...要求：对如下工作进行展开描核心数据结构的设(1Nod本程序使用了两个新的实体类，分别I的属性I是标识符里面也包含了该标识符在本程序中存储的地址和长度等信息I下/privat String name;/基本类privat String type/起始地privatin offset/长in length privat/该数组各维的长publi List<Integer> arr_length得/变量的维度可以根arr_length.size(的属性如下Nod是语法生成树的节点Nod节点/privat String nam父节/privat Node fathe/子节publi List<Node>son/属Map<String,String>attribut publi使用哈希表这是因为各个节点的属性不是统一的的类型是哈Ma其atrribut以方便地创建、使用属性主要功能函数说(2因为语义分析过程与语法分析同步进此次试验的语义分析部分并没有新的功能函数文法符号匹配的过程中，插入语义的，代码都是在第二次第二次实验的基础上，LL(l的功能发作代码。
所以，只有句法分析函analysis(List<Token> token_list了变化，添加了语义分析的功能，其他函数功能基本与实验二相同(3程序核心部分的程序流程图..是否否是否是3-1图四、实验结果及分析得分..要求：对实验结果进行描述和分析，基本内容包括针对一测试程序输出其语义分析结果输出针对此测试程序对应的语义错误报告输出针对此测试程序经过语义分析后的符号表对实验结果进行分析注：其中的测试样例需先用已编写的词法分析程序进行处理测试程序void main () {double d;int a[2][3];d = 0;a[0][1] = 2;if (d == 0) {a[0][1] = d;}else {a[1][1] = 0;}while (a[0][1]<3) {++a[0][1];}}分析结果以及错误报告：. .4-1 图标识符表：4-2图实验结果分析：. ..。
编译原理实验报告
编译原理实验报告一、实验目的本次编译原理实验的主要目的是通过实践加深对编译原理中词法分析、语法分析、语义分析和代码生成等关键环节的理解，并提高实际动手能力和问题解决能力。
二、实验环境本次实验使用的编程语言为 C/C+＋，开发工具为 Visual Studio 2019，操作系统为 Windows 10。
三、实验内容（一）词法分析器的设计与实现词法分析是编译过程的第一个阶段，其任务是从输入的源程序中识别出一个个具有独立意义的单词符号。
在本次实验中，我们使用有限自动机的理论来设计词法分析器。
首先，我们定义了单词的种类，包括关键字、标识符、常量、运算符和分隔符等。
然后，根据这些定义，构建了相应的状态转换图，并将其转换为程序代码。
在实现过程中，我们使用了字符扫描和状态转移的方法，逐步读取输入的字符，判断其所属的单词类型，并将其输出。
（二）语法分析器的设计与实现语法分析是编译过程的核心环节之一，其任务是在词法分析的基础上，根据给定的语法规则，判断输入的单词序列是否构成一个合法的句子。
在本次实验中，我们采用了自顶向下的递归下降分析法来实现语法分析器。
首先，我们根据给定的语法规则，编写了相应的递归函数。
每个函数对应一种语法结构，通过对输入单词的判断和递归调用，来确定语法的正确性。
在实现过程中，我们遇到了一些语法歧义的问题，通过仔细分析语法规则和调整函数的实现逻辑，最终解决了这些问题。
（三）语义分析与中间代码生成语义分析的任务是对语法分析所产生的语法树进行语义检查，并生成中间代码。
在本次实验中，我们使用了四元式作为中间代码的表示形式。
在语义分析过程中，我们检查了变量的定义和使用是否合法，类型是否匹配等问题。
同时，根据语法树的结构，生成相应的四元式中间代码。
（四）代码优化代码优化的目的是提高生成代码的质量和效率。
在本次实验中，我们实现了一些基本的代码优化算法，如常量折叠、公共子表达式消除等。
通过对中间代码进行分析和转换，减少了代码的冗余和计算量，提高了代码的执行效率。
语义分析实验报告
云南大学编译原理实验报告实验题目：语义分析学院：信息学院专业：计算机科学与技术学号： 20091060064姓名：刘继远目录一、实验目的 0二、实验内容 0三、源程序分析 (2)1、程序采用的BNF (2)2、根据语义要求得到对应的翻译模式 (3)3、实现原理 (4)4、文法的属性分析 (4)5、过程设计 (5)6、子程序说明 (6)四、设计的基本思想（包括修改之后的属性文法、属性类型分析、翻译模式） (6)1、增加除法运算 (7)2、禁止同名重复声明 (8)五、结果及分析 (8)一、实验目的进一步理解递归下降分析原理和实现方法，理解语义分析的基本机制，掌握语义子程序的构造方法。
二、实验内容将带变量声明的表达式翻译为四元式序列，其中包括以下要求：非终结符号D实现定义两种类型int, real变量的声明；非终结符号S实现变量之间的*，+，: =(赋值运算)两个关键字 int 和real变量之间的*，+，: =(赋值) 运算只能使用声明过的变量，所以要检查使用的变量是否声明过。
对每个*，+，: =(赋值) 运算生成一条四元式如（*，A，B，T1），其中T1是临时变量*优先级别高于+，*满足左结合规则三、源程序分析这是一个简单的包含词法、语法、语义分析的程序：语义分析.h和语义分析.cpp。
实现的基本原理是自顶向下分析，单遍扫描，以语法分析为核心，调用词法分析，并实现语义分析。
1、程序采用的BNFP→ DS.D→B; DD→εB→int L | real LL→id | L，idS→ V := E HH→；S | εE→E+T | TT→T*F|FF→( E )F→idV→id消除左递归之后的等价文法start→ DS.D→B; DD→εB→int L | real LL→id AA→ ，idAA→εS→ V := E HH→；S | εE→T RR→+T RR→εT→F PP→* F PP→εF→( E )F→idV→id2、根据语义要求得到对应的翻译模式start→ DS.D→ B; DD→εB→ int L { L.type := int } | real L { L.type := real }L→ id { A.Type := L.type enter(v.entry, L.type)}AA→ ，idA { A1.Type := A.type enter(v.entry,A.type)}A→εS→ V := E { gen( ":=", E.place,0,V.place) } HH→；S | εE→T { R.i:=T.place} R {E.place:=R.s}R→+T { R1.i:= newtemp; gen( "+", R.i, T.place , R1.i) } R {R.s:= R1.s; }R→ ε {Rs=R.i}T→F { P.i:=F.place} P { T.place:=P.s}P→* F { p1.i:= newtemp; gen( "*", P.i, F.place , T) } P {P.s:=p1.s; }P→ε {P.s=P.i}F→( E ) { F.place := E.place}F→id {F.place:=position (id)}V→id {V.place:=position(id)}3、实现原理基于翻译模式的自上而下语义处理（翻译）1.对每个非终结符 A，构造一个函数，以 A 的每个继承属性为形参，以A的综合属性为返回值（若有多个综合属性，可返回记录类型的值）。
编译原理实验报告
编译原理实验报告一、实验目的编译原理是计算机科学中的重要学科，它涉及到将高级编程语言转换为计算机能够理解和执行的机器语言。
本次实验的目的是通过实际操作和编程实践，深入理解编译原理中的词法分析、语法分析、语义分析以及中间代码生成等关键环节，提高我们对编译过程的认识和编程能力。
二、实验环境本次实验使用的编程语言为C+＋，开发环境为Visual Studio 2019。
此外，还使用了一些相关的编译工具和调试工具，如 GDB 等。
三、实验内容（一）词法分析器的实现词法分析是编译过程的第一步，其任务是将输入的源程序分解为一个个单词符号。
在本次实验中，我们使用有限自动机的理论来设计和实现词法分析器。
首先，定义了各种单词符号的类别，如标识符、关键字、常量、运算符等。
然后，根据这些类别设计了相应的状态转换图，并将其转换为代码实现。
在实现过程中，使用了正则表达式来匹配输入字符串中的单词符号。
对于标识符和常量等需要进一步处理的单词符号，使用了相应的规则进行解析和转换。
（二）语法分析器的实现语法分析是编译过程的核心环节之一，其任务是根据给定的语法规则，分析输入的单词符号序列是否符合语法结构。
在本次实验中，我们使用了递归下降的语法分析方法。
首先，根据实验要求定义了语法规则，并将其转换为相应的递归函数。
在递归函数中，通过对输入单词符号的判断和处理，逐步分析语法结构。
为了处理语法错误，在分析过程中添加了错误检测和处理机制。
当遇到不符合语法规则的输入时，能够输出相应的错误信息，并尝试进行恢复。
（三）语义分析及中间代码生成语义分析的目的是对语法分析得到的语法树进行语义检查和语义处理，生成中间代码。
在本次实验中，我们使用了三地址码作为中间代码的表示形式。
在语义分析过程中，对变量的定义和使用、表达式的计算、控制流语句等进行了语义检查和处理。
对于符合语义规则的语法结构，生成相应的三地址码指令。
四、实验步骤（一）词法分析器的实现步骤1、定义单词符号的类别和对应的正则表达式。
编译原理语义分析实验报告
实验3 语义分析实验报告一、实验目的二、通过上机实习, 加深对语法制导翻译原理的理解, 掌握将语法分析所识别的语法成分变换为中间代码的语义翻译方法。
三、实验要求四、采用递归下降语法制导翻译法, 对算术表达式、赋值语句进行语义分析并生成四元式序列。
五、算法思想1.设置语义过程。
（1）emit(char *result,char *ag1,char *op,char *ag2)该函数的功能是生成一个三地址语句送到四元式表中。
四元式表的结构如下:struct{ char result[8];char ag1[8];char op[8];char ag2[8];}quad[20];(2) char *newtemp()该函数回送一个新的临时变量名, 临时变量名产生的顺序为T1, T2, …char *newtemp(void){ char *p;char m[8];p=(char *)malloc(8);k++;itoa(k,m,10);strcpy(p+1,m);p[0]=’t’;return(p);}六、 2.函数lrparser 在原来语法分析的基础上插入相应的语义动作: 将输入串翻译成四元式序列。
在实验中我们只对表达式、赋值语句进行翻译。
源程序代码:#include<stdio.h>#include<string.h>#include<iostream.h>#include<stdlib.h>struct{char result[12];char ag1[12];char op[12];char ag2[12];}quad;char prog[80],token[12];char ch;int syn,p,m=0,n,sum=0,kk; //p是缓冲区prog的指针, m是token的指针char *rwtab[6]={"begin","if","then","while","do","end"};void scaner();char *factor(void);char *term(void);char *expression(void);int yucu();void emit(char *result,char *ag1,char *op,char *ag2);char *newtemp();int statement();int k=0;void emit(char *result,char *ag1,char *op,char *ag2){strcpy(quad.result,result);strcpy(quad.ag1,ag1);strcpy(quad.op,op);strcpy(quad.ag2,ag2);cout<<quad.result<<"="<<quad.ag1<<quad.op<<quad.ag2<<endl;}char *newtemp(){char *p;char m[12];p=(char *)malloc(12);k++;itoa(k,m,10);strcpy(p+1,m);p[0]='t';return (p);}void scaner(){for(n=0;n<8;n++) token[n]=NULL;ch=prog[p++];while(ch==' '){ch=prog[p];p++;}if((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')){m=0;while((ch>='0'&&ch<='9')||(ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')){token[m++]=ch;ch=prog[p++];}token[m++]='\0';p--;syn=10;for(n=0;n<6;n++)if(strcmp(token,rwtab[n])==0){syn=n+1;break;}}else if((ch>='0'&&ch<='9')){{sum=0;while((ch>='0'&&ch<='9')){sum=sum*10+ch-'0';ch=prog[p++];}}p--;syn=11;if(sum>32767)syn=-1;}else switch(ch){case'<':m=0;token[m++]=ch;ch=prog[p++];if(ch=='>'){syn=21;token[m++]=ch;}else if(ch=='='){syn=22;token[m++]=ch;}else{syn=23;p--;}break;case'>':m=0;token[m++]=ch;ch=prog[p++];if(ch=='='){syn=24;token[m++]=ch;}else{syn=20;p--;}break;case':':m=0;token[m++]=ch;ch=prog[p++];if(ch=='='){syn=18;token[m++]=ch;}else{syn=17;p--;}break;case'*':syn=13;token[0]=ch;break; case'/':syn=14;token[0]=ch;break; case'+':syn=15;token[0]=ch;break; case'-':syn=16;token[0]=ch;break; case'=':syn=25;token[0]=ch;break; case';':syn=26;token[0]=ch;break; case'(':syn=27;token[0]=ch;break; case')':syn=28;token[0]=ch;break; case'#':syn=0;token[0]=ch;break; default: syn=-1;break;}}int lrparser(){//cout<<"调用lrparser"<<endl;int schain=0;kk=0;if(syn==1){scaner();schain=yucu();if(syn==6){scaner();if(syn==0 && (kk==0))cout<<"success!"<<endl;}else{if(kk!=1)cout<<"缺end!"<<endl;kk=1;}}else{cout<<"缺begin!"<<endl;kk=1;}return(schain);}int yucu(){// cout<<"调用yucu"<<endl;int schain=0;schain=statement();while(syn==26){scaner();schain=statement();}return(schain);}int statement(){//cout<<"调用statement"<<endl;char *eplace,*tt;eplace=(char *)malloc(12);tt=(char *)malloc(12);int schain=0;switch(syn){case 10:strcpy(tt,token);scaner();if(syn==18){scaner();strcpy(eplace,expression());emit(tt,eplace,"","");schain=0;}else{cout<<"缺少赋值符!"<<endl;kk=1;}return(schain);break;}return(schain);}char *expression(void){char *tp,*ep2,*eplace,*tt;tp=(char *)malloc(12);ep2=(char *)malloc(12);eplace=(char *)malloc(12);tt =(char *)malloc(12);strcpy(eplace,term ()); //调用term分析产生表达式计算的第一项eplacewhile((syn==15)||(syn==16)){if(syn==15)strcpy(tt,"+");else strcpy(tt,"-");scaner();strcpy(ep2,term()); //调用term分析产生表达式计算的第二项ep2strcpy(tp,newtemp()); //调用newtemp产生临时变量tp存储计算结果emit(tp,eplace,tt,ep2); //生成四元式送入四元式表strcpy(eplace,tp);}return(eplace);}char *term(void){// cout<<"调用term"<<endl;char *tp,*ep2,*eplace,*tt;tp=(char *)malloc(12);ep2=(char *)malloc(12);eplace=(char *)malloc(12);tt=(char *)malloc(12);strcpy(eplace,factor());while((syn==13)||(syn==14)){if(syn==13)strcpy(tt,"*");else strcpy(tt,"/");scaner();strcpy(ep2,factor()); //调用factor分析产生表达式计算的第二项ep2strcpy(tp,newtemp()); //调用newtemp产生临时变量tp存储计算结果emit(tp,eplace,tt,ep2); //生成四元式送入四元式表strcpy(eplace,tp);}return(eplace);}char *factor(void){char *fplace;fplace=(char *)malloc(12);strcpy(fplace,"");if(syn==10){strcpy(fplace,token); //将标识符token的值赋给fplacescaner();}else if(syn==11){itoa(sum,fplace,10);scaner();}else if(syn==27){scaner();fplace=expression(); //调用expression分析返回表达式的值if(syn==28)scaner();else{cout<<"缺)错误!"<<endl;kk=1;}}else{cout<<"缺(错误!"<<endl;kk=1;}return(fplace);}void main(){p=0;cout<<"**********语义分析程序**********"<<endl;cout<<"Please input string:"<<endl;do{cin.get(ch);prog[p++]=ch;}while(ch!='#');p=0;scaner();lrparser();}七、结果验证1、给定源程序begin a:=2+3*4; x:=(a+b)/c end#输出结果2、源程序begin a:=9; x:=2*3-1; b:=(a+x)/2 end#输出结果八、收获（体会）与建议通过此次实验, 让我了解到如何设计、编制并调试语义分析程序, 加深了对语法制导翻译原理的理解, 掌握了将语法分析所识别的语法成分变换为中间代码的语义翻译方法。
编译原理语义分析实验报告 免费
编译原理综合训练语义分析实验报告指导老师：班级：学生：zeadom学号：学生：学号：2011/6/29目录语言文法的形式化描述 (3)语义规则 (3)运行环境介绍 (5)关键算法的流程图及文字解释 (5)1、本编译器的总框架 (5)2、在语义分析中的主要函数介绍 (5)3、产生布尔表达式 (7)4、While-do语句的语义分析 (8)5、词法、语法和语义分析的衔接 (8)测试报告 (8)附录 (12)语言文法的形式化描述（BNF范式）程序开始P->program i;SDn SC;定义语句SDn->SDSDn|nullSD->var int iSDTSDT -> null|,iSDT复合语句SC->begin Sn endSn->S;Sn||null单个语句S->SD|SA|SIF|SW|SC赋值语句SA->i:=E算术表达式E->cET|iET|(E)ETET->AE|CE|DE|null;C->+|-|*|/;布尔表达式B->EAEBT|NOT B|(B)BTBT->DB|nullA->>|<|=|>=|<=|<>D->AND|ORif语句SIF->if B then S SELSESELSE->null|else S2while语句SW->while B do S语义规则（属性文法）运行环境介绍运行环境是DEVC++Dev-C++是一个C&C++开发工具，它是一款自由软件，遵守GPL协议。
它集合了GCC、MinGW32等众多自由软件，并且可以取得最新版本的各种工具支持，而这一切工作都是来自全球的狂热者所做的工作，并且你拥有对这一切工具自由使用的权利，包括取得源代码等，前提是你也必须遵守GNU协议。
Dev-C++每一天都在进步着，因为它是一个自由软件。
编译原理_ 语义分析_实验报告
编译原理实验三语义分析实验报告◆学院：数学与计算机科学技术学院◆专业：计算机科学与技术◆班级：级计算机班◆小组组员：姓名：学号：姓名：学号：姓名：学号：姓名：学号：实验题目一、实验目的要求学生用与实验2相同的语言，编制语义分析程序。
二、实验准备微机CPU主频1.3G以上，128M内存，安装好C语言，PASCAL语言，或C++。
三、实验时间13学时四、实验内容要求学生用与实验2相同的语言，编制语义分析程序。
定义该语言的语义成分，将语义分析程序编制成子程序，在实验2分析出各语法单位后，分析其含义，并将可执行语句或表达式翻译为四元式输出，并将错误信息输出。
实验报告必须包括设计的思路，以及测试报告（输入测试例子，输出结果）。
五、上交文档1．实验报告（书面）；2．程序文件（通过网络提交）。
<program> ::= <block> .<block> ::= <const-decl> <var-decl> <proc-decl> <statement><const-decl> ::= const <const-assignment-list> ; | ε<const-assignment-list> ::= <ident> = <number>| <const-assignment-list> , <ident> = <number><var-decl> ::= var <ident-list> ; |ε<ident-list> ::= <ident> | <ident-list> , <ident><proc-decl> ::= <proc-decl> procedure <ident> ; <block> ; |ε<statement> ::= <ident> := <expression>| call <ident>| begin <statement-list> end| if <condition> then <statement>| while <condition> do <statement>|ε<statement-list> ::= <statement> | <statement-list> ; <statement><condition> ::= odd <expression> | <expression> <relation> <expression><relation> ::= = | <> | < | > | <= | >=<expression> ::= <term> | <adding-operator> <term>| <expression> <adding-operator> <term><adding-operator> ::= + | -<term> ::= <factor> | <term> <multiplying-operator> <factor><multiplying-operator> ::= * | /<factor> ::= <ident> | <number> | ( <expression> )注意：(1) "ε" 表示空串。
编译原理的实验报告
一、实验目的1. 理解编译原理的基本概念和原理。
2. 掌握编译器的各个阶段及其实现方法。
3. 能够运用编译原理的知识解决实际问题。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 20194. 实验内容：词法分析、语法分析、语义分析、中间代码生成、代码优化、目标代码生成三、实验内容1. 词法分析（1）实验目的：实现一个简单的词法分析器，将源代码中的字符序列转换为词法符号序列。
（2）实验步骤：1）定义词法符号类型，包括标识符、关键字、运算符、常量等。
2）设计词法分析器算法，对源代码进行遍历，将字符序列转换为词法符号序列。
3）实现词法分析器程序，输出词法符号序列。
（3）实验结果：输入源代码：int a = 10;输出词法符号序列：{<int, int>, <a, a>, <=, =>, <10, 10>, <;, ;>}2. 语法分析（1）实验目的：实现一个简单的语法分析器，将词法符号序列转换为抽象语法树（AST）。
（2）实验步骤：1）定义语法规则，包括产生式、非终结符、终结符等。
2）设计语法分析算法，根据语法规则对词法符号序列进行解析，生成AST。
3）实现语法分析器程序，输出AST。
（3）实验结果：输入词法符号序列：{<int, int>, <a, a>, <=, =>, <10, 10>, <;, ;>}输出AST：```AST:- ExpressionStatement- Expression- BinaryExpression- Identifier: a- Operator: =- Constant: 10```3. 语义分析（1）实验目的：实现语义分析器，对AST进行语义检查，确保程序的正确性。
（2）实验步骤：1）定义语义规则，包括类型检查、作用域检查等。
编译原理实验报告语义分析
编译原理实验报告语义分析实验名称：语义分析实验目的：1.掌握词法分析器生成的词法单元序列的构造；2.学会设计语法分析器，实现对程序的基本语法结构检查，并生成抽象语法树；3.学习语义规约的实现，实现对程序的语义分析和错误检查；4.熟悉语义分析向语法分析的接口。
实验原理：语义分析是编译过程的一个重要环节，它的主要任务是对生成的抽象语法树进行遍历，并验证程序的类型一致性、语义规则的正确性、错误的检查和恢复等。
语义分析的输入是由语法分析生成的抽象语法树，输出是继续优化的抽象语法树或中间代码，以供后续的中间代码生成等工作使用。
实验步骤：1.设计语法分析器，包括语法规则、优先级关系等；2.生成词法单元序列；3.构建语法分析器，进行语法分析，并生成抽象语法树；4.针对不同的语义规约，设计语义动作，实现对程序的语义分析和错误检查；5.完成语义分析器的构建和测试。
实验设备：1.计算机；2. 编程语言：C++/Java/Python等；3. 开发环境：Visual Studio/ Eclipse/PyCharm等。
实验结果：通过对语法分析生成的抽象语法树进行遍历，实现了对程序的语义分析和错误检查。
具体实现包括：1.类型检查：根据语义规约，对程序中的类型进行检查，包括变量的声明及使用、函数的调用、赋值语句的一致性等；2.作用域检查：检查变量的作用域和可见性等；3.错误检查：检测语义错误，如变量未声明、函数重复定义等；4.错误恢复：当检测到错误时，采取适当的错误恢复措施，如跳过错误的部分继续分析、提示错误信息等。
实验心得：本次实验主要学习了语义分析的原理和实现方法，深入了解了编译过程中各个环节的作用和关系。
通过实践操作，加深了对语法分析和语义分析的理解，提高了编程能力和解决问题的能力。
同时，实验过程中也遇到了一些挑战和困难，例如语义规约的设计和实现、错误检查和恢复等，但通过查阅资料和与同学讨论，最终解决了这些问题。
通过本次实验，我对编译原理和语义分析有了更深入的了解，并且对以后的学习和工作有了更好的准备。
编译原理语义分析实验报告
action[5][LE].i=5; action[6][RI].ch='R'; action[6][RI].i=1; action[6][EMY].ch='R'; action[6][EMY].i=1; action[7][Z].ch='S'; action[7][Z].i=4; action[7][LE].ch='S'; action[7][LE].i=5; action[8][X].ch='R'; action[8][X].i=4; action[8][RI].ch='R'; action[8][RI].i=4; action[8][EMY].ch='R'; action[8][EMY].i=4; action[9][Z].ch='S'; action[9][Z].i=4; action[9][LE].ch='S'; action[9][LE].i=5; action[10][RI].ch='S'; action[10][RI].i=13; action[11][X].ch='S'; action[11][X].i=7; action[11][RI].ch='R'; action[11][RI].i=3; action[11][EMY].ch='R';//R！ ！ action[11][EMY].i=3; action[12][Y].ch='S'; action[12][Y].i=9; action[12][X].ch='R'; action[12][X].i=6; action[12][RI].ch='R'; action[12][RI].i=6; action[12][EMY].ch='R'; action[12][EMY].i=6; action[13][X].ch='R';
编译原理实验报告
编译原理实验报告一、实验目的编译原理是计算机科学中的重要课程，旨在让学生了解编译器的基本工作原理以及相关技术。
本次实验旨在通过设计和实现一个简单的编译器，来进一步加深对编译原理的理解，并掌握实际应用的能力。
二、实验环境本次实验使用了Java编程语言及相关工具。
在开始实验前，我们需要安装Java JDK并配置好运行环境。
三、实验内容及步骤1. 词法分析词法分析是编译器的第一步，它将源代码分割成一系列词法单元。
我们首先实现一个词法分析器，它能够将输入的源代码按照语法规则进行切割，并识别出关键字、标识符、数字、运算符等。
2. 语法分析语法分析是编译器的第二步，它将词法分析得到的词法单元序列转化为语法树。
我们使用自顶向下的LL(1)语法分析算法，根据文法规则递归地构建语法树。
3. 语义分析语义分析是编译器的第三步，它对语法树进行检查和转换。
我们主要进行类型检查、语法错误检查等。
如果源代码存在语义错误，编译器应该能够提供相应的错误提示。
4. 代码生成代码生成是编译器的最后一步，它将经过词法分析、语法分析和语义分析的源代码翻译为目标代码。
在本次实验中，我们将目标代码生成为Java字节码。
5. 测试与优化完成以上步骤后，我们需要对编译器进行测试，并进行优化。
通过多个测试用例的执行，我们可以验证编译器的正确性和性能。
四、实验心得通过完成这个编译器的实验，我收获了很多。
首先，我对编译原理的知识有了更深入的理解。
在实验过程中，我深入学习了词法分析、语法分析、语义分析和代码生成等关键技术，对编译器的工作原理有了更系统的了解。
其次，我提高了编程能力。
实现一个完整的编译器需要处理复杂的数据结构和算法，这对我的编程能力是一个很好的挑战。
通过实验，我学会了合理地组织代码，优化算法，并注意到细节对程序性能的影响。
最后，我锻炼了解决问题的能力。
在实验过程中，我遇到了很多困难和挑战，但我不断地调试和改进代码，最终成功地实现了编译器。
编译原理语义分析与中间代码生成实验报告
编译原理语义分析与中间代码生成实验报告专题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}。
编译原理语义分析报告
《编译原理》实验报告专业班级_软工1502 姓名_赵翘楚_ 学号_20151107062_1.题目要求：1.1实验目的通过上机实习,加深对语法制导翻译原理的理解,掌握将语法分析所识别的语法成分变换为中间代码的语义翻译方法。
1.2实验原理采用递归下降语法制导翻译法,对算术表达式、赋值语句进行语义分析并生成四元式序列。
2.算法分析2.1主程序示意图置初值调用scaner调用lrparser输出四元组结束图12.2设置语义过程emit(char *result,char *arg1,char *op,char *ag2)该函数功能是生成一个三地址语句送到四元式表中。
四元式表的结构如下：struct {char result[8];char ag1[8];char op[8];char ag2[8];}quad[20];(2) char *newtemp()该函数回送一个新的临时变量名，临时变量名产生的顺序为T1,T2,….Char *newtemp(void){char *p;char m[8];p=(char *)malloc(8);k++;itoa(k,m,10);strcpy(p+1,m);p[0]=’t’;return(p);}2.3函数lrparser在原来语法分析的基础上插入相应的语义动作：将输入串翻译成四元式序列。
在实验中我们只对表达式、赋值语句进行翻译。
3、实验步骤#include "stdio.h"#include "string.h"#include "stdlib.h"char prog[100],token[8],ch;char*rwtab[6]={"begin","if","then","while","do"," end"};int syn,p,m,n,sum,q;int kk;struct { char result1[8];char ag11[8];char op1[8];char ag21[8];} quad[20];char *factor();char *expression();int yucu();char *term();int statement();int lrparser();char *newtemp();scaner();emit(char *result,char *ag1,char *op,char *ag2);void main(){ int j; q=p=kk=0;printf("\nplease input a string (end with '#'): ");do{ scanf("%c",&ch);prog[p++]=ch;}while(ch!='#');p=0;scaner();lrparser();if(q>19)printf(" to long sentense!\n"); elsefor(j=0;j<q;j++)printf("%s=%s%s%s\n\n", quad[j].result1,quad[j].ag11,quad[j].op1,quad[j].ag21);//getch();}int lrparser(){ int schain=0;kk=0;if (syn==1){ scaner(); //读下一个单词符号schain=yucu(); //调用语句串分析函数进行分析if(syn==6){ scaner(); //读下一个单词符号if((syn==0)&&(kk==0))printf("Success!\n"); //输出（“success”）}else { if(kk!=1)printf("short of 'end' !\n"); //输出 ‘缺end ’ 错误kk=1; // getch(); exit(0); } } else { printf("short of 'begin' !\n"); //输出’begin ’错误kk=1; // getch(); exit(0); } return (schain); } int yucu() { int schain=0; schain=statement(); //调用语句分析函数进行分析 while(syn==26) { scaner(); //读下一个单词符号 schain=statement(); //调用语句分析函数进行分析 } return (schain); } int statement() { char tt[8],eplace[8]; int schain=0; if (syn==10) { strcpy(tt,token); scaner(); if(syn==18) { scaner(); //读下一个单词符号strcpy(eplace,expression()); emit(tt,eplace,"",""); schain=0; } else { printf("short of sign ':=' !\n"); //输出’缺少赋值号’的错误kk=1; // getch(); exit(0); } return (schain); } } char *expression() { char *tp,*ep2,*eplace,*tt; tp=(char *)malloc(12); //分配空间ep2=(char *)malloc(12); eplace=(char *)malloc(12); tt=(char *)malloc(12); strcpy(eplace,term()); //调用term 分析产生表达式计算的第一项eplace while((syn==13)||(syn==14)) { if (syn==13)strcpy(tt,"+"); //操作符 tt= ‘+’或者‘—’ else strcpy(tt,"-"); scaner(); //读下一个单词符号 strcpy(ep2,term()); //调用term 分析产生表达式计算的第二项ep2 strcpy(tp,newtemp()); //调用newtemp 产生临时变量tp 存储计算结果 emit(tp,eplace,tt,ep2); //生成四元式送入四元式表 strcpy(eplace,tp); } return (eplace); } char *term() //仿照函数expression 编写 { char *tp,*ep2,*eplace,*tt; tp=(char *)malloc(12); ep2=(char *)malloc(12); eplace=(char *)malloc(12);tt=(char *)malloc(12); strcpy(eplace,factor()); while((syn==15)||(syn==16)) { if (syn==15)strcpy(tt,"*"); else strcpy(tt,"/"); scaner(); //读下一个单词符号 strcpy(ep2,factor());strcpy(tp,newtemp()); emit(tp,eplace,tt,ep2); strcpy(eplace,tp); } return (eplace);}char *factor(){ char *fplace;fplace=(char *)malloc(12);strcpy(fplace,"");if(syn==10){ strcpy(fplace,token);scaner(); //读下一个单词符号}else if(syn==11){ itoa(sum,fplace,10);scaner(); //读下一个单词符号}else if(syn==27){ scaner(); //读下一个单词符号fplace=expression(); //调用expression分析返回表达式的值if(syn==28) scaner(); //读下一个单词符号else { printf("error on ')' !\n");kk=1;// getch();exit(0);}}else { printf("error on '(' !\n");kk=1;// getch();exit(0);}return (fplace);}char *newtemp(){ char *p;char m[8];p=(char *)malloc(8);kk++;itoa(kk,m,10);strcpy(p+1,m);p[0]='t';return(p);}scaner(){ sum=0;for(m=0;m<8;m++)token[m++]=NULL;m=0;ch=prog[p++];while(ch==' ')ch=prog[p++];if(((ch<='z')&&(ch>='a'))||((ch<='Z')&&(ch>= 'A'))){ while(((ch<='z')&&(ch>='a'))||((ch<='Z')&& (ch>='A'))||((ch>='0')&&(ch<='9'))){token[m++]=ch;ch=prog[p++];}p--;syn=10;token[m++]='\0';for(n=0;n<6;n++)if(strcmp(token,rwtab[n])==0){ syn=n+1;break;}}else if((ch>='0')&&(ch<='9')){ while((ch>='0')&&(ch<='9')){ sum=sum*10+ch-'0';ch=prog[p++];}p--;syn=11;}else switch(ch){ case '<':m=0;ch=prog[p++];if(ch=='>'){ syn=21;}else if(ch=='='){ syn=22;}else{ syn=20;p--;}break;case '>':m=0;ch=prog[p++];if(ch=='='){ syn=24;}else{ syn=23;p--;}break;case ':':m=0;ch=prog[p++];if(ch=='='){ syn=18;}else{ syn=17;p--;}break;case '+': syn=13; break; case '-': syn=14; break;case '*': syn=15;break;case '/': syn=16;break;case '(': syn=27;break;case ')': syn=28;break;case '=': syn=25;break;case ';': syn=26;break;case '#': syn=0;break;default: syn=-1;break;}}emit(char *result,char *ag1,char *op,char *ag2){strcpy(quad[q].result1,result);strcpy(quad[q].ag11,ag1);strcpy(quad[q].op1,op);strcpy(quad[q].ag21,ag2);q++;}4、实验结果实验的输入和输出：输入是语法分析提供的正确的单词串，输出为三地址指令形式的四元式序列。
编译原理实验报告
编译原理实验报告编译原理实验报告一、引言编译原理是计算机科学中的重要课程之一，它研究的是如何将高级语言程序转化为机器语言程序的过程。
在本次实验中，我们将学习并实践编译原理中的一些基本概念和技术，包括词法分析、语法分析和语义分析等。
二、词法分析词法分析是编译过程中的第一步，它负责将源程序中的字符序列转化为有意义的词法单元。
在本次实验中，我们使用了Flex工具来生成词法分析器。
通过定义一系列正则表达式和对应的动作，我们可以将源程序中的字符序列识别为不同的词法单元，如标识符、关键字、运算符等。
三、语法分析语法分析是编译过程中的第二步，它负责将词法单元序列转化为抽象语法树。
在本次实验中，我们使用了Bison工具来生成语法分析器。
通过定义一系列文法规则和对应的动作，我们可以将词法单元序列转化为抽象语法树，并进行语法错误的检测和恢复。
四、语义分析语义分析是编译过程中的第三步，它负责对抽象语法树进行语义检查和语义动作的执行。
在本次实验中，我们通过自定义语义规则和对应的动作，对抽象语法树进行类型检查、符号表管理等操作。
同时，我们还实现了一些简单的语义动作，如计算表达式的值、生成中间代码等。
五、中间代码生成中间代码生成是编译过程中的一项重要任务，它负责将源程序转化为机器无关的中间表示形式。
在本次实验中，我们使用了三地址码作为中间表示形式。
通过对抽象语法树的遍历和一系列的转换规则，我们可以将源程序转化为等价的三地址码表示形式。
六、实验结果与分析通过对一些简单的测试程序的编译，我们验证了我们所实现的词法分析、语法分析、语义分析和中间代码生成的正确性。
同时，我们还进行了一些性能测试，对比了不同算法和数据结构在编译过程中的效率差异。
实验结果表明，我们所实现的编译器在处理大规模程序时具有较好的性能。
七、结论通过本次实验，我们深入了解了编译原理中的一些基本概念和技术，并通过实践加深了对编译过程的理解。
同时，我们也意识到编译器的设计和实现是一项复杂而有挑战性的任务，需要综合运用多种算法和数据结构。
编译原理教程实验报告
一、实验目的本次实验旨在使学生通过编译原理的学习，了解编译程序的设计原理及实现技术，掌握编译程序的各个阶段，并能将所学知识应用于实际编程中。
二、实验内容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. 编译原理是一门理论与实践相结合的课程，通过本次实验，我对编译程序的设计原理及实现技术有了更深入的了解。
编译原理语义实验报告
编译原理语义实验报告编译原理语义实验报告引言：编译原理是计算机科学中的重要课程之一，它研究的是如何将高级程序语言转化为机器语言，使得计算机能够理解并执行程序。
语义分析是编译过程中的重要环节，它负责对程序的语义进行分析和处理。
本实验报告将介绍我们在编译原理课程中进行的语义实验，并分享我们的实验结果和心得体会。
实验目的：本次实验的主要目的是掌握语义分析的基本原理和方法，了解如何构建语法树以及如何进行类型检查和语义规则的验证。
通过实验，我们将能够更好地理解编译器是如何对程序进行处理和优化的。
实验环境和工具：为了完成本次实验，我们使用了一些常见的编程语言和工具。
其中，我们选择了C语言作为实验的目标语言，并使用了Flex和Bison作为词法分析器和语法分析器的生成工具。
此外，我们还使用了一些辅助工具和库，如LLVM和GCC 等。
实验过程：在实验过程中，我们首先需要设计和实现一个简单的编程语言，包括其语法和语义规则。
然后，我们使用Flex和Bison来生成词法分析器和语法分析器，并通过这些工具将源代码转换为语法树。
接下来，我们对语法树进行类型检查和语义规则的验证，以确保程序的正确性和合法性。
最后，我们将生成的中间代码转化为目标代码，并进行优化和生成可执行文件。
实验结果：通过实验，我们成功地设计和实现了一个简单的编程语言，并使用Flex和Bison生成了相应的词法分析器和语法分析器。
我们还实现了类型检查和语义规则的验证，确保了程序的正确性和合法性。
最终，我们成功地将生成的中间代码转化为目标代码，并生成了可执行文件。
实验心得：通过本次实验，我们深入理解了编译原理中的语义分析过程。
我们学会了如何构建语法树，并对其进行类型检查和语义规则的验证。
我们还学会了使用一些常见的编程语言和工具，如C语言、Flex、Bison等。
通过实验，我们不仅提高了自己的编程能力，还加深了对编译原理的理解和认识。
结论：编译原理是计算机科学中的重要课程，语义分析是编译过程中的关键环节。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
语义分析实验报告一、实验目的：通过上机实习，加深对语法制导翻译原理的理解，掌握将语法分析所识别的语法成分变换为中间代码的语义翻译方法。
二、实验要求：采用递归下降语法制导翻译法，对算术表达式、赋值语句进行语义分析并生成四元式序列。
三、算法思想：1、设置语义过程。
（1）emit(char *result,char *ag1,char *op,char *ag2)该函数的功能是生成一个三地址语句送到四元式表中。
四元式表的结构如下：struct{ char result[8];char ag1[8];char op[8];char ag2[8];}quad[20];(2) char *newtemp()该函数回送一个新的临时变量名，临时变量名产生的顺序为T1，T2，…char *newtemp(void){ char *p;char m[8];p=(char *)malloc(8);k++;itoa(k,m,10);strcpy(p+1,m);p[0]=’t’;return(p);}2、函数lrparser 在原来语法分析的基础上插入相应的语义动作：将输入串翻译成四元式序列。
在实验中我们只对表达式、赋值语句进行翻译。
四、源程序代码：#include<stdio.h>#include<string.h>#include<iostream.h>#include<stdlib.h>struct{char result[12];char ag1[12];char op[12];char ag2[12];}quad;char prog[80],token[12];char ch;int syn,p,m=0,n,sum=0,kk; //p是缓冲区prog的指针，m是token的指针char *rwtab[6]={"begin","if","then","while","do","end"};void scaner();char *factor(void);char *term(void);char *expression(void);int yucu();void emit(char *result,char *ag1,char *op,char *ag2);char *newtemp();int statement();int k=0;void emit(char *result,char *ag1,char *op,char *ag2){strcpy(quad.result,result);strcpy(quad.ag1,ag1);strcpy(quad.op,op);strcpy(quad.ag2,ag2);cout<<quad.result<<"="<<quad.ag1<<quad.op<<quad.ag2<<endl;}char *newtemp(){char *p;char m[12];p=(char *)malloc(12);k++;itoa(k,m,10);strcpy(p+1,m);p[0]='t';return (p);}void scaner(){for(n=0;n<8;n++) token[n]=NULL;ch=prog[p++];while(ch==' '){ch=prog[p];p++;}if((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')){m=0;while((ch>='0'&&ch<='9')||(ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')){token[m++]=ch;ch=prog[p++];}token[m++]='\0';p--;syn=10;for(n=0;n<6;n++)if(strcmp(token,rwtab[n])==0){syn=n+1;break;}}else if((ch>='0'&&ch<='9')){{sum=0;while((ch>='0'&&ch<='9')){sum=sum*10+ch-'0';ch=prog[p++];}}p--;syn=11;if(sum>32767)syn=-1;}else switch(ch){case'<':m=0;token[m++]=ch;ch=prog[p++];if(ch=='>'){syn=21;token[m++]=ch;}else if(ch=='=')syn=22;token[m++]=ch;}else{syn=23;p--;}break;case'>':m=0;token[m++]=ch;ch=prog[p++];if(ch=='='){syn=24;token[m++]=ch;}else{syn=20;p--;}break;case':':m=0;token[m++]=ch;ch=prog[p++];if(ch=='='){syn=18;token[m++]=ch;}else{syn=17;p--;break;case'*':syn=13;token[0]=ch;break;case'/':syn=14;token[0]=ch;break;case'+':syn=15;token[0]=ch;break;case'-':syn=16;token[0]=ch;break;case'=':syn=25;token[0]=ch;break;case';':syn=26;token[0]=ch;break;case'(':syn=27;token[0]=ch;break;case')':syn=28;token[0]=ch;break;case'#':syn=0;token[0]=ch;break; default: syn=-1;break;}}int lrparser(){//cout<<"调用lrparser"<<endl;int schain=0;kk=0;if(syn==1){scaner();schain=yucu();if(syn==6){scaner();if(syn==0 && (kk==0))cout<<"success!"<<endl;}else{if(kk!=1)cout<<"缺end!"<<endl;kk=1;}}else{cout<<"缺begin!"<<endl;kk=1;}return(schain);}int yucu(){// cout<<"调用yucu"<<endl;int schain=0;schain=statement();while(syn==26){scaner();schain=statement();}return(schain);}int statement(){//cout<<"调用statement"<<endl;char *eplace,*tt;eplace=(char *)malloc(12);tt=(char *)malloc(12);int schain=0;switch(syn){case 10:strcpy(tt,token);scaner();if(syn==18){scaner();strcpy(eplace,expression());emit(tt,eplace,"","");schain=0;}else{cout<<"缺少赋值符!"<<endl;kk=1;}return(schain);break;}return(schain);}char *expression(void){char *tp,*ep2,*eplace,*tt;tp=(char *)malloc(12);ep2=(char *)malloc(12);eplace=(char *)malloc(12);tt =(char *)malloc(12);strcpy(eplace,term ()); //调用term分析产生表达式计算的第一项eplacewhile((syn==15)||(syn==16)){if(syn==15)strcpy(tt,"+");else strcpy(tt,"-");scaner();strcpy(ep2,term()); //调用term分析产生表达式计算的第二项ep2strcpy(tp,newtemp()); //调用newtemp产生临时变量tp存储计算结果emit(tp,eplace,tt,ep2); //生成四元式送入四元式表strcpy(eplace,tp);}return(eplace);}char *term(void){// cout<<"调用term"<<endl;char *tp,*ep2,*eplace,*tt;tp=(char *)malloc(12);ep2=(char *)malloc(12);eplace=(char *)malloc(12);tt=(char *)malloc(12);strcpy(eplace,factor());while((syn==13)||(syn==14)){if(syn==13)strcpy(tt,"*");else strcpy(tt,"/");scaner();strcpy(ep2,factor()); //调用factor分析产生表达式计算的第二项ep2strcpy(tp,newtemp()); //调用newtemp产生临时变量tp存储计算结果emit(tp,eplace,tt,ep2); //生成四元式送入四元式表strcpy(eplace,tp);}return(eplace);}char *factor(void){char *fplace;fplace=(char *)malloc(12);strcpy(fplace,"");if(syn==10){strcpy(fplace,token); //将标识符token的值赋给fplacescaner();}else if(syn==11){itoa(sum,fplace,10);scaner();}else if(syn==27){scaner();fplace=expression(); //调用expression分析返回表达式的值if(syn==28)scaner();else{cout<<"缺)错误!"<<endl;kk=1;}}else{cout<<"缺(错误!"<<endl;kk=1;}return(fplace);}void main(){p=0;cout<<"**********语义分析程序**********"<<endl;cout<<"Please input string:"<<endl;do{..cin.get(ch);prog[p++]=ch;}while(ch!='#');p=0;scaner();lrparser();} 五、 结果验证：1、给定源程序begin a:=2+3*4; x:=(a+b)/c end#输出结果2、 源程序begin a:=9; x:=2*3-1; b:=(a+x)/2 end#输出结果六、 收获（体会）与建议：通过此次实验，让我了解到如何设计、编制并调试语义分析程序，加深了对语法制导翻译原理的理解，掌握了将语法分析所识别的语法成分变换为中间代码的语义翻译方法。