语义分析实验报告.doc
北邮 编译原理 语义分析实验报告

编译原理第六章语义分析目录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.实验分析和思考由于要求进行类型检查和求值,所以可以定义两个综合属性,一个记录值一个记录类型,存放在结构中,一并传入传出。
实验三-语义分析-实习报告

实验三语义分析一、实习目的通过上机实习,加深对语法制时翻译原理的理解,掌握将语法分析所识别的语法成分变换为中间代码的语义翻译方法.二、实习要求采用递归下降语法制导翻译法对算术表达式、赋值语句、条件语句、循环语句进行语义分析生成四元式序列。
三、实习过程实习代码;/***JavaCC file*/options {JDK_VERSION = "1。
5”;static=false;}PARSER_BEGIN(whileParse)package whileparse;import java。
io.FileInputStream;import java。
io.FileNotFoundException;import java.util。
ArrayList;public class whileParse {public int count=0; /*四元式标号*/public static ArrayList<Sys〉sysList = new ArrayList<Sys〉();public int ncount=0;/*临时变量下标*/public static void main(String args[]) throws ParseException {FileInputStream fileStream;t ry {fileStream = new FileInputStream("data/test.c");whileParse parser = new whileParse(fileStream);System.out。
println("Reading from standard input。
.”);System。
out。
println("Enter c programe only main()with only while();\" :");try {switch (parser.start()){case 0:System。
河北工业大学语义分析实验报告

实验三语义分析程序实现一、实验设计在实现词法、语法分析程序的基础上,编写相应的语义子程序,进行语义处理,加深对语法制导翻译原理的理解,进一步掌握将语法分析所识别的语法范畴变换为某种中间代码(四元式)的语义分析方法。
基本实验题目:对文法G2[<算术表达式>]中的产生式添加语义处理子程序,完成运算对象是简单变量(标识符)和无符号数的四则运算的计值处理,将输入的四则运算转换为四元式形式的中间代码。
语法制导翻译模式是在语法分析的基础上,增加语义操作来实现的,实际上是对前后文无关文法的一种扩展。
一般而言,首先需要根据进行的语义分析工作,完成对给定文法的必要拆分和语义动作的编写,从而为每一个产生式都配备相应的语义子程序,以便在进行语法分析的同时进行语义解释。
即在语法分析过程中,每当用一个产生式进行推导或归约时,语法分析程序除执行相应的语法分析动作之外,还要调用相应的语义子程序,以便完成生成中间代码、查填有关表格、检查并报告源程序中的语义错误等工作。
每个语义子程序需指明相应产生式中各个符号的具体含义,并规定使用该产生式进行分析时所应采取的语义动作。
这样,语法制导翻译程序在对源程序从左到右进行的一遍扫描中,既完成语法分析任务,又完成语义分析和中间代码生成方面的工作。
本实验要求从编译器的整体设计出发,重点通过对实验二中语法分析程序的扩展,完成一个编译器前端程序的编写、调试和测试工作,形成一个将源程序翻译为中间代码序列的编译系统。
二、程序代码在词法分析和语法分析的基础上,完成了语义的分析,同样采用了头文件的形式,在VC++6.0中运行#include<stdio.h>#include<ctype.h>#include<stdlib.h>#include<string.h>#include<math.h>#include"cifa.h"#include"fenxibiao.h"# define PL 15 //+# define MI 16 //-# define MU 17# define DI 18#define acc 100#define MAXState 20#define NUMBER 9//表达式的个数#define MAXTEMP 10//最多临时变量的个数int State[MAXState];//状态栈int i=0;int CURRENTSTATE=0;//标识当前状态int LENGTH[NUMBER]={1,3,3,1,3,3,1,3,1};//表达式右边的长度int length;int index;//索引int Yes=0;//判断是否结束int tag=0;//判断是否需要调用词法程序//extern char * cifa();double e1,t4,f7;//整形char e12[20],t42[20],f72[20];//字符型int TEMP[MAXTEMP];int temp=0;int biaoshifu=0;FILE * fp;void REPORT_ERROR(){Yes=1;long f1=ftell(fp);char ch=fgetc(fp);fseek(fp,-1,1);printf("语法错误,第%d个字符'%C'处\n",f1,ch); }void Accept(){Yes=1;//printf("语法分析成功\n");}int INDEX(char a)//获取当前字符串对应的索引{int i;switch (a){case 'E':i=8;return(i);break;case 'T':i=9;return(i);break;case 'F':i=10;return(i);break;default: REPORT_ERROR();return(0);break;}}void Gen(int a,double i1,double i2,int t)//输出四元式{switch(a){case PL:printf("(+,%g,%g,%d)\n",i1,i2,t);break;case MI:printf("(-,%g,%g,%d)\n",i1,i2,t);break;case MU:printf("(*,%g,%g,%d)\n",i1,i2,t);break;case DI:printf("(/,%g,%g,%d)\n",i1,i2,t);break;default:break;}}void yuyi(int n)//语义子程序{switch(n){case 1:{temp++;//产生临时变量,Gen(PL,e1,t4,temp);e1=temp;break;}case 2:{temp++;//产生临时变量,TEMP[temp] Gen(MI,e1,t4,temp);e1=temp;break;}case 3:{e1=t4;break;}case 4:{temp++;Gen(MU,t4,f7,temp); t4=temp;break;}case 5:{temp++;Gen(DI,t4,f7,temp); t4=temp;break;}case 6:{t4=f7;break;}case 7:{f7=e1;break;}case 8:{f7=FCON;break;}default :printf("error\n");break;}}void Gen2(int a,char *i1,char *i2,int t)//输出四元式{switch(a){case PL:printf("(+,%s,%s,%d)\n",&i1,&i2,t);break;case MI:printf("(-,%s,%s,%d)\n",&i1,&i2,t);break;case MU:printf("(*,%s,%s,%d)\n",&i1,&i2,t);break;case DI:printf("(/,%s,%s,%d)\n",&i1,&i2,t); break;default:break;}}void fuzhi(char *a,char *b)//将数组b赋值给数组a {}void yuyi2(int n)//语义子程序{switch(n){case 1:{temp++;//产生临时变量Gen2(PL,e12,t42,temp);e12[0]=temp;break;}case 2:{temp++;//产生临时变量,TEMP[temp] Gen2(MI,e12,t42,temp);e12[0]=temp;break;}case 3:{//e12=t42;strcpy(e12,t42);break;}case 4:{temp++;Gen2(MU,t42,f72,temp); t42[0]=temp;break;}case 5:{temp++;Gen2(DI,t42,f72,temp); t42[0]=temp;break;}case 6:{//t42=f72;strcpy(t42,f72); break;}case 7:{//f72=e12;strcpy(f72,e12);break;}case 8:{//f72=TOKEN[0];strcpy(f72,TOKEN);break;}default :printf("error\n"); break;}}void INPUT(int a){index=a;int index2=0;if(Table[CURRENTSTATE][index]!=acc) {if (Table[CURRENTSTATE][index]==0)//报错{REPORT_ERROR();}elseif (Table[CURRENTSTATE][index]<20)//移近{ i++;State[i]=Table[CURRENTSTATE][index]; CURRENTSTATE=State[i];}else //规约{tag=1;length=LENGTH[Table[CURRENTSTATE][index]-20]; i=i-length;//指针回退switch(Table[CURRENTSTATE][index]-20){case 1:case 2:case 3:index2=8;break;case 4:case 5:case 6:index2=9;break;case 7:case 8:index2=10;break;default :REPORT_ERROR();break;}if (biaoshifu!=1)//不是标识符{yuyi(Table[CURRENTSTATE][index]-20);//规约调用语义子程序}else{yuyi2(Table[CURRENTSTATE][index]-20);//规约调用语义子程序}CURRENTSTATE=State[i];i++;State[i]=Table[CURRENTSTATE][index2];CURRENTSTATE=State[i];}}else{Accept();CURRENTSTATE=0;}}void main(){int res;State[0]=0;if((fp=fopen("b.txt","r"))==NULL) {printf("file open error!\n");exit(0);}else{res=cifa(fp);if(start==1)//文件以begin开始{do{res=cifa(fp);if(end==0){fseek(fp,-1,1);//文件指针回退一个*/。
语义分析实验报告

云南大学编译原理实验报告实验题目:语义分析学院:信息学院专业:计算机科学与技术学号: 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的综合属性为返回值(若有多个综合属性,可返回记录类型的值)。
语义分析

三、词法、语法、语义分析结合一、实验目的与要求在实现词法、语法分析程序的基础上,编写相应的语义子程序,进行语义处理,加深对语法制导翻译原理的理解,进一步掌握将语法分析所识别的语法范畴变换为某种中间代码(四元式)的语义分析方法,并完成相关语义分析器的代码开发。
二、实验内容语法制导翻译模式是在语法分析的基础上,增加语义操作来实现的。
对于给定文法中的每一产生式,编写相应的语义子程序。
在语法分析过程中,每当用一个产生式进行推导或归约时,语法分析程序除执行相应的语法分析动作之外,还要调用相应的语义子程序,以便完成生成中间代码、查填有关表格、检查并报告源程序中的语义错误等工作。
每个语义子程序需指明相应产生式中各个符号的具体含义,并规定使用该产生式进行分析时所应采取的语义动作。
这样,语法制导翻译程序在对源程序从左到右进行的一遍扫描中,既完成语法分析任务,又完成语义分析和中间代码生成方面的工作。
输入:包含测试用例,如由无符号数和+、−、*、/、(、)构成的算术表达式的源程序文件。
输出:将源程序转换为中间代码形式表示,并将中间代码序列输出到文件中。
若源程序中有错误,应指出错误信息。
三、实验设计语法制导翻译模式实际上是对前后文无关文法的一种扩展。
一般而言,首先需要根据进行的语义工作,完成对文法的必要拆分和语义动作的编写,从而为每个产生式都配备相应的语义子程序,以便在进行语法分析的同时进行语义解释。
要求从编译器的整体设计出发,重点通过对实验二中语法分析程序的扩展,完成一个编译器前端程序的编写、调试和测试工作,形成一个将源程序翻译为中间代码序列的编译系统。
对文法G3[<算术表达式>]中的产生式添加语义处理子程序,完成无符号数的四则运算的计值处理,将输入的四则运算转换为四元式形式的中间代码。
本实验只进行了算术表达式四元式的翻译。
四、源代码1、在.h文件中添加了//语义分析部分#define PMAX 5//define 后面不加括号,定义产生式符号属性字符串的长度int NXQ=0; /*全局变量NXQ用于指示所要产生的下一个四元式的编号*/int NXTemp=1;//整型变量NXTemp指示临时变量的编号int SentenceCount=1;//存放文件中句子的个数struct QUATERNION /*四元式表的结构*/{char op[PMAX]; /*操作符*/char arg1[PMAX]; /*第一个操作数*/char arg2[PMAX]; /*第二个操作数*/char result[PMAX]; /*运算结果*/}pQuad[256]; /*存放四元式的数组*/char EBracket_Place[PMAX];//(E)的语义属性char i_Place[PMAX];char E_Place[PMAX];char T_Place[PMAX];char F_Place[PMAX];//char JudgeStr[100];int EXCUTE (int state, int symbol,FILE *fp,char JudgeStr[],int row,int index);int GetChar (char ch);int HandleError (char StrJudge[],int row);int Push( int State );int Pop(int count);int SLRControl(FILE* fp);void GEN(char *Op, char *Arg1, char *Arg2, char *Result);char *NewTemp(void);void NextSentence(FILE* fp);//当语法或者词法产生错误的时候,跳过当前错误的句子,将文件指针指向下一个句子的开始#define MAXLENGTH 10;void GEN(char *Op, char *Arg1, char *Arg2, char *Result){strcpy (pQuad[NXQ].op, Op); /*pQuad为全局变量,是用于存放四元式的数组*/strcpy (pQuad[NXQ].arg1, Arg1);strcpy (pQuad[NXQ].arg2, Arg2);strcpy (pQuad[NXQ].result, Result);NXQ++; /*全局变量NXQ用于指示所要产生的下一个四元式的编号*/}char *NewTemp(void) /*产生一个临时变量*/{char *TempID=(char*)malloc(PMAX);sprintf (TempID, "T%d", NXTemp++);return TempID;}2、在.cpp文件中修改的部分int SLRControl(FILE* fp){while(Action[TopState][InputWordType][0] != 'A'){if (UNKNOWN==InputWordType){printf("**********************分析语句%i 时词法分析出错******************\n",SentenceCount);return 0;}printf("栈顶状态:%i\n",TopState);printf("扫描的单词类型:%i\n",InputWordType);/*if ('A'==Action[State][WordType][0]){TopState=0;//正确后把栈顶状态置为初始化StackPoint=0;//同理上面memset(StateStack,-1,sizeof(StateStack));printf("Right!");return 1;}*/if (-1==TopState){printf("分析语句%i 时状态栈栈顶指针错误!分析结束\n",SentenceCount);return 0;}if (' ' == Action[TopState][InputWordType][0]){printf("分析语句%i 时语法分析出错!分析结束\n",SentenceCount);return 0;}else if('s'==Action[TopState][InputWordType][0]){//TopState=atoi(&Action[TopState][InputWordType][1]);Push(atoi(&Action[TopState][InputWordType][1]));printf("执行压栈操作\n");if (EOF!=fgetc(fp)){scanner(fp);}else{printf("语句%i 不完整!分析结束\n",SentenceCount);return 0;}}else if('r'==Action[TopState][InputWordType][0]){//do//用一个while循环为了可能遇到连续规约的情况,即从文件中扫描一个单词之后,可能连续规约多次//{int ProductionNum=atoi(&Action[TopState][InputWordType][1]);int ProdutionLeft=0;if (1==ProductionNum){ProdutionLeft=E;//为下面差goto表提供列坐标Pop(3);printf("用产生式1 归约\n");char* Temp=NewTemp();GEN("+",E_Place,T_Place,Temp);strcpy(E_Place,Temp);printf("生成四元式:(“+”,E_Place,T_Place,E_Place)\n"); }else if(2==ProductionNum){ProdutionLeft=E;Pop(3);printf("用产生式2 归约\n");char* Temp=NewTemp();GEN("-",E_Place,T_Place,Temp);strcpy(E_Place,Temp);printf("生成四元式:(“-”,E_Place,T_Place,E_Place)\n"); }else if(3==ProductionNum){ProdutionLeft=E;Pop(1);printf("用产生式3 归约\n");char* Temp=NewTemp();GEN("",T_Place,"",Temp);strcpy(E_Place,Temp);printf("生成四元式:(-,-,T_Place,E_Place)\n");}else if(4==ProductionNum){ProdutionLeft=T;Pop(3);printf("用产生式4 归约\n");char* Temp=NewTemp();GEN("*",T_Place,F_Place,Temp);strcpy(T_Place,Temp);printf("生成四元式:(“*”,T_Place,F_Place,T_Place)\n"); }else if(5==ProductionNum){ProdutionLeft=T;Pop(3);printf("用产生式5 归约\n");char* Temp=NewTemp();GEN("/",T_Place,F_Place,Temp);strcpy(T_Place,Temp);printf("生成四元式:(“/”,T_Place,F_Place,T_Place)\n");}else if(6==ProductionNum){ProdutionLeft=T;Pop(1);printf("用产生式6 归约\n");char* Temp=NewTemp();GEN("+",F_Place,"",Temp);strcpy(T_Place,Temp);printf("生成四元式:(-,-,F_Place,T_Place)\n");}else if(7==ProductionNum){ProdutionLeft=F;Pop(3);printf("用产生式7 归约\n");char* Temp=NewTemp();GEN("+",EBracket_Place,"",Temp);strcpy(F_Place,Temp);printf("生成四元式:(-,-,(E)_Place,F_Place)\n");}else if(8==ProductionNum){ProdutionLeft=F;Pop(1);printf("用产生式8 归约\n");char* Temp=NewTemp();GEN("+",i_Place,"",Temp);strcpy(F_Place,Temp);printf("生成四元式:(-,-,i_Place,F_Place)\n");}else{printf("分析语句%i 时产生式编号超出范围!分析结束\n",SentenceCount);return 0;}Push(Goto[TopState][ProdutionLeft]);//}while('r' == Action[TopState][InputWordType][0])}}printf("栈顶状态:%i\n",TopState);printf("扫描的单词类型:%i\n",InputWordType);printf("*********************************语句%i 正确*********************************\n",SentenceCount);return 1;}void NextSentence(FILE* fp){while ('#'!= ch){ch=fgetc(fp);}if('\n'==fgetc(fp)){return;}SentenceCount++;return;}/////////////////////////////////主程序int main(int argc, char* argv[]){extern char ch;FILE *fp;if((fp=fopen("date.txt","r"))==NULL){printf("\nfile open error!\n");exit(0);}if(ch=fgetc(fp)=='EOF')//不管小括号内的判断是否成功,p指针都会向后移一个位置,判断不成功,ch中存的字符不变{printf("The file is null.\n");return 0;}while ('\n'!=fgetc(fp)){TopState=0;StackPoint=0;memset(StateStack,-1,sizeof(StateStack));printf("***********************语句%i 分析开始**************************\n",SentenceCount);scanner(fp);SLRControl(fp);NextSentence(fp);}//printf("第一个字母是:%c\n",ch);//fseek(p,-1,1);/*do{scanner(p);}while(ch=fgetc(p)!=EOF);*/fclose(fp);return 0;}五、测试用例和结果分析运行结果:结果分析:虽然能分开语句,但仍用“#”做结束标识符。
编译原理_ 语义分析_实验报告

编译原理实验三语义分析实验报告◆学院:数学与计算机科学技术学院◆专业:计算机科学与技术◆班级:级计算机班◆小组组员:姓名:学号:姓名:学号:姓名:学号:姓名:学号:实验题目一、实验目的要求学生用与实验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) "ε" 表示空串。
(完整word版)语义分析实验报告(word文档良心出品)

软件学院实验卡和实验报告学号:xxxxxxxxxxx姓名:xxx年级专业班级:xxxxxxxxxxxxxxxxxxx xxx实验室组别:__ __ 实验日期:2xxx 年xx 月xxx 日附录1 程序功能1.1操作实例例如:对源程序begin a:=2+3*4;x:=(a+b)/c; end#进行判断;首先运行程序,程序出现提示:“请输入字符串,以#号结束:”,在光标处输入begin a:=2+3*4;x:=(a+b)/c; end#,回车,结果如图:程序给出了三地址码形式的四元式。
1.2 错误处理(1)如果用户在语句串开头处没有输入“begin ”,程序提示“缺少begin !”;如果用户没有输入“end ”,程序提示“end !错误”;(2)如果用户输入的语句串中缺少赋值符号(“:=”),程序提示“缺少赋值符号!”;(3)如果用户输入的语句串中“(”和“)”不匹配,程序提示“缺少“(”!”或“缺少“)!”。
2源程序#include<stdio.h>#include<string.h>#include <stdlib.h>char prog[80],token[8];char ch;int syn,p,m,n,sum;int kk=0,ii,N,nn=0;int k=0,t,i=0;char tt;char * keywords[6] = {"begin","if","then","while","do","end"}; //关键字表。
int scaner();int parser();int statement();int sentence();char *term();char *factor();char *expression();void emit(char *result,char *ag1,char *op,char *ag2);struct //四元式的结构。
编译原理实验报告语义分析

编译原理实验报告语义分析实验名称:语义分析实验目的:1.掌握词法分析器生成的词法单元序列的构造;2.学会设计语法分析器,实现对程序的基本语法结构检查,并生成抽象语法树;3.学习语义规约的实现,实现对程序的语义分析和错误检查;4.熟悉语义分析向语法分析的接口。
实验原理:语义分析是编译过程的一个重要环节,它的主要任务是对生成的抽象语法树进行遍历,并验证程序的类型一致性、语义规则的正确性、错误的检查和恢复等。
语义分析的输入是由语法分析生成的抽象语法树,输出是继续优化的抽象语法树或中间代码,以供后续的中间代码生成等工作使用。
实验步骤:1.设计语法分析器,包括语法规则、优先级关系等;2.生成词法单元序列;3.构建语法分析器,进行语法分析,并生成抽象语法树;4.针对不同的语义规约,设计语义动作,实现对程序的语义分析和错误检查;5.完成语义分析器的构建和测试。
实验设备:1.计算机;2. 编程语言:C++/Java/Python等;3. 开发环境:Visual Studio/ Eclipse/PyCharm等。
实验结果:通过对语法分析生成的抽象语法树进行遍历,实现了对程序的语义分析和错误检查。
具体实现包括:1.类型检查:根据语义规约,对程序中的类型进行检查,包括变量的声明及使用、函数的调用、赋值语句的一致性等;2.作用域检查:检查变量的作用域和可见性等;3.错误检查:检测语义错误,如变量未声明、函数重复定义等;4.错误恢复:当检测到错误时,采取适当的错误恢复措施,如跳过错误的部分继续分析、提示错误信息等。
实验心得:本次实验主要学习了语义分析的原理和实现方法,深入了解了编译过程中各个环节的作用和关系。
通过实践操作,加深了对语法分析和语义分析的理解,提高了编程能力和解决问题的能力。
同时,实验过程中也遇到了一些挑战和困难,例如语义规约的设计和实现、错误检查和恢复等,但通过查阅资料和与同学讨论,最终解决了这些问题。
通过本次实验,我对编译原理和语义分析有了更深入的了解,并且对以后的学习和工作有了更好的准备。
编译原理实验报告-语义分析

编译原理课程实验报告实验3:语义分析图2-1本程序根据之前两个实验的结果进一步进行语义分析,主要是通过在第二个实验句法分析过程中添加语义分析功能完成的。
在代码编写之前,我将程序的功能模块分为界面及主控程序,实体类和工具类三大部分。
MyCompiler是整个程序运行的入口,是主控程序;ComplierFrame完成程序的界面,以及界面里事件的响应;Token是词法分析中词法单元的实体类;ErrorToken是错误的词法单元实体类;Symbol是句法分析中符号的实体类;Production是产生式的实体类;ErrorProduction是句法分析中产生错误的时候使用的产生式实体类;Id是标示符实体类,保存了语义分析后的标识符表;Node是语法分析树的节点类,帮助完成语法分析树的构造;LL类使用LL(1)分析法完成句法分析,同时完成语义分析;MyScanner完成了词法分析。
图2-2三、详细设计及实现得分要求:对如下工作进行展开描述(1)核心数据结构的设计本程序使用了两个新的实体类,分别是Id和Node。
Id是标识符,里面也包含了该标识符在本程序中存储的地址和长度等信息。
Id的属性如下:private String name; //名private String type;//基本类型private int offset;//起始地址private int length;//长度开始输入词法分析读入Token尝试匹配是否错误存储错误记录,处理栈顶与Token 序列是否为语义符号存储产生式,处理栈顶与Token 序列判断动作符号执行语义动作是否读到Token末尾打印结果结束分析结果以及错误报告:图4-1 标识符表:图4-2。
编译原理语义分析实验报告

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';
语义分析实验报告

语义分析实验报告语义分析实验报告引言语义分析是自然语言处理领域中的重要研究方向,旨在理解和解释文本中的意义。
它涉及词汇、句法和语义的分析,以便将文本转化为机器可理解的形式。
本实验报告旨在介绍我们进行的语义分析实验,并分析实验结果。
实验目的本次实验的主要目的是使用现有的语义分析工具和技术,对一组文本进行分析,以探索其在语义理解方面的效果和限制。
我们希望通过实验,深入了解语义分析的原理和应用。
实验设计我们选择了一组新闻文章作为实验对象,这些文章涵盖了不同主题和语境。
我们使用了一种基于深度学习的语义分析工具,该工具能够将文本转化为向量表示,并通过计算向量之间的相似度来衡量语义相关性。
我们将对比不同文章之间的相似度,并分析结果。
实验过程首先,我们将文本数据进行预处理,包括去除停用词、标点符号和数字,以及进行词形还原和词干提取等操作。
这样可以减少文本噪音,提高语义分析的准确性。
然后,我们使用语义分析工具对预处理后的文本进行处理,将其转化为向量表示。
这些向量表示可以捕捉到文本中的语义信息,并用于计算相似度。
接下来,我们对不同文章之间的相似度进行计算,并将结果进行可视化展示。
我们使用了一种常见的相似度度量方法,如余弦相似度等。
通过比较不同文章之间的相似度,我们可以发现它们之间的语义关联程度。
实验结果我们发现,在相同主题的新闻文章中,语义分析工具表现出较高的准确性和一致性。
相似主题的文章通常具有较高的相似度,而不同主题的文章则具有较低的相似度。
这表明语义分析工具能够有效地捕捉到文本的语义信息。
然而,在处理一些语义复杂或上下文模糊的文章时,语义分析工具的效果有所下降。
这可能是由于工具在处理复杂语义结构时存在一定的局限性。
此外,工具对于一些专业领域的术语和特定语境的理解也存在一定的困难。
讨论与展望本次实验结果表明,语义分析在理解文本意义方面具有一定的能力和局限性。
在未来的研究中,我们可以进一步改进语义分析工具,以提高其对复杂语义结构和专业领域的理解能力。
语义分析实验报告

云南大学编译原理实验报告实验题目:语义分析学院:信息学院专业:计算机科学与技术学号: 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的综合属性为返回值(若有多个综合属性,可返回记录类型的值)。
语义分析实验报告

一、实验背景随着信息技术的飞速发展,语义分析作为自然语言处理(NLP)领域的一个重要分支,日益受到学术界和工业界的关注。
语义分析旨在理解和处理人类语言中的语义信息,包括词义消歧、句法分析、指代消解等任务。
本实验旨在通过构建一个简单的语义分析系统,对中文文本进行语义分析,验证语义分析技术在中文处理中的有效性。
二、实验目的1. 了解语义分析的基本原理和方法。
2. 掌握中文语义分析的相关工具和算法。
3. 构建一个简单的语义分析系统,对中文文本进行实验验证。
三、实验内容1. 数据集准备实验数据集采用某中文新闻语料库,包含约5万条新闻文本,每条文本约500字左右。
2. 实验方法(1)词性标注利用基于统计的词性标注工具(如Stanford CoreNLP)对文本进行词性标注,识别文本中的名词、动词、形容词等。
(2)命名实体识别利用命名实体识别(NER)工具(如Stanford CoreNLP)对文本进行命名实体识别,识别文本中的人名、地名、机构名等。
(3)依存句法分析利用依存句法分析工具(如Stanford CoreNLP)对文本进行句法分析,识别文本中的句子成分及其之间的关系。
(4)语义角色标注利用语义角色标注(SRL)工具(如Stanford CoreNLP)对文本进行语义角色标注,识别文本中谓词的宾语、宾语补足语等。
3. 实验步骤(1)数据预处理对实验数据集进行预处理,包括去除停用词、分词、去除特殊符号等。
(2)词性标注使用词性标注工具对预处理后的文本进行词性标注。
(3)命名实体识别使用命名实体识别工具对文本进行命名实体识别。
(4)依存句法分析使用依存句法分析工具对文本进行句法分析。
(5)语义角色标注使用语义角色标注工具对文本进行语义角色标注。
(6)结果分析对实验结果进行分析,评估语义分析系统的性能。
四、实验结果与分析1. 词性标注实验结果显示,词性标注准确率达到95%以上,说明词性标注工具在中文处理中具有较高的准确率。
编译原理实验三-自下而上语法分析报告及语义分析报告.docx

上海电力学院编译原理课程实验报告实验名称:实验三自下而上语法分析及语义分析院系:计算机科学与技术学院专业年级:学生姓名:学号:指导老师:实验日期:实验三自上而下的语法分析一、实验目的:通过本实验掌握LR分析器的构造过程,并根据语法制导翻译,掌握属性文法的自下而上计算的过程。
二、实验学时:4学时。
三、实验内容根据给出的简单表达式的语法构成规则(见五),编制LR分析程序,要求能对用给定的语法规则书写的源程序进行语法分析和语义分析。
对于正确的表达式,给出表达式的值。
对于错误的表达式,给出出错位置。
四、实验方法采用LR分析法。
首先给出S-属性文法的定义(为简便起见,每个文法符号只设置一个综合属性,即该文法符号所代表的表达式的值。
属性文法的定义可参照书137页表6.1),并将其改造成用LR分析实现时的语义分析动作(可参照书145页表6.5)。
接下来给出LR分析表。
然后程序的具体实现:●LR分析表可用二维数组(或其他)实现。
●添加一个val栈作为语义分析实现的工具。
●编写总控程序,实现语法分析和语义分析的过程。
注:对于整数的识别可以借助实验1。
五、文法定义简单的表达式文法如下:(1)E->E+T(2)E->E-T(3)E->T(4)T->T*F(5)T->T/F(6)T->F(7)F->(E)(8)F->i五、处理程序例和处理结果例示例1:20133191*(20133191+3191)+ 3191#六、源代码【cifa.h】//cifa.h#include<string> using namespace std;//单词结构定义struct WordType{int code;string pro;};//函数声明WordType get_w();void getch();void getBC();bool isLetter();bool isDigit();void retract();int Reserve(string str); string concat(string str); 【Table.action.h】//table_action.hclass Table_action{int row_num,line_num;int lineName[8];string tableData[16][8]; public:Table_action(){row_num=16;line_num=8;lineName[0]=30;lineName[1]=7;lineName[2]=13;lineName[3]=8;lineName[4]=14;lineName[5]=1;lineName[6]=2;lineName[7]=15;lineName[8]=0;for(int m=0;m<row_num;m++) for(int n=0;n<line_num;n++) tableData[m][n]="";tableData[0][0]="S5";tableData[0][5]="S4";tableData[1][1]="S6";tableData[1][2]="S12";tableData[1][7]="acc";tableData[2][1]="R3";tableData[2][2]="R3";tableData[2][3]="S7";tableData[2][6]="R3"; tableData[2][7]="R3"; tableData[3][1]="R6"; tableData[3][2]="R6"; tableData[3][3]="R6"; tableData[3][4]="R6"; tableData[3][6]="R6"; tableData[3][7]="R6"; tableData[4][0]="S5"; tableData[4][5]="S4"; tableData[5][1]="R8"; tableData[5][2]="R8"; tableData[5][3]="R8"; tableData[5][4]="R8"; tableData[5][6]="R8"; tableData[5][7]="R8"; tableData[6][0]="S5"; tableData[6][5]="S4"; tableData[7][0]="S5"; tableData[7][5]="S4"; tableData[8][1]="S6";tableData[8][6]="S11"; tableData[9][1]="R1"; tableData[9][2]="R1"; tableData[9][3]="S7"; tableData[9][4]="S13"; tableData[9][6]="R1"; tableData[9][7]="R1"; tableData[10][1]="R4"; tableData[10][2]="R4"; tableData[10][3]="R4"; tableData[10][4]="R4"; tableData[10][6]="R4"; tableData[10][7]="R4"; tableData[11][1]="R7"; tableData[11][2]="R7"; tableData[11][3]="R7"; tableData[11][4]="R7"; tableData[11][6]="R7"; tableData[11][7]="R7"; tableData[12][0]="S5"; tableData[12][5]="S4";tableData[13][5]="S4";tableData[14][1]="R2";tableData[14][2]="R2";tableData[14][3]="S7";tableData[14][4]="S13";tableData[14][6]="R2";tableData[14][7]="R2";tableData[15][1]="R5";tableData[15][2]="R5";tableData[15][3]="R5";tableData[15][4]="R5";tableData[15][5]="R5";tableData[15][6]="R5";tableData[15][7]="R5";}string getCell(int rowN,int lineN){int row=rowN;int line=getLineNumber(lineN);if(row>=0&&row<row_num&&line>=0&&line<=line_num) return tableData[row][line];elsereturn"";}int getLineNumber(int lineN){for(int i=0;i<line_num;i++)if(lineName[i]==lineN)return i;return -1;}};【Table_go.h】//table_go.hclass Table_go{int row_num,line_num;//行数、列数string lineName[3];int tableData[16][3];public:Table_go(){row_num=16;line_num=3;lineName[0]="E";lineName[1]="T";lineName[2]="F";for(int m=0;m<row_num;m++) for(int n=0;n<line_num;n++)tableData[m][n]=0;tableData[0][0]=1;tableData[0][1]=2;tableData[0][2]=3;tableData[4][0]=8;tableData[4][1]=2;tableData[4][2]=3;tableData[6][1]=9;tableData[6][2]=3;tableData[7][2]=10;tableData[12][1]=14;tableData[12][2]=3;tableData[13][2]=15;}int getCell(int rowN,string lineNa){int row=rowN;int line=getLineNumber(lineNa);if(row>=0&&row<row_num&&line<=line_num) return tableData[row][line];elsereturn -1;}int getLineNumber(string lineNa){for(int i=0;i<line_num;i++)if(lineName[i]==lineNa)return i;return -1;}};【Stack_num.h】class Stack_num{int i; //栈顶标记int *data; //栈结构public:Stack_num() //构造函数{data=new int[100];i=-1;}int push(int m) //进栈操作{i++;data[i]=m;return i;}int pop() //出栈操作{i--;return data[i+1];}int getTop() //返回栈顶{return data[i];}~Stack_num() //析构函数{delete []data;}int topNumber(){return i;}void outStack(){for(int m=0;m<=i;m++)cout<<data[m];}};【Stack_str.h】class Stack_str{int i; //栈顶标记string *data; //栈结构public:Stack_str() //构造函数{data=new string[50];i=-1;}int push(string m) //进栈操作{i++;data[i]=m;return i;}int pop() //出栈操作{data[i]="";i--;return i;}string getTop() //返回栈顶{return data[i];}~Stack_str() //析构函数{delete []data;int topNumber(){return i;}void outStack(){for(int m=0;m<=i;m++)cout<<data[m];}};【cifa.cpp】//cifa.cpp#include<iostream>#include<string>#include"cifa.h"using namespace std;//关键字表和对应的编码stringcodestring[10]={"main","int","if","then","else","return","void","cout","endlint codebook[10]={26,21,22,23,24,25,27,28,29};//全局变量char ch;int flag=0;/*//主函数int main(){WordType word;cout<<"请输入源程序序列:";word=get_w();while(word.pro!="#")//#为自己设置的结束标志{cout<<"("<<word.code<<","<<"“"<<word.pro<<"”"<<")"<<endl;word=get_w();};return 0;}*/WordType get_w(){string str="";int code;WordType wordtmp;getch();//读一个字符getBC();//去掉空白符if(isLetter()){ //以字母开头while(isLetter()||isDigit()){str=concat(str);getch();}retract();code=Reserve(str);if(code==-1){wordtmp.code=0;wordtmp.pro=str;}//不是关键字else{wordtmp.code=code;wordtmp.pro=str;}//是关键字}else if(isDigit()){ //以数字开头while(isDigit()){str=concat(str);getch();}retract();wordtmp.code=30;wordtmp.pro=str;}else if(ch=='(') {wordtmp.code=1;wordtmp.pro="(";} else if(ch==')') {wordtmp.code=2;wordtmp.pro=")";} else if(ch=='{') {wordtmp.code=3;wordtmp.pro="{";} else if(ch=='}') {wordtmp.code=4;wordtmp.pro="}";} else if(ch==';') {wordtmp.code=5;wordtmp.pro=";";} else if(ch=='=') {wordtmp.code=6;wordtmp.pro="=";} else if(ch=='+') {wordtmp.code=7;wordtmp.pro="+";} else if(ch=='*') {wordtmp.code=8;wordtmp.pro="*";} else if(ch=='>') {wordtmp.code=9;wordtmp.pro=">";} else if(ch=='<') {wordtmp.code=10;wordtmp.pro="<";} else if(ch==',') {wordtmp.code=11;wordtmp.pro=",";} else if(ch=='\'') {wordtmp.code=12;wordtmp.pro="\'";} else if(ch=='-') {wordtmp.code=13;wordtmp.pro="-";} else if(ch=='/') {wordtmp.code=14;wordtmp.pro="/";} else if(ch=='#') {wordtmp.code=15;wordtmp.pro="#";} else if(ch=='|') {wordtmp.code=16;wordtmp.pro="|";}else {wordtmp.code=100;wordtmp.pro=ch;}return wordtmp;}void getch(){if(flag==0) //没有回退的字符ch=getchar();else //有回退字符,用回退字符,并设置标志flag=0;}void getBC(){while(ch==' '||ch=='\t'||ch=='\n')ch=getchar();}bool isLetter(){if(ch>='a'&&ch<='z'||ch>='A'&&ch<='Z')return true;elsereturn false;}bool isDigit(){if(ch>='0'&&ch<='9')return true;elsereturn false;}string concat(string str){return str+ch;}void retract(){flag=1;}int Reserve(string str){int i;for(i=0;i<=8;i++){if(codestring[i]==str) //是某个关键字,返回对应的编码return codebook[i];}if(i==9) //不是关键字return -1;}【LR.cpp】#include<iostream>#include<string>#include<cstdlib>#include"cifa.h"#include"stack_num.h"#include"stack_str.h"#include"table_action.h"#include"table_go.h"using namespace std;void process(){int stepNum=1;int topStat;Stack_num statusSTK; //状态栈Stack_str symbolSTK; //符号栈Stack_num valueSTK; //值栈WordType word;Table_action actionTAB; //行为表Table_go goTAB; //转向表cout<<"请输入源程序,以#结束:";word=get_w();//总控程序初始化操作symbolSTK.push("#");statusSTK.push(0);valueSTK.push(0);cout<<"步骤\t状态栈\t符号栈\t值栈\t当前词\t动作\t转向"<<endl;//分析while(1){topStat=statusSTK.getTop(); //当前状态栈顶string act=actionTAB.getCell(topStat,word.code);//根据状态栈顶和当前单词查到的动作//输出cout<<stepNum++<<"\t";statusSTK.outStack(); cout<<"\t";symbolSTK.outStack(); cout<<"\t";valueSTK.outStack(); cout<<"\t";cout<<word.pro<<"\t";//行为为“acc”,且当前处理的单词为#,且状态栈里就两个状态//说明正常分析结束if(act=="acc"&&word.pro=="#"&&statusSTK.topNumber()==1){cout<<act<<endl;cout<<"分析成功!"<<endl;cout<<"结果为:"<<valueSTK.getTop()<<endl;return;}//读到act表里标记为错误的单元格else if(act==""){cout<<endl<<"不是文法的句子!"<<endl;cout<<"错误的位置为单词"<<word.pro<<"附近。
编译原理语义分析实验报告

编译原理语义分析实验报告编译原理语义分析实验报告引言编译原理是计算机科学的重要基础课程之一,它主要研究如何将高级语言转换为低级语言,使计算机能够理解和执行人类可读的代码。
语义分析是编译过程中的重要环节,它负责对代码进行语义检查和语义解释,以确保代码的正确性和可执行性。
本实验报告旨在介绍编译原理中语义分析的基本原理和实验过程。
一、实验目的本次实验的主要目的是通过实现一个简单的语义分析器,加深对编译原理中语义分析的理解。
具体来说,我们将实现以下功能:1. 识别并解析变量声明和赋值语句;2. 检查变量的重复声明和赋值类型的一致性;3. 计算并输出表达式的值。
二、实验环境和工具为了完成本次实验,我们需要准备以下环境和工具:1. 操作系统:Windows、Linux或MacOS;2. 编程语言:C++、Java或Python;3. 开发工具:编译器和调试器。
三、实验原理语义分析是编译过程中的重要环节,它主要负责对代码进行语义检查和语义解释。
在编译器中,语义分析器通常通过构建抽象语法树(AST)来实现。
AST是一种树状的数据结构,用于表示代码的语法结构和语义信息。
在语义分析的过程中,我们需要进行变量声明和赋值语句的解析和检查。
首先,我们需要识别代码中的变量声明和赋值语句,并将其转换成AST。
在解析过程中,我们需要检查变量的重复声明和赋值类型的一致性。
如果发现错误,我们需要报告相应的错误信息,并终止编译过程。
接下来,我们需要对表达式进行求值。
表达式是编程语言中的核心概念,它由操作数和运算符组成。
在求值过程中,我们需要考虑运算符的优先级和结合性。
为了实现这一功能,我们可以使用递归下降法或者使用运算符优先级算法。
四、实验过程1. 识别变量声明和赋值语句我们首先需要编写词法分析器,将代码中的字符序列转换成标记序列。
在词法分析的过程中,我们需要识别变量声明和赋值语句的关键字和标识符,并将其转换成相应的标记。
2. 构建抽象语法树在词法分析的基础上,我们可以构建抽象语法树。
实验三语义分析报告

编译原理实验报告实验名称:分析调试语义分析程序实验类型:验证型指导教师:专业班级:姓名:学号:实验地点:实验成绩:日期:2016 年 6 月 3 日实验三分析调试语义分析程序一、实验目的通过分析调试TEST语言的语义分析和中间代码生成程序,加深对语法制导翻译思想的理解,掌握将语法分析所识别的语法范畴变换为中间代码的语义翻译方法。
二、实验知识1.语法制导基本思想语法制导就是对文法中的每个产生式都附加一个语义动作或语义子程序,且在语法分析过程中,每当需要使用一个产生式进行推导或归约时,语法分析程序除执行相应的语法分析动作外,还要执行相应的语义动作或调用相应的语义子程序。
基本思想是,根据翻译的需要设置文法符号的属性,以描述语法结构的语义。
例如,一个变量的属性有类型,层次,存储地址等。
表达式的属性有类型,值等。
属性值的计算和产生式相联系。
随着语法分析的进行,执行属性值的计算,完成语义分析和翻译的任务。
2.翻译方案设计1)设计原理:在实验二的基础上为文法符号引进一组属性及相应求值规则和动作,得到属性翻译文法,并引进一个符号表(包括变量名,变量数据是否有效,变量地址,变量的具体数据,数据类型等),在进行语法分析的同时,结合符号表完成语义分析与检测,同时根据属性翻译文法的属性及相关动作得到中间代码(抽象机式汇编指令),最后通过模拟的抽象机运行出结果。
2)设计方法:(@为动作标志,↓为继承属性,↑为综合属性)结合课本语法制导相关内容对文法增加属性和动作如下:以下列出有修改的属性翻译文法:①<declaration_stat>↓vartablep,datap,codep →int ID↑n@name-def↓n,t;其中动作符号的含义如下@name-def↓n,t:插入符号表;②<if_stat>→if (<expr>)@BRF↑label1<statement>@BR↑label2 @SETlabel↓label1| if (<expr>) @BRF↑label1<statement >@BR↑label2 @SETlabel↓label1else < statement > @SETlabel↓label2其中动作符号的含义如下@BRF↑label1 :输出BRF label1;@BR↑label2:输出BR label2;@SETlabel↓label1:设置标号label1;@SETlabel↓label2:设置标号label2;③<while_stat>→while@SETlabel↑label1(<expression>) @BRF↑label2<statement >@BR↓label1 @SETlabel↓label2其中动作符号的含义如下@SETlabel↑label1:设置标号label1;@BRF↑label2 :输出BRF label2;@BR↓label1:输出BR label1;@SETlabel↓label2:设置标号label2;④<for_stat>→for (<expression>@POP;@SETlabel↑label1< expression >@BRF↑label2@BR↑label3;@SETlabel↑label4 < expression >@POP@BR↓label1) @SETlabel↓label3 < statement >@BR↓label4@SETlabel↓label2其中动作符号的含义如下@SETlabel↓label1:设置标号label1;@BRF↑label2 :输出BRF label2;@BR↑label3:输出BR label3;@SETlabel↓label4:设置标号label4;@BR↑label1:输出BR label1;@SETlabel↓label3:设置标号label3;@BR↑label4:输出BR label4;@SETlabel↓label2:设置标号label2;⑤<write_stat>→write <expression>@OUT;其中动作符号的含义如下@ OUT:输出OUT⑥<read_stat>→read ID↑n LOOK↓n↑d @IN@STO↓d@POP;其中动作符号的含义如下@LOOK↓n↑d:查符号表n,给出变量地址d;没有,变量没定义;@IN:输出IN;@STO↓d:输出指令代码STO d;@POP:将栈顶元素出栈⑦<expression>→ID↑n@LOOK↓n↑d@ASSIGN=<bool_expr>@STO↓d@POP |<bool_expr>其中动作符号的含义如下@LOOK↓n↑d:查符号表n,给出变量地址d;没有,变量没定义;@ASSIGN:记住当前文件位置;@STO↓d:输出指令代码STO d;⑧<bool_expr>→<additive_expr>|< additive_expr >><additive_expr>@GT|< additive_expr ><<additive_expr>@LES|< additive_expr >>=<additive_expr >@GE|< additive_expr ><=< additive_expr >@LE|< additive_expr >==< additive_expr >@EQ|< additive_expr >!=< additive_expr >@NOTEQ其中动作符号的含义如下@GT:次栈顶与栈顶作大于比较;@LES:次栈顶与栈顶作小于比较;@GE:次栈顶与栈顶作大于等于比较;@LE:次栈顶与栈顶作小于等于比较;@EQ:次栈顶与栈顶作等于比较;@NOTEQ:次栈顶与栈顶作不等于比较;B→+<term>B@ADD | -<term>B@SUB | ε⑨<additive_A>→+<term><additive_A>@ADD | -<term><additive_A>@SUB | ε其中动作符号的含义如下@ADD:操作数相加;@SUB:操作数相减;C→*<factor>C@MULT | /<factor>C@DIV | ε⑩<term_A>→*<factor><term_A>@MULT | /<factor><term_A>@DIV | ε其中动作符号的含义如下@MULT:操作数相乘;@DIV:操作数相除;⑪< factor >→(< expression >)| ID↑n@LOOK↓n↑d@LOAD↓d |NUM↑i@LOADI↓i其中动作符号的含义如下@LOOK↓n↑d:查符号表n,给出变量地址d;没有,变量没定义;@LOAD↓d:将地址d的变量入栈;@LOADI↓i:将常量i入栈;3)设计结果:1) <program>→{<declaration_list><statement_list>}2)<declaration_list>→<declaration_stat> <declaration_list>| ε3) <declaration_stat>↓vartablep,datap,codep →int ID↑n@name-def↓n,t;4) <statement_list>→<statement><statement_list>| ε5) <statement>→<if_stat>|<while_stat>|<for_stat>|<read_stat>|<write_stat>|< compound_stat > |<expression_stat>6)<if_stat>→if (<expr>)@BRF↑label1<statement>@BR↑label2 @SETlabel↓label1| if (<expr>) @BRF↑label1<statement >@BR↑label2 @SETlabel↓label1else < statement > @SETlabel↓label27)<while_stat>→while@SETlabellabel1(<expression>)@BRF↑label2 <statement >@BR ↓label1 @SETlabel↓label28) <for_stat>→for (<expression>;@SETlabel↑label1< expression >@BRF↑label2@BR↑label3;@SETlabel↑label4 < expression >@BR↓label1) @SETlabel↓label3 < statement >@BR ↓label29) <write_stat>→write <expression>@OUT;10) <read_stat>→read ID↑n LOOK↓n↑d @IN@STO↓d@POP;11)<compound_stat>→{<statement_list>}12)<expression_stat>→< expression >@POP;|;13) <expression>→ID↑n@LOOK↓n↑d@ASSIGN=<bool_expr>@STO↓d@POP |<bool_expr>14) <bool_expr>→<additive_expr><bool_A>15) <bool_A>→><additive_expr>@GT|<<additive_expr>@LES|>=<additive_expr >@GE|<=< additive_expr >@LE|==< additive_expr >@EQ|!=< additive_expr >@NOTEQ | ε16) < additive_expr>→<term><additive_A>17) <additive_A>→+<term><additive_A>@ADD | -<term><additive_A>@SUB | ε18) < term >→<factor><term_A>19) <term_A>→*<factor><term_A>@MULT | /<factor><term_A>@DIV | ε20) < factor >→(< expression >)| ID↑n@LOOK↓n↑d@LOAD↓d |NUM↑i@LOADI↓i三、实验过程首先,理解书上的代码和观看相关的知识的PPT,深入理解属性反应文法的作用,据此在我之前实验写好的语法分析基础上进行修改,写出语义分析代码。
编译原理语义分析实验报告 免费

