编译原理实验-递归下降分析资料报告器地设计(含源代码和运行结果)

合集下载

编译原理实验报告——实验二递归下降分析

if(sym=='*') {
printf("T'->*FT'\t"); printf("#E'T'F*\t\t"); print(); } else { printf("T'->/FT'\t"); printf("#E'T'F/\t\t"); print(); }
7
myAdvance(); printf("\t\t"); printf("#E'T'F\t\t"); print(); myF(); } if( sym!='*'||sym!='/') { printf("T'->^\t\t"); printf("#E'\t\t"); print(); } return(1); } else return(0); } /*判断是否是表达式或者括号*/ int myF() { int p; if (sym >= 'A' && sym <= 'Z' || sym >= 'a' && sym <= 'z' ) { printf("F->i\t\t"); printf("#E'T'i\t\t"); print(); myAdvance(); printf("\t\t"); printf("#E'T'\t\t"); print(); return(1); } else{

(完整)编译原理课程设计 LL(1)递归下降分析器

(完整)编译原理课程设计 LL(1)递归下降分析器编辑整理：尊敬的读者朋友们：这里是精品文档编辑中心，本文档内容是由我和我的同事精心编辑整理后发布的，发布之前我们对文中内容进行仔细校对，但是难免会有疏漏的地方，但是任然希望（(完整)编译原理课程设计LL(1)递归下降分析器）的内容能够给您的工作和学习带来便利。

同时也真诚的希望收到您的建议和反馈，这将是我们进步的源泉，前进的动力。

本文可编辑可修改，如果觉得对您有帮助请收藏以便随时查阅，最后祝您生活愉快业绩进步，以下为(完整)编译原理课程设计 LL(1)递归下降分析器的全部内容。

仲恺农业技术学院编译原理课程设计课程设计题目：LL（1）递归下降分析器姓名：院（系）:专业班级：学号 :指导教师：设计日期：目录1、需求分析 (1)2、概要设计 (2)3、详细设计 (3)4、测试分析 (8)5、用户手册 (9)6、课程总结 (9)7、参考文献 (10)题目：LL（1)递归下降分析器1、需求分析语法分析是编译过程的核心部分。

语法分析器的任务是识别和处理比单词更大的语法单位。

如：程序设计语言中的表达式，各种说明和语句乃至全部源程序，指我们知道,语言的语法结构是用上下文无关文法描述的.按照语法分析树的建立方法,我们可以粗略地把语法分析办法分成两类，一类是自上而下分析，另一类是自下而上分析法。

而自上而下这种方法是带“回溯”的，且存在许多困难和缺点.首先，是文法的左递归性问题。

一个文法是含有左递归的,如果存在非终结符P 且,含有左递归的文法使上述的自上而下的分析过程陷入无限循环。

即，当试图用P 去匹配输入串时，我们会发现，在没有识别任何输入符号的情况下，有得重新要求P 去进行新的匹配。

因此，使用自上而下分析法必须消除文法的左递归性.其次，由于回溯,就碰到一大堆麻烦问题。

如果我们走了一大段错路,最后必须回头，那么，就应把已经做的一大堆语义工作（指中间代码产生工作和各种表格的簿记工作）推倒重来.这些事情既麻烦又费时间，所以，最好应设法消除回溯.第三，在自上而下分析过程中，当一个非终结符用某一候选匹配成功时,这种成功可能仅是暂时的。

编译原理_实验二_语法分析_递归下降分析器设计_实验报告

递归下降分析器设计一、实验/实习过程内容：利用JavaCC生成一个MiniC的语法分析器；要求：1. 用流的形式读入要分析的C语言程序，或者通过命令行输入源程序。

2. 具有错误检查的能力，如果有能力可以输出错误所在的行号，并简单提示3. 如果输入的源程序符合MiniC的语法规范，输出该程序的层次结构的语法树具体实施步骤如下：1.把MiniC转换为文法如下<程序〉→ main()〈语句块〉〈语句块〉→{〈语句串〉}〈语句串〉→〈语句〉〈语句串〉|〈语句〉〈语句〉→〈赋值语句〉|〈条件语句〉|〈循环语句〉〈赋值语句〉→ ID =〈表达式〉；〈条件语句〉→ if〈条件〉〈语句块〉〈循环语句〉→ while〈条件〉〈语句块〉〈条件〉→（〈表达式〉〈关系符〉〈表达式〉）〈表达式〉→〈表达式〉〈运算符〉〈表达式〉|（〈表达式〉）|ID|NUM〈运算符〉→+|-|*|/〈关系符〉→＜|＜＝|＞|＞＝|＝＝|!=2.消除语句中的回溯与左递归3．在eclipse环境下完成JavaCC的插件安装后，写一个JavaCC文法规范文件(扩展名为jj)4.完成的功能包括词法分析，语法分析二、代码：options {JDK_VERSION = "1.5";}PARSER_BEGIN(eg1)public class eg1 {public static void main(String args[]) throws ParseException { eg1 parser = new eg1(System.in);parser.start();}}PARSER_END(eg1)SKIP :{" "| "\r"| "\t"| "\n"}TOKEN : /* OPERATORS */{< PLUS: "+" >| < MINUS: "-" >| < MULTIPLY: "*" >| < DIVIDE: "/" >}TOKEN :{<BIGGER:">"> |<SMALLER:"<"> |<NOTVOLUTION:"!="> |<SMALLEREQDD:"<="> |<BIGGEREE:">=" > |<DOUBLE:"==">TOKEN: //关键字{<MAIN:"main"> |<VOID:"void"> |<IF:"if"> |<INT:"int"> | <WHILE:"while"> |<CHAR:"char"> | <VOLUTION:"="> }TOKEN : //定义整型数{< INTEGER: ["0" - "9"]( <DIGIT> )+ >| < #DIGIT: ["0" - "9"] >}TOKEN : //数字{<NUMBER:(<DIGIT>)+ | (<DIGIT>)+"."| (<DIGIT>)+"."(<DIGIT>)+| "."(<DIGIT>)+>}TOKEN : //标记{<COMMA:","> | <SEMICOLON:";"> | <COLON:":"> | <LEFTPARENTHESES:"("> |<RIGHTPARENTHESES:")"> | <LEFTBRACE:"{"> | <RIGHTBRACE:"}"> }TOKEN : //标识符{<IDENTIFIER:<LETTER> |<LETTER>(<LETTER> | <DIGIT> )* >|<#LETTER:["a"-"z", "A"-"Z"]>}void start():{}{<MAIN> <LEFTPARENTHESES> <RIGHTPARENTHESES> block() }void block():{}{<LEFTBRACE> string() <RIGHTBRACE>}void string():{}{yuju() (string())?}void yuju():{}{fuzhiyuju() | tiaojianyuju() | xunhuanyuju()}void fuzhiyuju():{}{<IDENTIFIER> <VOLUTION> biaodashi() <SEMICOLON>}void tiaojianyuju():{}{<IF> tiaojian() block()}void xunhuanyuju():{}<WHILE> tiaojian() block()}void tiaojian():{}{<LEFTPARENTHESES> biaodashi() guanxifu() biaodashi()<RIGHTPARENTHESES>}void biaodashi():{}{( <LEFTPARENTHESES> biaodashi() <RIGHTPARENTHESES> biaodashi2()) |(<IDENTIFIER> biaodashi2() ) | ( <NUMBER> biaodashi2() )}void biaodashi2():{}{(yunsuanfu() biaodashi() biaodashi2() )?}void yunsuanfu():{}{< PLUS > | < MINUS > |< MULTIPLY> | < DIVIDE >}void guanxifu() :{}{<BIGGER> | <SMALLER> | <NOTVOLUTION><SMALLEREQDD> | <BIGGEREE> | <DOUBLE>}三、实验/实习总结本次实习，我使用javacc完成了包括词法分析，语法分析(输出语法树),能够读文件的功能，总的来说比较满意，通过本次实习掌握了javacc基本的使用。

编译原理递归下降预测分析

《编译原理》课程实验报告课程实验题目：作者所在系部：计算机科学与工程系作者所在专业：计算机科学与技术作者所在班级：作者学号：作者姓名：指导教师姓名：一、实验目的通过本实验，了解递归下降预测分析的原理和过程以及可能存在的回溯问题，探讨解决方法，为预测分析表方法的学习奠定基础。

分析递归下降子程序的优缺点。

二、实验内容及要求1．给定文法：S→（T）|a+S|aT→T，S|S改写文法，使其可以使用递归下降子程序方法进行分析，编写递归下降子程序，判断句子：（（（a+a+a），a+a），a）是否符合该文法。

输入：（（（a+a+a），a+a），a）输出：结构正确或结构错误2．编写程序调试运行；考虑如果将你的程序改为识别其他的文法，你的递归下降子程序可否通用，考虑递归下降子程序方法的优缺点。

三、实验程序设计说明1．实验方案设计1．match;函数：从文件中依次读字符2．S函数：判断表达式是否满足S→(T)|aS1。

3．S1函数：判断表达式是否满足S1→(a+)S1|e4．T函数：判断表达式是否满足T→ST15．T1函数：判断表达式是否满足T1→,ST1|e6．error函数：输出错误信息到屏幕2．程序源代码#include<iostream.h>#include<stdlib.h>void match(char t);void S();void S1();void T();void T1();void error();char lookahead;char a[100];int i=0;int j=0;int x=0;void match(char t){if(lookahead==t)lookahead=a[++j];else error();}void S(){if(lookahead=='('){match('(');T();if(lookahead==')')match(')');else error();}else if(lookahead=='a'){match('a');S1();}else error();}void S1(){if(lookahead=='+'){match('+');S();}}void T(){S();T1();}void T1(){if(lookahead==','){match(',');S();T1();}}void error()x=-1;}void main(){cout<<"请输入一个表达式(((a+a+a),a+a),a)（以@结束）:";char c;cin>>c;char s;cin>>s;while(s!='@'){a[i]=s;i++;cin>>s;}lookahead=*a;S();if(x==-1)cout<<"不匹配"<<endl;if(x==0)cout<<"匹配"<<endl;}3．程序的执行结果4．实验程序的优点和特色1.输入是以读文件的方式进行,避免了输入时的繁琐；2.递归下降子程序的健壮性较好，能准确分析出表达式错误的位置等；3.采用C语言极其部分函数编写，易懂。

编译原理实验语法器递归下降子程序实现解析

编译原理程序设计实验报告——表达式语法分析器的设计班级：计算机1306班姓名：张涛学号：20133967 实验目标：用递归下降子程序设计实现表达式语法分析器实验内容：⑴概要设计：通过对实验一的此法分析器的程序稍加改造，使其能够输出正确的表达式的token序列。

然后利用LL（1）分析法实现语法分析。

⑵数据结构：int op=0; //当前判断进度char ch; //当前字符char nowword[10]=""; //当前单词char operate[4]={'+','-','*','/'}; //运算符char bound[2]={'(',')'}; //界符struct Token{int code;char ch[10];}; //Token定义struct Token tokenlist[50]; //Token数组struct Token tokentemp; //临时Token变量⑶流程图：⑷关键函数：int IsLetter(char ch) //判断ch是否为字母int IsDigit(char ch) //判断ch是否为数字int Iskey(char *string) //判断是否为关键字int Isbound(char ch) //判断是否为界符int Isboundnum(char ch) //给出界符所在token值void T(); //分析子程序void F(); //分析子程序void E1(); //分析子程序void E(); //分析子程序void T1(); //分析子程序源程序代码：（加入注释）#include<stdio.h>#include<string.h>#include<ctype.h>#include<windows.h>int op=0; //当前判断进度char ch; //当前字符char nowword[10]=""; //当前单词char operate[4]={'+','-','*','/'};char bound[2]={'(',')'};struct Token{int code;char ch[10];};struct Token tokenlist[50];struct Token tokentemp;void T();void F();void E1();void E();void T1();int IsLetter(char ch) //判断ch是否为字母{int i;for(i=0;i<=45;i++)if ((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z'))return 1;return 0;}int IsDigit(char ch) //判断ch是否为数字{int i;for(i=0;i<=10;i++)if (ch>='0'&&ch<='9')return 1;return 0;}int Isbound(char ch){int i;for(i=0;i<2;i++){if(ch==bound[i]){return i+1;}}return 0;}int Isoperate(char ch){int i;for(i=0;i<4;i++){if(ch==operate[i]){return i+3;}}return 0;}int main(){FILE *fp;int q=0,m=0;char sour[200]=" ";printf("请将源文件置于以下位置并按以下方式命名：F:\\2.txt\n");if((fp=fopen("F:\\2.txt","r"))==NULL){printf("文件未找到！\n");}else{while(!feof(fp)){if(isspace(ch=fgetc(fp)));else{sour[q]=ch;q++;}}}int p=0;printf("输入句子为：\n");for(p;p<=q;p++){printf("%c",sour[p]);}printf("\n");int state=0,nowlen=0;BOOLEAN OK=TRUE,ERR=FALSE;int i,flagpoint=0;for(i=0;i<q;i++){switch(state){case 0:ch=sour[i];if(Isbound(ch)){if(ERR){printf("无法识别\n");ERR=FALSE;OK=TRUE;}else if(!OK){printf("<10,%s>标识符\n",nowword);tokentemp.code=10;tokentemp.ch[10]=nowword[10];tokenlist[m]=tokentemp;m++;OK=TRUE;}state=4;}else if(IsDigit(ch)){if(OK){memset(nowword,0,strlen(nowword));nowlen=0;nowword[nowlen]=ch;nowlen++;state=3;OK=FALSE;break;}else{nowword[nowlen]=ch;nowlen++;}}else if(IsLetter(ch)){if(OK){memset(nowword,0,strlen(nowword));nowlen=0;nowword[nowlen]=ch;nowlen++;OK=FALSE;if(sour[i+1]=='#'){printf("<10,%s>标识符\n",nowword);struct Token tokentemp;tokentemp.code=10;int i=0;for(i;i<=nowlen;i++)tokentemp.ch[i]=nowword[i];tokenlist[m]=tokentemp;}}else{nowword[nowlen]=ch;nowlen++;}}else if(Isoperate(ch)){if(!OK){printf("<10,%s>标识符\n",nowword);tokentemp.code=10;tokentemp.ch[10]=nowword[10];tokenlist[m]=tokentemp;m++;OK=TRUE;}printf("<%d,%c>运算符\n",Isoperate(ch),ch);tokentemp.code=Isoperate(ch);tokentemp.ch[10]=ch;tokenlist[m]=tokentemp;m++;}break;case 3:if(IsLetter(ch)){printf("错误\n");nowword[nowlen]=ch;nowlen++;ERR=FALSE;state=0;break;}if(IsDigit(ch=sour[i])){nowword[nowlen]=ch;nowlen++;}else if(sour[i]=='.'&&flagpoint==0){flagpoint=1;nowword[nowlen]=ch;nowlen++;}else{printf("<20,%s>数字\n",nowword);i--;state=0;OK=TRUE;tokentemp.code=20;tokentemp.ch[10]=nowword[10];tokenlist[m]=tokentemp;m++;}break;case 4:i--;printf("<%d,%c>界符\n",Isbound(ch),ch);tokentemp.code=Isbound(ch);tokentemp.ch[10]=ch;tokenlist[m]=tokentemp;m++;state=0;OK=TRUE;break;}}int io=0;for(io;io<=m;io++){printf("tokenlist%d.code值为%d\n",io,tokenlist[io].code);}E();if(op==m)printf("OK!!!");elseprintf("WRONG!!!");return 0;}void E(){T();E1();}void E1(){if(tokenlist[op].code==3||tokenlist[op].code==4){tokenlist[op++];T();E1();}}void T1(){if(tokenlist[op].code==5||tokenlist[op].code==6){tokenlist[op++];F();T1();}}void T(){F();T1();}void F(){if(tokenlist[op].code==10||tokenlist[op].code==20) {tokenlist[op++];}else{if(tokenlist[op].code==1){tokenlist[op++];E();if(tokenlist[op].code==2){tokenlist[op++];}else{printf("WRONG!!!!!!");//exit(1);}}else{printf("WRONG!!!!!!");//exit(1);}}}程序运行结果：（截屏）输入：((Aa+Bb)*(88.2/3))#注：如需运行请将文件放置F盘，并命名为：2.txt 输出：思考问题回答：在递归下降子程序中要注意对于错误情况的处理，以防程序无限循环，无法结束。

编译原理-实验报告2-递归下降分析法

计算机硬件实验室实验报告一、实验目的：根据某一文法编制调试递归下降分析程序，以便对任意输入的符号串进行分析。

本次实验的目的主要是加深对递归下降分析法的理解。

二、实验要求：对下列文法，用递归下降分析法对任意输入的符号串进行分析：（1）E->TG（2）G->+TG|—TG（3）G->ε（4）T->FS（5）S->*FS|/FS（6）S->ε（7）F->(E)（8）F->i输出的格式如下：(1)递归下降分析程序，编制人：姓名，学号，班级(2)输入一以#结束的符号串(包括+—*/（）i#)：在此位置输入符号串例如：i+i*i#(3)输出结果：i+i*i#为合法符号串备注：输入一符号串如i+i*#,要求输出为“非法的符号串”。

注意：1.表达式中允许使用运算符（+-*/）、分割符（括号）、字符i，结束符#；2.如果遇到错误的表达式，应输出错误提示信息（该信息越详细越好）；三、实验过程：程序设计：1.模块设计：将程序分成合理的多个模块（函数），每个模块做具体的同一事情。

2.写出（画出）设计方案：模块关系简图、流程图、全局变量、函数接口等。

程序编写：1.定义部分：定义常量、变量、数据结构。

2.初始化：从文件将输入符号串输入到字符缓冲区中。

3.利用递归下降分析法，对每个非终结符编写函数，在主函数中调用文法开始符号的函数。

四、实验结果（1）程序流程图（2）运行结果示例程序：#include <>#include<>#include<>#include<>char a[50] ,b[50],d[500],e[10];char ch;int n1,i1=0,flag=1,n=5;int E();int E1();int T();int G();int S();int F();void input();void input1();void output();void main() /*递归分析*/{int f,p,j=0;char x;d[0]='E';d[1]='=';d[2]='>';d[3]='T';d[4]='G';d[5]='#';printf("递归下降分析程序，编制人：武普泉，20号，1020562班\n");printf("输入一以#结束的符号串(包括+ - * / ( ) i #,且长度小于50)：");do{scanf("%c",&ch);a[j]=ch;j++;}while(ch!='#');n1=j;ch=b[0]=a[0];printf("文法\t分析串\t\t\t分析字符\t\t剩余串\n");f=E1();if(f==0) return ;if (ch=='#'){ printf("accept\n");p=0;x=d[p];// {// printf("%c",x);p=p+1;x=d[p]; /*输出推导式*/ // }while(a[p]!='#')printf("%c",a[p++]);printf("为合法字符!\n");}else {// printf("error\n");j=0;while(a[j]!='#')printf("%c",a[j++]);printf("非法字符!\n");printf("回车返回\n");getchar();getchar();return;}printf("\n");printf("回车返回\n");getchar();getchar();}int E1(){ int f,t;printf("E-->TG\t");flag=1;input();input1();f=T();if (f==0) return(0);t=G();if (t==0) return(0);else return(1);}int E(){ int f,t;printf("E-->TG\t");e[0]='E';e[1]='=';e[2]='>';e[3]='T';e[4]='G';e[5]='#';output();flag=1;input();input1();f=T();if (f==0)return(0);t=G();if (t==0) return(0);else return(1);}int T(){ int f,t;printf("T-->FS\t");e[0]='T';e[1]='=';e[2]='>';e[3]='F';e[4]='S';e[5]='#';output();flag=1;input();input1();f=F();if (f==0)return(0);t=S();if (t==0) return(0);else return(1);}int G(){int f;if(ch=='+'){b[i1]=ch;printf("G-->+TG\t");e[0]='G';e[1]='=';e[2]='>';e[3]='+';e[4]='T';e[5]='G';e[6]='#';output();flag=0;input();input1();ch=a[++i1];f=T();if (f==0)return(0);f=G();if(f==0)return 0;else return 1;}else if(ch=='-'){b[i1]=ch;printf("G-->-TG\t");e[0]='G';e[1]='=';e[2]='>';e[3]='-';e[4]='T';e[5]='G';e[6]='#';output();flag=0;input();input1();ch=a[++i1];f=T();if (f==0){// printf("G=%d\n",f);return(0);}f=G();if(f==0)return 0;else return 1;}else{printf("G-->^\t");e[0]='G';e[1]='=';e[2]='>';e[3]='^';e[4]='#';output();flag=1;input();input1();return(1);}}int S(){int f,t;if(ch=='*'){b[i1]=ch;printf("S-->*FS\t");e[0]='S';e[1]='=';e[2]='>';e[3]='*';e[4]='F';e[5]='S';e[6]='#';output();flag=0;input();input1();ch=a[++i1];f=F();if (f==0)return(0);t=S();if (t==0)return(0);else return(1);}else if(ch=='/'){b[i1]=ch;printf("S-->/FS\t");e[0]='S';e[1]='=';e[2]='>';e[3]='/';e[4]='F';e[5]='S';e[6]='#';output();flag=0;input();input1();ch=a[++i1];f=F();if (f==0)return(0);t=S();if (t==0)return(0);else return(1);}else{printf("S-->^\t");e[0]='S';e[1]='=';e[2]='>';e[3]='^';e[4]='#';output();flag=1;a[i1]=ch;input();input1();return(1);}}int F(){ int f;int j;if(ch=='('){b[i1]=ch;printf("F-->(E)\t");e[0]='F';e[1]='=';e[2]='>';e[3]='(';e[4]='E';e[5]=')';e[6]='#';output();flag=0;input();input1();ch=a[++i1];f=E();if (f==0) return(0);if(ch==')'){b[i1]=ch;printf("F-->(E)\t");flag=0;input();input1();ch=a[++i1];}else{printf("error\n");j=0;while(a[j]!='#')printf("%c",a[j++]);printf("非法字符!\n");return(0);}}else if(ch=='i'){b[i1]=ch;printf("F-->i\t");e[0]='F';e[1]='=';e[2]='>';e[3]='i';e[4]='#';output();flag=0;input();input1();ch=a[++i1];}else {printf("error\n");j=0;while(a[j]!='#')printf("%c",a[j++]);printf("非法字符!\n");return(0);}return(1);}void input(){int j=0;for (;j<=i1-flag;j++)printf("%c",b[j]); /*输出分析串*/printf("\t\t\t");printf("%c\t\t\t",ch); /*输出分析字符*/ }void input1(){int j;for (j=i1+1-flag;j<n1;j++)printf("%c",a[j]); /*输出剩余字符*/printf("\n");}void output(){ /*推导式计算*/ int m,k,j,q;int i=0;m=0;k=0;q=0;i=n;d[n]='=';d[n+1]='>';d[n+2]='#';n=n+2;i=n;i=i-2;while(d[i]!='>'&&i!=0) i=i-1;i=i+1;while(d[i]!=e[0]) i=i+1;q=i;m=q;k=q;while(d[m]!='>') m=m-1;m=m+1;while(m!=q) {d[n]=d[m];m=m+1;n=n+1;}d[n]='#';for(j=3;e[j]!='#';j++){d[n]=e[j];n=n+1;}k=k+1;while(d[k]!='=') {d[n]=d[k];n=n+1;k=k+1;}d[n]='#';}。

递归下降分析器的设计

河北大学工商学院编译原理实验报告年级09级学号姓名成绩专业计算机科学与技术实验地点B3-216 指导教师李凯实验项目递归下降分析器的设计实验日期2012/5/14实验报告要求：一、实验目的1. 实验目的使用递归子程序法设计一个语法分析程序，理解自顶向下分析方法的原理，掌握手工编写语法分析程序的方法。

2.了解什么是LL（1）文法的，以及如何把一个非ll(1)的文法转化为非ll(1)型文法，深入了解如何根据ll(1)文法编写递归子程序，实现语法的检查。

3.深入了解编译程序语法分析的过程。

二、实验原理1. 基本原理递归下降法是语法分析中最易懂的一种方法。

它的主要原理是，对每个非终极符按其产生式结构构造相应语法分析子程序，其中终极符产生匹配命令，而非终极符则产生过程调用命令。

因为文法递归相应子程序也递归，所以称这种方法为递归子程序下降法或递归下降法。

其中子程序的结构与产生式结构几乎是一致的。

2. 文法要求递归下降法要满足的条件：假设 A 的全部产生式为A α1|α2|……|αn ，则必须满足如下条件才能保证可以唯一的选择合适的产生式Select(A-> αi)∩select(A ->αj)=Φ,当i≠j，即要求文法必需满足ll(1)文法。

3.开发工具要求本程序使用C语言写的，要求掌握C语言的基本语法和语义，特别是关于程序递归调用的要求。

4.文法的BNF式：E->EaT|T;T->TbF|FF->(E)|da:=+|-b:=*|/消除左递归之后的文法E->TE’E’->aTE’|εT->bFT’|εT’->bFT’F->(E)|da:=+|-b:=*|/三、实验要求【目的】使用递归子程序法设计一个语法分析程序，理解自顶向下分析方法的原理，掌握手工编写语法分析程序的方法。

编译原理语法分析递归下降子程序实验报告

编译原理语法分析递归下降子程序实验报告编译课程设计-递归下降语法分析课程名称编译原理设计题目递归下降语法分析一、设计目的通过设计、编制、调试一个具体的语法分析程序，加深对语法分析原理的理解，加深对语法及语义分析原理的理解，并实现对文法的判断，是算符优先文法的对其进行FirstVT集及LastVT集的分析，并对输入的字符串进行规约输出规约结果成功或失败。

二、设计内容及步骤内容：在C++ 6.0中编写程序代码实现语法分析功能，调试得到相应文法的判断结果：是算符优先或不是。

若是，则输出各非终结符的FirstVT与LastVT集的结果，还可进行字符串的规约，输出详细的规约步骤，程序自动判别规约成功与失败。

步骤:1.看书，找资料，了解语法分析器的工作过程与原理2.分析题目，列出基本的设计思路1定义栈，进栈，出栈函数○2栈为空时的处理○3构造函数判断文法是否是算符文法，算符优先文法○4构造FirstVT和LastVT函数对文法的非终结符进行分析○5是算符优先文法时，构造函数对其可以进行输入待规约○串，输出规约结果○6构造主函数，对过程进行分析3.上机实践编码，将设计的思路转换成C++语言编码，编译运行4.测试，输入不同的文法，观察运行结果详细的算法描述详细设计伪代码如下：首先要声明变量，然后定义各个函数1.void Initstack(charstack &s){//定义栈s.base=new charLode[20];s.top=-1; }2. void push(charstack&s,charLode w){//字符进栈s.top++;s.base[s.top].E=w.E;s.base[s.top].e=w.e;}3. void pop(charstack&s,charLode &w){//字符出栈w.E=s.base[s.top].E; 三、w.e=s.base[s.top].e;s.top--;}4. int IsEmpty(charstack s){//判断栈是否为空if(s.top==-1)return 1;else return 0;}5.int IsLetter(char ch){//判断是否为非终结符if(ch='A'&&ch= 'Z')return 1;else return 0;}6.int judge1(int n){ //judge1是判断是否是算符文法：若产生式中含有两个相继的非终结符则不是算符文法}7. void judge2(int n){//judge2是判断文法G是否为算符优先文法：若不是算符文法或若文法中含空字或终结符的优先级不唯一则不是算符优先文法8.int search1(char r[],int kk,char a){ //search1是查看存放终结符的数组r中是否含有重复的终结符}9.void createF(int n){ //createF函数是用F数组存放每个终结符与非终结符和组合，并且值每队的标志位为0;F数组是一个结构体}10.void search(charLode w){ //search函数是将在F数组中寻找到的终结符与非终结符对的标志位值为1 }分情况讨论：//产生式的后选式的第一个字符就是终结符的情况//产生式的后选式的第一个字符是非终结符的情况11.void LastVT(int n){//求LastVT}12.void FirstVT(int n){//求FirstVT}13.void createYXB(int n){//构造优先表分情况讨论：//优先级等于的情况，用1值表示等于}//优先级小于的情况，用2值表示小于//优先级大于的情况，用3值表示大于}14.int judge3(char s,char a){//judge3是用来返回在归约过程中两个非终结符相比较的值}15.void print(char s[],charSTR[][20],int q,int u,int ii,int k){//打印归约的过程}16. void process(char STR[][20],int ii){//对输入的字符串进行归约的过程}四、设计结果分两大类，四种不同的情况第一类情况：产生式的候选式以终结符开始候选式以终结符开始经过存在递归式的非终结符后再以终结符结束篇二：编译原理递归下降子程序北华航天工业学院《编译原理》课程实验报告课程实验题目：递归下降子程序实验作者所在系部：计算机科学与工程系作者所在专业：计算机科学与技术作者所在班级：xxxx作者学号：xxxxx_作者姓名：xxxx指导教师姓名：xxxxx完成时间：2011年3月28日一、实验目的通过本实验，了解递归下降预测分析的原理和过程以及可能存在的回溯问题，探讨解决方法，为预测分析表方法的学习奠定基础。

编译原理实验递归下降分析器的设计含源代码和运行结果

2求出每个非终结符的ＦIRST集合和ＦOLＬOW集合:
ＦIRＳT(ｅxp)= ＦIRSＴ(tｅrm）= FIRSＴ(facｔor)＝{id， nｕmbｅｒ， ( }
FIＲSＴ(texp)＝｛ ε,+, - ｝
FＩRＳT(Adｄop)={+， - }
ＦIRSＴ（tteｒｍ)={ ε,*， / }
FIＲST（mulop)={*, ／ }
由于分析的文件中可能出现非法字符，而一旦发现非法字符就无需再接着分析，所以在每次读取一个字符时调用ｉsleｇａｌ函数判断是否是合法字符，并返回0或1.
在ｍain()函数中,whiｌe((lookahｅaｄ=='\n'||lｏｏｋahｅad==' ')&&lookaheaｄ!=EOF）ﻩfｓcanf(resｏurｃｅ,"%ｃ",&looｋahead);
void matｃh(cｈarｔ)/／写入rｅsult文件,打印输出，并读取下一个
｛
ｆprｉntｆ(reｓult,＂%c",lｏokahead);//向rｅsuｌt写入
printｆ(＂%ｃ",ｌookaｈeａd);
fscaｎf(resourcｅ,"％c"，&loｏkaheaｄ）;/／读数据
｝
ｎumber()/／识别数字，如果遇到数字就一直接着读直到不是数字
{
whｉle(＇0'＜＝lookaｈead&&ｌoｏkaheaｄ<='９')
ﻩ{
ﻩfprintf（ｒeｓult,"%ｃ",looｋaｈeａd);//写入
prｉntf("%ｃ",loｏkahead);

递归下降程序实验报告

一、实验目的1. 理解递归下降分析法的原理和实现方法。

2. 掌握递归下降分析程序的设计和调试。

3. 加深对编译原理中语法分析部分的理解。

二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019三、实验内容1. 递归下降分析法原理介绍2. 递归下降分析程序的设计与实现3. 递归下降分析程序的调试与测试四、实验步骤1. 递归下降分析法原理介绍递归下降分析法是一种自顶向下的语法分析方法，它将文法中的非终结符对应为分析过程中的递归子程序。

当遇到一个非终结符时，程序将调用对应的递归子程序，直到处理完整个输入串。

2. 递归下降分析程序的设计与实现（1）定义文法以一个简单的算术表达式文法为例，文法如下：E -> E + T| TT -> T F| FF -> ( E )| id（2）消除左递归由于文法中存在左递归，我们需要对其进行消除，消除后的文法如下：E -> T + E'E' -> + T E' | εT -> F T'T' -> F T' | εF -> ( E ) | id（3）设计递归下降分析程序根据消除左递归后的文法，设计递归下降分析程序如下：```cpp#include <iostream>#include <string>using namespace std;// 定义终结符const char PLUS = '+';const char MUL = '';const char LPAREN = '(';const char RPAREN = ')';const char ID = 'i'; // 假设id为'i'// 分析器状态int index = 0;string input;// 非终结符E的分析程序void E() {T();while (input[index] == PLUS) {index++;T();}}// 非终结符T的分析程序void T() {F();while (input[index] == MUL) {index++;F();}}// 非终结符F的分析程序void F() {if (input[index] == LPAREN) {index++; // 跳过左括号E();if (input[index] != RPAREN) {cout << "Error: Missing right parenthesis" << endl; return;}index++; // 跳过右括号} else if (input[index] == ID) {index++; // 跳过标识符} else {cout << "Error: Invalid character" << endl;return;}}// 主函数int main() {cout << "Enter an arithmetic expression: ";cin >> input;index = 0; // 初始化分析器状态E();if (index == input.size()) {cout << "The expression is valid." << endl;} else {cout << "The expression is invalid." << endl;}return 0;}```3. 递归下降分析程序的调试与测试将以上代码编译并运行，输入以下表达式进行测试：```2 +3 (4 - 5) / 6```程序输出结果为：```The expression is valid.```五、实验总结通过本次实验，我们了解了递归下降分析法的原理和实现方法，掌握了递归下降分析程序的设计与调试。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

《编译原理》实验报告实验3 递归下降分析器的设计学号班级计科1001班时间：2012/4/15 地点:文波同组人：无指导教师：朱少林实验目的使用递归子程序法设计一个语法分析程序，理解自顶向下分析方法的原理，掌握手工编写递归下降语法分析程序的方法。

实验容a.运用所学知识，编程实现递归下降语法分析程序。

b.从数据文件中读出符号串，输出表达式并给出其正误评判。

实验数据文件中应该有多个表达式，可能有正确的也应该有错误的表达式；表达式有形式简单的也应该有复杂的。

每个表达式写在一行，以回车结束。

实验环境软件：VC++6.0实验前准备1、方案设计：①准备模拟数据：本实验中使用“work..cpp”②程序思想：为了使用递归向下的分析，为每个非终结符根据其产生式写一个分析程序，由于写入读出的操作频繁。

所以程序中还有一个match(char t)函数，该函数是将字符写入文件打印输出同时从文件中读取下一个字符，而由于id和number可能是多个字符构成，故写了number()和id（）来分析数字和标识符，它们的功能仅仅是把整个number或id完整的读取出来并写入文件，打印输出。

由于分析的文件中可能出现非法字符，而一旦发现非法字符就无需再接着分析，所以在每次读取一个字符时调用islegal函数判断是否是合法字符，并返回0或1.在main()函数中，while((lookahead=='\n'||lookahead==' ')&&lookahead!=EOF)fscanf(resource,"%c",&lookahead);是为了忽略分析文件中的换行或空格，之后进入分析阶段，根据返回值判断是否是合法的表达式。

在该程序中只有发现了非法字符才会返回0，否则就返回1，而对于合法的表达式，递归程序最后分析的字符就是换行符，不合法的表达式在未分析到换行符就会停止分析，所以根据最后分析的字符是否为换行符进一步确定是否为合法的表达式。

实验步骤首先将上述文法改写成LL（1）文法①消除左递归：exp →term texptexp →addop term texp | εAddop →+ | -term→factor ttermtterm →mulop factor tterm|εmulop →* | /factor →(exp) | id | number②求出每个非终结符的FIRST集合和FOLLOW集合：FIRST(exp)= FIRST(term)= FIRST(factor)={id, number, ( }FIRST(texp)={ ε,+, - }FIRST(Addop)={+, - }FIRST(tterm)={ ε,*, / }FIRST(mulop)={*, / }求出每个非终结符的FOLLOW集合：FOLLOW(exp)=FOLLOW(texp)={#, ）}FOLLOW(Addop)=FOLLOW(mulop)={id, number, ( }FOLLOW(term)=FOLLOW(tterm)={+, -,#, ) }FOLLOW(factor)={ *,/,+,-,#,) }对于texp →addop term texp | ε：FIRST（Addop term texp）∩FOLLOW(texp)= φ；对于tterm →mulop factor tterm|ε：FIRST(mulop factor tterm)∩FOLLOW(tterm)= φ；而Addop →+ | - mulop →* | / factor →(exp) | id | number 显然也是符合LL（1）文法要求的，所以改写后的文法符合LL（1）文法，可以用自上而下的递归分析方法。

③为每个非终结符根据其产生式写一个分析子程序；④编写数字和字母识别程序，以便分离数字和标识符。

；⑤主函数调用递归程序进行分析，根据分析结果判断是否是合法表达式，并将所有识别到的表达式输出。

程序设计：#include <stdio.h>#include <string.h>number();id();int exp();int texp();int addop();int term();int tterm();int mulop();int factor();int islegal();void match(char t); FILE *resource;//测试文件FILE *result;//结果文件char lookahead;//全局变量void match(char t)//写入result文件,打印输出，并读取下一个{fprintf(result,"%c",lookahead);//向result写入printf("%c",lookahead);fscanf(resource,"%c",&lookahead);//读数据}number()//识别数字，如果遇到数字就一直接着读直到不是数字{while('0'<=lookahead&&lookahead<='9'){fprintf(result,"%c",lookahead);//写入printf("%c",lookahead);fscanf(resource,"%c",&lookahead);//读出}}id(){//识别标识符while((lookahead<='z'&& lookahead>='a')||(lookahead>='A'&& lookahead<='Z')||lookahead=='_'){while((lookahead<='z'&& lookahead>='a')||(lookahead>='A'&& lookahead<='Z')||lookahead=='_'||lookahead>='0'&&lookahead<='9'){fprintf(result,"%c",lookahead);//写入printf("%c",lookahead);fscanf(resource,"%c",&lookahead);//读}}}int addop()//Addop →+ | -{//分析+，-int i;if(lookahead=='+')//+{match('+');i=islegal();//判断下一个是否是合法字符，如果不是则返回0if(i)return 1;elsereturn 0;}else if(lookahead=='-')//-{match('-');i=islegal();if(i)return 1;elsereturn 0;}elsereturn 0;}int mulop()//mulop →* | / {//分析*，/int i;if(lookahead=='*'){match('*');i=islegal();if(i)return 1;elsereturn 0;}else if(lookahead=='/'){match('/');i=islegal();if(i)return 1;elsereturn 0;}elsereturn 0;}int exp()//exp →term texp{int i,j;while(!feof(resource)){if(lookahead=='('||'0'<=lookahead&&lookahead<='9'||(lookahead<='z'&& lookahead>='a')||(lookahead>='A'&& lookahead<='Z')||lookahead=='_')//FIRST(term)={id, number, ( }{i=term();if(i){j=texp();if(j){return 1;//当且仅当term和texp都返回1时才返回1 }else{return 0;}}else{return 0;}}else{return 0;;}}}int factor()//factor →(exp) | id | number{int i,m,n;if(lookahead=='('){match('(');i=exp();//返回1则继续分析if(lookahead==')'&&i){match(')');return 1;}elsereturn 0;}else if((lookahead<='z'&& lookahead>='a')||(lookahead>='A'&& lookahead<='Z')||lookahead=='_'){id();n=islegal();//判断读出的是否合法，不合法则不必接着分析if(n)return 1;elsereturn 0;}//id分析中自会匹配else if('0'<=lookahead&&lookahead<='9'){number();m=islegal();//判断读出的是否合法，不合法则不必接着分析if(m)return 1;elsereturn 0;}elsereturn 0;}int tterm()//tterm →mulop factor tterm|ε{//mulop,factor都为空或mulop,factor都为真则返回1int i,j,k;i=mulop();j=factor();if(i&&j){k=tterm();//调用自己继续分析直至mulop,factor都为空或仅其中之一返回真值，此时推出该函数return 1;}else if(!i&&!j) //mulop,factor都为空{return 1;}elsereturn 0;}int term()//term→factor tterm {//factor,tterm都为真则返回1 int i,j;i=factor();if(i){j=tterm();if(j)return 1;elsereturn 0;}elsereturn 0;}int texp()//texp →addop term texp | ε{//addop,term为空或addop，term为真int i,j,k;i=addop();j=term();if(i&&j){k=texp();//调用自己继续分析直至addop,term都为空或仅其中之一返回真值，此时推出该函数return 1;}else if(!i&&!j){return 1;//没必要继续向下分析，否则死循环}elsereturn 0;}int islegal()//当为'(',')','+','-','*','/',换行，字母，数字，下划线才合法{if(lookahead=='('||(lookahead<='9'&&lookahead>='0')||lookahead==')'||looka head=='/'||lookahead=='*'||lookahead=='+'||lookahead=='-'||(lookahead<='z'&& lookahead>='a')||(lookahead>='A'&& lookahead<='Z')||lookahead=='_'||lookahead=='\n'){return 1;}elsereturn 0;}void main(){int i;resource=fopen("work.cpp","r");if(resource==NULL){printf("fail to open!");}result=fopen("结果.txt","w");fscanf(resource,"%c",&lookahead);//读一个字符while(lookahead!=EOF){while((lookahead=='\n'||lookahead==' ')&&lookahead!=EOF)//空格或换行则接着读fscanf(resource,"%c",&lookahead);if(lookahead!=EOF){i=exp();//判断}if(i) //返回1{if(lookahead!='\n') //若没有分析到换行，则说明表达式不正确{while(lookahead!='\n')//打印该行{fprintf(result,"%c",lookahead);printf("%c",lookahead);fscanf(resource,"%c",&lookahead);}fprintf(result," error!\n");printf(" error!\n");}else //表达式分析到换行符正确{fprintf(result," right!\n");printf(" right!\n");}}else //返回0{while(lookahead!='\n')//打印该行{fprintf(result,"%c",lookahead);printf("%c",lookahead);fscanf(resource,"%c",&lookahead);}fprintf(result," error!\n");printf(" error!\n");}fscanf(resource,"%c",&lookahead); //读取下一个字符}fclose( result);fclose( resource);}实验结果及其分析：结果：被分析的文件work.cpp#include "stdio.h"#include "string.h"#include<stdio.h>main(){int i;3+466/9e/i&&;(666+op)*y;(p+8+9+i)*lprintf("%c",&i)((y+i)+p)*8i=1fgetc(fp)6+re==1y-6_a1}输出到“结果.txt”中的容：#include "stdio.h" error! #include "string.h" error! #include<stdio.h> error! main() error!{ error!int i; error!3+4 right!66/9 right!e/i right!&&; error!(666+op)*y; error!(p+8+9+i)*l right!printf("%c",&i) error! ((y+i)+p)*8 right!i=1 error!fgetc(fp) error!. .6+re==1 error!y-6 right!_a1 right!} error!分析：这个实验是每行一个表达式，且每行以换行符终结，故需要按行分析并打印输出，且对于每个非终结符的子程序要有返回值以便确定是否继续向下分析。