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

编译原理第六章语义分析目录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);//文件指针回退一个*/。
编译原理语义分析实验报告

实验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#输出结果八、收获(体会)与建议通过此次实验, 让我了解到如何设计、编制并调试语义分析程序, 加深了对语法制导翻译原理的理解, 掌握了将语法分析所识别的语法成分变换为中间代码的语义翻译方法。
编译原理_ 语义分析_实验报告

编译原理实验三语义分析实验报告◆学院:数学与计算机科学技术学院◆专业:计算机科学与技术◆班级:级计算机班◆小组组员:姓名:学号:姓名:学号:姓名:学号:姓名:学号:实验题目一、实验目的要求学生用与实验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.学习语义规约的实现,实现对程序的语义分析和错误检查;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';
语义分析实验报告

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

一、实验背景随着信息技术的飞速发展,语义分析作为自然语言处理(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%以上,说明词性标注工具在中文处理中具有较高的准确率。
编译原理语义分析实验报告 免费

编译原理综合训练语义分析实验报告指导老师:班级:学生: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. 操作系统: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,深入理解属性反应文法的作用,据此在我之前实验写好的语法分析基础上进行修改,写出语义分析代码。
编译原理语义分析报告

《编译原理》实验报告专业班级_软工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、实验结果实验的输入和输出:输入是语法分析提供的正确的单词串,输出为三地址指令形式的四元式序列。
语义分析报告

语义分析报告
根据任务需求,对文本进行语义分析可以从以下几个方面进行报告:
1. 实体识别:通过对文本进行实体识别,可以了解文本中包含的人名、地名、组织机
构名等实体信息。
通过识别实体,可以帮助理解文本的内容,提供更准确的语义分析
结果。
2. 关系抽取:通过对文本进行关系抽取,可以分析出文本中实体之间的关系。
例如,
可以分析出人物之间的关系(亲属关系、合作关系等)、地点之间的关系(居住关系、距离关系等)等。
关系抽取可以帮助进一步理解文本的语义含义。
3. 情感分析:通过对文本进行情感分析,可以判断文本中所表达的情感倾向。
例如,
文本的意思是否积极、消极或中性,可以帮助理解文本的观点、情感等信息。
4. 观点分析:通过对文本进行观点分析,可以分析出文本中所表达的观点或立场。
例如,可以判断文本的作者支持还是反对某个观点、行为等。
观点分析可以帮助理解文
本的立场、态度等信息。
5. 主题抽取:通过对文本进行主题抽取,可以识别出文本所讨论的主要主题或话题。
例如,可以从新闻报道中抽取出主要的新闻事件、从社交媒体中识别出热门话题等。
主题抽取可以帮助理解文本的重点内容。
以上是语义分析的一些常见任务和方法,根据具体的任务需求,可以选择适当的方法
进行分析和报告。
编译原理语义实验报告

编译原理语义实验报告编译原理语义实验报告引言:编译原理是计算机科学中的重要课程之一,它研究的是如何将高级程序语言转化为机器语言,使得计算机能够理解并执行程序。
语义分析是编译过程中的重要环节,它负责对程序的语义进行分析和处理。
本实验报告将介绍我们在编译原理课程中进行的语义实验,并分享我们的实验结果和心得体会。
实验目的:本次实验的主要目的是掌握语义分析的基本原理和方法,了解如何构建语法树以及如何进行类型检查和语义规则的验证。
通过实验,我们将能够更好地理解编译器是如何对程序进行处理和优化的。
实验环境和工具:为了完成本次实验,我们使用了一些常见的编程语言和工具。
其中,我们选择了C语言作为实验的目标语言,并使用了Flex和Bison作为词法分析器和语法分析器的生成工具。
此外,我们还使用了一些辅助工具和库,如LLVM和GCC 等。
实验过程:在实验过程中,我们首先需要设计和实现一个简单的编程语言,包括其语法和语义规则。
然后,我们使用Flex和Bison来生成词法分析器和语法分析器,并通过这些工具将源代码转换为语法树。
接下来,我们对语法树进行类型检查和语义规则的验证,以确保程序的正确性和合法性。
最后,我们将生成的中间代码转化为目标代码,并进行优化和生成可执行文件。
实验结果:通过实验,我们成功地设计和实现了一个简单的编程语言,并使用Flex和Bison生成了相应的词法分析器和语法分析器。
我们还实现了类型检查和语义规则的验证,确保了程序的正确性和合法性。
最终,我们成功地将生成的中间代码转化为目标代码,并生成了可执行文件。
实验心得:通过本次实验,我们深入理解了编译原理中的语义分析过程。
我们学会了如何构建语法树,并对其进行类型检查和语义规则的验证。
我们还学会了使用一些常见的编程语言和工具,如C语言、Flex、Bison等。
通过实验,我们不仅提高了自己的编程能力,还加深了对编译原理的理解和认识。
结论:编译原理是计算机科学中的重要课程,语义分析是编译过程中的关键环节。
语义分析实验报告

实验三语法分析309 科3 李君林一.实验目的:通过使用、剖析和扩充TINY语言的语义分析程序,掌握编译器的语义分析程序的构造方法。
二.实验内容(一)运行TINY的语义分析程序(二)扩充TINY的语法分析程序提示:考虑作用域(如:函数)和数组时可能需要修改符号表。
三.实验步骤1.先读懂TINY语义程序(相关联的文件:)(1)buildSymtab(syntaxTree); 充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.六.关键程序代码()/****************************************************//* File: *//* Semantic analyzer implementation *//* for the TINY compiler *//* Compiler Construction: Principles and Practice *//* Kenneth C. Louden *//****************************************************/#include ""#include ""#include ""/* 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->{default:break;}break;case ExpK:switch (t->{ case IdK:if (st_lookup(t-> == -1){/* not yet in table, so treat as new definition */unDecError(t);.\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->{ case OpK:if ((t->child[0]->type != Integer) ||(t->child[1]->type != Integer))typeError(t,"Op applied to non-integer");if ((t-> == EQ) || (t-> == LT) || (t-> == BG)|| (t-> == LE) || (t-> == BG) || (t-> == UNEQ))t->type = Boolean;elset->type = Integer;break;case ConstK:case IdK:t->type = Integer;break;default:break;}break;case StmtK:switch (t->{ case SelK: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); }。
语义实验报告

一、实验目的本次实验旨在探究语义理解在自然语言处理中的应用,通过设计一系列实验,验证不同语义分析方法在处理复杂文本数据时的效果。
实验将重点考察以下内容: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)。
云南大学编译原理实验报告
实验题目:语义分析
学院:信息学院
专业:计算机科学与技术
学号: 064
姓名:刘继远
目录
一、实验目的 ..................... 错误!未定义书签。
二、实验内容 ..................... 错误!未定义书签。
三、源程序分析 ................... 错误!未定义书签。
1、程序采用的BNF .............. 错误!未定义书签。
2、根据语义要求得到对应的翻译模式错误!未定义书
签。
3、实现原理 ................... 错误!未定义书签。
4、文法的属性分析 ............. 错误!未定义书签。
5、过程设计 ................... 错误!未定义书签。
6、子程序说明 ................. 错误!未定义书签。
四、设计的基本思想(包括修改之后的属性文法、属性类型分析、翻译模式) ................. 错误!未定义书签。
1、增加除法运算 ............... 错误!未定义书签。
2、禁止同名重复声明 ........... 错误!未定义书签。
五、结果及分析 ................... 错误!未定义书签。
一、实验目的
进一步理解递归下降分析原理和实现方法,理解语义分析的基本机制,掌握语义子程序的构造方法。
二、实验内容
将带变量声明的表达式翻译为四元式序列,其中包括以下要求:
非终结符号D实现定义两种类型int, real变量的声明;
非终结符号S实现变量之间的*,+,: =(赋值运算)
两个关键字 int 和real
变量之间的*,+,: =(赋值) 运算只能使用声明过的变量,所以要检查使用的变量是否声明过。
对每个*,+,: =(赋值) 运算生成一条四元式如(*,A,B,T1),其中T1是临时变量
*优先级别高于+,*满足左结合规则
三、源程序分析
这是一个简单的包含词法、语法、语义分析的程序:语义分析.h和语义分析.cpp。
实现的基本原理是自顶向下分析,单遍扫描,以语法分析为核心,调用词法分析,并实现语义分析。
1、程序采用的BNF
P→ DS.
D→B; D
D→ε
B→int L | real L
L→id | L,id
S→ V := E H
H→;S | ε
E→E+T | T
T→T*F|F
F→( E )
F→id
V→id
消除左递归之后的等价文法
start→ DS.
D→B; D
D→ε
B→int L | real L
L→id A
A→ ,idA
A→ε
S→ V := E H
H→;S | ε
E→T R
R→+T R
R→ ε
T→F P
P→* F P
P→ε
F→( E )
F→id
V→id
2、根据语义要求得到对应的翻译模式
start→ DS.
D→ B; D
D→ε
B→ int L { := int } | real L { := real }
L→ id { := enter, }A
A→ ,idA { := enter,}
A→ε
S→ V := E { gen( ":=", ,0, } H
H→;S | ε
E→T { :=} R {:=}
R→+T { := newtemp; gen( "+", , , } R {:= ; } R→ ε {Rs=}
T→F { :=} P { :=}
P→* F { := newtemp; gen( "*", , , T) } P {:= ; } P→ε {=}
F→( E ) { := }
F→id {:=position (id)}
V→id {:=position(id)}
3、实现原理
基于翻译模式的自上而下语义处理(翻译)
1.对每个非终结符 A,构造一个函数,以 A 的每个继承属性为形参,以A的
综合属性为返回值(若有多个综合属性,可返回记录类型的值)。
如同预测分析程序的构造,该函数代码的流程是根据当前的输入符号来决定调用哪个产生式。
2.与每个产生式相关的代码根据产生式右端的终结符,非终结符,和语义规则
集(语义动作),依从左到右的次序完成下列工作:
(1)对终结符 X,保存其综合属性x的值至专为而声明的变量;然
后调用匹配终结符(match_token)和取下一输入符号(next_token)
的函数;
(2)对非终结符 B,利用相应于 B 的函数调用产生赋值语句
c:=B(b1, b2, …, bk),其中变量 b1, b2, …, bk 对应 B的各继
承属性,变量c对应B的综合属性
(3)对语义规则集,直接copy其中每一语义规则(动作)来产生代
码,只是将对属性的访问替换为对相应变量的访问。
4、文法的属性分析
5、过程设计
int getsym(); ame) == 0){
printf("错误4:变量名重复.\n");
exit(0);
}
}
每次要把一个变量加入到table[tx]数组中都要检验变量名是否跟table[tx]数组中已有的变量名重复,重复就报错,并跳出程序。
这样就在程序中增加了检查重复变量名的功能。
五、结果及分析
1、运行的文件内容为:
real a,b;
int c,d;
c:=c+d*b;
d:=b*a.
运行结果为:
2、运行文件的内容为:
real a,b;
int c,d,a;
c:=c+d*b;
d:=b*a.
运行结果为:
3、运行文件的内容为:
real a,b;
int c,d;
f:=c+d*b;
d:=b*a.
运行的结果为:
从以上三个结果(一个正确,两个错误)来看,完全实现了扩展要求的两个功能,也完全符合定义的语法语义规则。