编译原理综合训练语义分析实验报告指导老师:班级:学生:zeadom学号:学生:学号:2011/6/29目录语言文法的形式化描述 (3)语义规则 (3)运行环境介绍 (5)关键算法的流程图及文字解释 (5)1、本编译器的总框架 (5)2、在语义分析中的主要函数介绍 (6)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语义规则(属性文法)EE1+E2EE1*E2E-E1E(E1)E iE iE i1 R i2E┐E1E( E1 )M εE E1∧ME2E E1∨ME2E E1∧ME2S if E then M S1M εN εS if E then M1 S1 N else M2 S2S.nextlist:=merge(S1.nextlist, N.nextlist, S2.nextlist) }S while M1 E do M2 S1 { backpatch(S1.nextlist, M1.quad ); Gen( j , —, —, M1.quad ); backpatch(E.truelist, M2.quad ); S.nextlist:= E.falselist }S begin L end { S.nextlist:=L.nextlist }S A { S.nextlist:= makelist() /*空链*/ }L S { L.nextlist:=S.nextlist }L L1;M S { backpatch(L1.nextlist, M.quad );L.nextlist:=S.nextlist }运行环境介绍运行环境是DEVC++Dev-C++是一个C&C++开发工具,它是一款自由软件,遵守GPL协议。
语义实验报告

一、实验目的本次实验旨在探究语义理解在自然语言处理中的应用,通过设计一系列实验,验证不同语义分析方法在处理复杂文本数据时的效果。
实验将重点考察以下内容:1. 语义相似度计算方法在文本分类中的应用;2. 语义角色标注在信息抽取中的作用;3. 基于语义理解的文本摘要生成。
二、实验背景随着互联网技术的快速发展,文本数据呈爆炸式增长。
如何有效地处理和分析这些海量文本数据,提取有价值的信息,成为当前自然语言处理领域的研究热点。
语义理解作为自然语言处理的核心任务之一,对于文本数据的处理和分析具有重要意义。
三、实验方法本次实验采用以下方法:1. 语义相似度计算:采用余弦相似度和词嵌入(Word2Vec)两种方法计算文本之间的语义相似度,并将其应用于文本分类任务。
2. 语义角色标注:利用依存句法分析技术对文本进行语义角色标注,以提取文本中的关键信息。
3. 文本摘要生成:采用基于语义理解的文本摘要生成方法,对文本进行摘要,提取文本的主要内容和关键信息。
四、实验数据实验数据来自多个公开数据集,包括:1. 文本分类数据集:包含多个领域的文本数据,如新闻、论坛等。
2. 语义角色标注数据集:包含中文文本的依存句法标注数据。
3. 文本摘要数据集:包含多个领域的文本摘要数据。
五、实验结果与分析1. 语义相似度计算- 余弦相似度方法在文本分类任务中的准确率为85%,而词嵌入方法的准确率为90%。
这表明,词嵌入方法在语义相似度计算方面具有更高的准确率。
- 分析原因:词嵌入方法能够将文本中的词语映射到高维空间,使得语义相似的词语在空间中距离更近,从而提高了语义相似度计算的准确率。
2. 语义角色标注- 依存句法分析技术在语义角色标注任务中的准确率为78%,召回率为80%。
这表明,依存句法分析技术在提取文本关键信息方面具有较好的效果。
- 分析原因:依存句法分析能够准确地识别文本中的依存关系,从而有助于提取文本中的关键信息。
3. 文本摘要生成- 基于语义理解的文本摘要生成方法在文本摘要任务中的F1值为0.85。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验三语法分析20080810309 科3 李君林一.实验目的:通过使用、剖析和扩充TINY语言的语义分析程序,掌握编译器的语义分析程序的构造方法。
二.实验内容(一)运行TINY的语义分析程序(二)扩充TINY的语法分析程序提示:考虑作用域(如:函数)和数组时可能需要修改符号表。
三.实验步骤1.先读懂TINY语义程序(相关联的文件:MAIN.C ANALYZE.C ANALYZE.H)(1)buildSymtab(syntaxTree); //根据语法树建立符号表通过递归调用traverse(syntaxTree,insertNode,nullProc);进行static void insertNode( TreeNode * t),这样将遇到与ID有关的Node信息通过void st_insert( char * name, int lineno, int loc,int len )加入到hashTable[h]数据结构中。
(2)接着调用typeCheck(syntaxTree);进行类型检测通过递归调用traverse(syntaxTree,nullProc,checkNode);将语法树遍历,然后调用static void checkNode(TreeNode * t)对节点进行类型检测2.扩充TINY的语法分析程序本次实验我首先将源程序实现的功能改成符合C_MINUS的符号表与类型检测然后加入没申明调用与数组调用错误即数组没申明而调用数组类型。
四.实验结果1.正确的测试程序/**/int gcd (int u,int v[]){if(v==0)return u;elsereturn gcd(v,u);}void main(void){int x;int y;read x;x=y=2;while(x>0)y=y-1;write y;return (gcd(x,y));}/**/运行结果:经检验测试程序代码无语义错误2.错误测试程序/**/int gcd (int u,int v[]){if(v==0)return u;elsereturn gcd(v,u);}void main(void){int x;int y;read x;t=1;x=y=2;x[2]=2;while(x>0)y=y-1;write y;return (gcd(x,y));}/**/实验结果:检测到13行t没有申明检测到15行x不是一个数组五.实验心得通过本次实验学会了使用、剖析和扩充TINY语言的语义分析程序,掌握编译器的语义分析程序的构造方法。
加深了对书本语义分析的理解,感受到学以致用的快感,增强对本课程的兴趣。
实验中遇到的最大问题:如何查询符号表判断数组,后面在其数据结构中增加了一个属性Len,如果不是数组将其赋为-1.六.关键程序代码(ANALYZE.C)/****************************************************//* File: analyze.c *//* Semantic analyzer implementation *//* for the TINY compiler *//* Compiler Construction: Principles and Practice *//* Kenneth C. Louden *//****************************************************/#include "globals.h"#include "symtab.h"#include "analyze.h"/* counter for variable memory locations */static int location = 0;/* Procedure traverse is a generic recursive* syntax tree traversal routine:* it applies preProc in preorder and postProc* in postorder to tree pointed to by t*/static void traverse( TreeNode * t,void (* preProc) (TreeNode *),void (* postProc) (TreeNode *) ){ if (t != NULL){ preProc(t);{ int i;for (i=0; i < MAXCHILDREN; i++)traverse(t->child[i],preProc,postProc);}postProc(t);traverse(t->sibling,preProc,postProc);}}/* nullProc is a do-nothing procedure to* generate preorder-only or postorder-only* traversals from traverse*/static void nullProc(TreeNode * t){ if (t==NULL) return;else return;}static void typeError(TreeNode * t, char * message){ fprintf(listing,"Type error at line %d: %s\n",t->lineno,message);Error = TRUE;}static void unDecError(TreeNode * t){ fprintf(listing,"Type error at line %d: the %s doesn't declaration\n",t->lineno,t->); Error = TRUE;}static void notArrayError(TreeNode * t){ fprintf(listing,"Type error at line %d: the ID %s isn't a Array\n",t->lineno,t->); Error = TRUE;}/* Procedure insertNode inserts* identifiers stored in t into* the symbol table*/static void insertNode( TreeNode * t){ switch (t->nodekind){ case StmtK:switch (t->kind.stmt){default:break;}break;case ExpK:switch (t->kind.exp){ case IdK:if (st_lookup(t->) == -1){/* not yet in table, so treat as new definition */unDecError(t);//st_insert(t->,t->lineno,location++,0);}else{/* already in table, so ignore location,add line number of use only */// printf("LEN:%d\n",t->length);if(t->length!=-1&&st_isArray(t->)==-1)notArrayError(t);elsest_insert(t->,t->lineno,0,-1);}break;default:break;}break;case DecK:switch(t->kind.deck){case VarK:if (st_lookup(t->) == -1){/* not yet in table, so treat as new definition */if(t->length==-1){st_insert(t->,t->lineno,location++,-1);}else{st_insert(t->,t->lineno,location++,t->length);}if(t->length!=-1)location+=t->length-1;}else{/* already in table, so ignore location,add line number of use only */st_insert(t->,t->lineno,0,-1);}case ParaK:if (st_lookup(t->) == -1){/* not yet in table, so treat as new definition */if(t->length==-1){st_insert(t->,t->lineno,location++,-1);}else{st_insert(t->,t->lineno,location++,t->length);}}else/* already in table, so ignore location,add line number of use only */st_insert(t->,t->lineno,0,-1);break;case FunK:if (st_lookup(t->) == -1)/* not yet in table, so treat as new definition */st_insert(t->,t->lineno,location++,-1);/* already in table, so ignore location,add line number of use only */st_insert(t->,t->lineno,0,-1);break;default:break;}break;default:break;}}/* Function buildSymtab constructs the symbol* table by preorder traversal of the syntax tree*/void buildSymtab(TreeNode * syntaxTree){fprintf(listing,"\nunDecError and arrayCallError check\n");traverse(syntaxTree,insertNode,nullProc);fprintf(listing,"\nunDecError and arrayCallError check finished\n");if (TraceAnalyze){if (TraceAnalyze) fprintf(listing,"\nBuilding Symbol Table...\n");printSymTab(listing);}}/* Procedure checkNode performs* type checking at a single tree node*/static void checkNode(TreeNode * t){switch (t->nodekind){ case ExpK:switch (t->kind.exp){ case OpK:if ((t->child[0]->type != Integer) ||(t->child[1]->type != Integer))typeError(t,"Op applied to non-integer");if ((t->attr.op == EQ) || (t->attr.op == LT) || (t->attr.op == BG)|| (t->attr.op == LE) || (t->attr.op == BG) || (t->attr.op == UNEQ))t->type = Boolean;elset->type = Integer;break;case ConstK:case IdK:t->type = Integer;break;default:break;}break;case StmtK:switch (t->kind.stmt)if (t->child[0]->type == Integer)typeError(t->child[0],"if test is not Boolean");break;case IteK:if (t->child[0]->type == Integer)typeError(t->child[0],"while test is not Boolean");break;case WriteK:if (t->child[0]->type != Integer)typeError(t->child[0],"write of non-integer value");break;default:break;}break;default:break;}}/* Procedure typeCheck performs type checking* by a postorder syntax tree traversal*/void typeCheck(TreeNode * syntaxTree){traverse(syntaxTree,nullProc,checkNode);}。