您的位置：360文档中心› 编译原理实验报告算术表达式递归下降分析程序设计

编译原理实验报告算术表达式递归下降分析程序设计

合集下载

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

编译原理实验报告——实验二 递归下降分析
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{

编译原理实验报告算术表达式递归下降分析程序设计

编译原理实验报告算术表达式递归下降分析程序设计

武汉工程大学计算机科学与工程学院《编译原理》实验报告一、实验目的（1）掌握自上而下语法分析的要求与特点。

（2）掌握递归下降语法分析的基本原理和方法。

（3）掌握相应数据结构的设计方法。

二、实验内容编程实现给定算术表达式的递归下降分析器。

算术表达式文法如下： E E+T | TT T*F | FF(E) | i设计说明：首先改写文法为LL(1)文法；然后为每一个非终结符，构造相应的递归函数，函数的名字表示规则左部的非终结符；函数体按规则右部符号串的顺序编写。

三、设计分析（1）消去该文法左递归，得到文法：E TE1E1+TE1|εT FT1T1*FT1|εF(E)| I（2）根据LL（1）文法的判断条件，计算这个文法的每个非终结符的FIRST 集和FOLLOW集，经验证，改后的文法已经是LL（1）文法。

（3）最后构造递归下降分析程序，每个函数名是相应的非终结符，函数体则是根据右部符号串的结构编写。

a.当遇到非终结符时，如：+。

则编写语句 if(当读来的输入符号 == +) 读下一个输入符号b.当遇到非终结符时，例如：T。

则编写语句调用T()。

c.当遇到非终结符ε规则时，例如：Tε。

则编写语句 if(当前读来的输入字符不属于FOLLOW(T)) error()d.当某个非终结符的规则有很多个候选式时。

按LL(1)文法的条件能唯一的选择一个候选式进行推导。

（4）递归下降分析法是确定的自上而下分析法，基本思想是，对文法中的每个非终结符编写一个函数，每个函数的功能是识别由该非终结符所表示的语法成分。

因此需要分别构造E,E1,T,T1,F函数来执行自己的识别功能，根据文法的内容顺序决定函数的识别功能。

Scaner函数用于字符串的推进，input函数用于字符串的输入。

四、程序代码#include <>#include <>#include <iostream>using namespace std;char a[80];char sym;int i=0;void E();void E1();void T();elseError();}else if (sym =='i')Scaner();elseError();}五、测试用例1.输入的字符串只含有一个字符时：输入 i#a#2．输入的字符串含有 + 时：输入 ++#输入 i++#输入 i+i#3．输入的字符串含有 * 时：输入 **#输入 **i#输入 *i*#输入 i*i#i*i*#3．输入的字符串含有（）时：输入（）#（i）#4．输入的字符串含有多种字符：输入i+i*i#(i+i)*i#(i+i)*(i+i)#(i+*#。

实验二 递归下降分析法的实现

实验二 递归下降分析法的实现

实验二递归下降分析法的实现一、实验目的实现一个递归下降语法分析程序，识别用户输入的算术表达式。

二、实验主要内容1、文法如下：E→TE`E’→+TE’|-TE’|εT→FT`T’→*FT’|/FT’|εF→(E)|i2、求取各非终结符的First及Follow集合3、编程实现下降递归分析法，识别从键盘输入的关于整数或浮点数的算术表达式（在此，上述文法中的i代表整数或浮点数）4、对于语法错误，要指出错误具体信息。

5、运行实例如下：三、提示1、纸质实验报告内容：实验内容、非终结符的First及Follow集合、正确表达式与错误表达式各举一例进行测试并给出结果、核心源代码。

2、将本次实验代码（.c、.cpp、.java等代码文件，删除编译产生的所有其他文件，不要打包）在规定时间内以作业附件（不可在线编辑、粘贴代码）的形式提交至网站，自己保存以备课程设计（本部有毕业设计要求的学生）参考。

3、纸质实验报告提交时间：临时要求。

实验指导（参考）一、实验步骤1、求取各非终结符的First及Follow集合；2、设计几个函数E(); Ep(); T(); Tp(); F();运用First集合进行递归函数选择，运用Follow集合进行出错情况判断；3、设计主函数：从键盘接受一个算术表达式串；在串尾添加尾部标志’#’；调用函数E()进行递归下降分析。

二、如何识别整数与浮点数在函数F()中要涉及到如何识别整数与浮点数。

识别的方法是：只要碰到‘0’～‘9’之间的字符就一直循环，循环到不是数字字符与小数点字符’.’为止，其间要运用一个标志变量来保证最多只能出现一个小数点，否则应该报错。

上述循环结束即表示识别了一个数，也即表达式文法中的i。

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

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

递归下降分析器设计一、实验/实习过程内容：利用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基本的使用。

编译原理用递归下降法进行表达式分析实验报告

编译原理用递归下降法进行表达式分析实验报告

《编译原理》课程实验报告题目用递归下降法进行表达式分析专业班级学号姓名一.实验题目用递归下降法进行语法分析的方法二.实验日期三.实验环境（操作系统，开发语言）操作系统是Windows开发语言是C语言四.实验内容（实验要求）词法分析程序和语法分析程序已经提供。

此语法分析程序能够实现：正确的输入可以给出结果。

例：输入表达式串为：（13+4）*3则应给出结果为51。

要求：（1）读懂源代码，理解内容写入实验报告（语法分析及语法分析程序和词法分析程序的接口）（2）把语法分析中使用的yyval，用yytext实现。

（3）在语法分析程序用加入出错处理（尽量完整，包括出错的位置，出错的原因，错误的重定位）五.实验步骤1.生成lex.yy.c文件：将已给的mylexer.l文件打开，先理解，然后再在DOS环境下用flex运行此文件，这时会生成一个lex.yy.c文件。

2.创建工程：打开C-Free 5.0(注：用C-Free 4.0会出错)，在菜单栏中的“工程（project）”菜单下选择“新建”；在新建工程中选择“控制台程序”，添加工程名字为“myleb”和保存位置后点“确定”；第1步选择“空的程序”点“下一步”；第2步再点“下一步”；最后点击“完成”。

3.在创建的工程中添加文件：在Source files文件夹中添加之前生成的lex.yy.c文件和syn.c文件，然后找到parser.h文件，将其添加到新建工程中的Header files文件夹中，这时就能将三个文件组成一个类似于.exe文件类型的文件，最后运行。

如图：4.理解并修改syn.c文件：首先，将num = yyval.intval修改成num = atoi(yytext)；将num = yyval.fval修改成num = atof(yytext)。

可以这样修改的原因：在.l文件中所写的规则中，有{DIGIT}+ { yyval.intval = atoi(yytext);return INTEGER; }和{DIGIT}+"."{DIGIT}* {yyval.fval = atof(yytext); return DOUBLE; } 这两句代码，其中yyval.intval = atoi(yytext)和yyval.fval = atof(yytext)就说明两者可以相互替代。

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

编译原理-实验报告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]='#';}。

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

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

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

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

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

步骤:1.看书，找资料，了解语法分析器的工作过程与原理2.分析题目，列出基本的设计思路1定义栈，进栈，出栈函数○2栈为空时的处理○3构造函数判断文法是否是算符文法，算符优先文法○4构造FirstVT和LastVT函数对文法的非终结符进行分析○5是算符优先文法时，构造函数对其可以进行输入待规约○串，输出规约结果○6构造主函数，对过程进行分析3.上机实践编码，将设计的思路转换成C++语言编码，编译运行4.测试，输入不同的文法，观察运行结果详细的算法描述详细设计伪代码如下：首先要声明变量，然后定义各个函数1.void Initstack(charstack &amp;s){//定义栈s.base=new charLode[20];s.top=-1; }2. void push(charstack&amp;s,charLode w){//字符进栈s.top++;s.base[s.top].E=w.E;s.base[s.top].e=w.e;}3. void pop(charstack&amp;s,charLode &amp;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=&#39;A&#39;&amp;&amp;ch= &#39;Z&#39;)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_____ 姓名_71李飞强77欧艺欣81吴文浩89张泰鑫__ 组别:第四组实验日期：2014年 3 月26 日报告退发(订正、重做)课程编译原理实验名称递归下降的预测分析一、实验目的1. 学会用语法图来形式化地描述一门简单的语言；2. 掌握递归下降的预测分析；3. 掌握词法分析。

二、实验环境Visual Studio 或 GCC 或Eclipse三、实验内容、步骤和结果分析实验内容：请基于递归下降的分析方法(教材P55页)，编写一个“语法图.doc”所对应语言的语法分析器。

该语法分析器能读入一个源代码文件（如“test.c”文件所示），并判断其中的源代码是否符合“语法图.doc”的规定。

如果符合，打印出Yes；如果不符合，打印出No。

（所用编程语言不限）C语言版:#include<stdio.h>#include<string.h>#include<stdlib.h>#define MaxIdLen 20 //标志符的最大长度#define KeyWordsCount 5 //该语言拥有的关键字个数#define BoolValueCount 2 //bool类型可能取值的个数#define SymTypeCount 17 //symType个数enum SymType//枚举{OR , //或AND, //与LP, //左括号RP, //右括号ID, //标志符ASSIGN, //赋值LB, //左大括号RB, //右大括号COMMA, //逗号SEMICOLON, //分号UNDEFINED, //未定义BOOLVALUE, //bool类型的值IF, //ifELSE, //elseWHILE, //whilePRINTF, //printfBOOL, //bool};enum boolValue{TRUE，FALSE,};//关键字static char * keywords[KeyWordsCount] = { "if","else","while","printf","bool",};//关键字对应类别static int keyType[KeyWordsCount] = { IF,ELSE,WHILE,PRINTF,BOOL,};static char * boolvalue[BoolValueCount]={"true","false"，};static int boolValueType[BoolValueCount]={TRUE,FALSE,};char ch=' '; //当前字符char id[MaxIdLen+1]; //当前符号串int token; //当前记号(的类型)int value; //当前记号的值FILE * fp; //用来打开要识别的源代码文件int lineNum=1; //要识别的代码行数bool isPass = false ; //判断识别的代码是否全部合法void getToken();void program();void program();void statement();void definition();void term();void factor();void expression();void match(int t);void main(){fopen_s(&fp,"D:\\test.c","r");getToken();program();if(isPass)printf("Y\n");else printf("N\n");fclose(fp);}/****************************************lexical*****************************************/int getKeyWord(char * str){for(int i=0;i<KeyWordsCount;i++)if(strcmp(str,keywords[i])==0)return keyType[i];return UNDEFINED;}int getBoolValue(char* str){for(int i=0;i<BoolValueCount;i++)if(strcmp(str,boolvalue[i])==0){value = boolValueType[i];return BOOLVALUE;}return UNDEFINED;}bool isLetter(char ch){return (ch>='A'&&ch<='Z')||(ch>='a'&&ch<='z'); }bool isDigit(char ch){return ch>='0'&&ch<='9';}void nextChar(){ch = fgetc(fp);}void getToken(){while(ch==' '||ch=='\t'||ch=='\r'||ch=='\n'){if(ch == '\n')lineNum++;nextChar();}if(isLetter(ch)){int index=0;id[index++] = ch;nextChar();while(isLetter(ch) || isDigit(ch)){if(index<MaxIdLen){id[index++] = ch;nextChar();}else{//cout<<"identifier is too long."<<endl;//exit(1);}}id[index]='\0';token = getKeyWord(id);if(token == UNDEFINED)token = getBoolValue(id);if(token == UNDEFINED){token = ID;}}else if(ch == '='){token = ASSIGN;nextChar();}else if(ch=='|'){nextChar();if(ch=='|'){token=OR;nextChar();}elseexit(1);}else if(ch=='&'){nextChar();if(ch=='&'){token=AND;nextChar();}elseexit(1);}else if(ch == ';'){token = SEMICOLON;nextChar();}else if(ch == '('){token = LP;nextChar();}else if(ch == ')'){token = RP;nextChar();}else if(ch == ','){token = COMMA;nextChar();}else if(ch == '{'){token = LB;nextChar();}else if(ch == '}'){token = RB;nextChar();}else if(ch == EOF){printf(" EOF!\n");isPass = true;}else{printf("第%d行不能识别的符号！\n",lineNum );exit(1);}}/****************************************grammar*****************************************/void match(int t){if(t == token){getToken();}else{printf("大概在第%d行错误\n",lineNum);exit(1);}}void expression(){term();while(token == OR){match(OR);term();}}void factor(){if(token == BOOLVALUE && value == TRUE)match(BOOLVALUE);else if(token == BOOLVALUE && value == FALSE) match(BOOLVALUE);else if(token == LP){match(LP);expression();match(RP);}else if(token == ID)match(ID);}void term(){factor();while(token == AND){match(AND);factor();}}void definition(){do{match(BOOL);match(ID);match(ASSIGN);expression();match(SEMICOLON);}while(token == BOOL);}void statement(){if(token == IF){match(IF);match(LP);expression();match(RP);statement();if(token == ELSE){match(ELSE);statement();}}else if(token == PRINTF){match(PRINTF);match(LP);expression();while(token == COMMA){match(COMMA);expression();}match(RP);match(SEMICOLON);}else if(token == WHILE){match(WHILE);match(LP);expression();match(RP);statement();}else if(token == LB){match(LB);do{statement();}while(token != RB);match(RB);}else if(token == ID){match(ID);match(ASSIGN);expression();match(SEMICOLON);}else if(token == SEMICOLON){match(SEMICOLON);}}void program(){definition();statement();}Java版:(吴文浩)Java版的关键代码：// 由语法分析带动翻译public void parse(String src) {this.lexer = new GrammarLexer(src);lookahead = lexer.getToken();program();}private void match(TokenType type) {// 如果记号lookahead的类型是type，则取下一个记号System.out.println("------------>" + type);if (lookahead.tokenType.equals(type)) {lookahead = lexer.getToken();} else {error("NO");// 否则报错}}private void error(String str) {// out.println(str);System.out.println(str);System.exit(-1);}/*** program:程序 definition----->statement-------->*/public void program() {definition();//定义statement();// 声明}// definition:定义/*** bool-->id-->=-->expression-->;*/public void definition() {do {match(TokenType.BOOLEAN);match(TokenType.ID);match(TokenType.EQUAL);expression();match(TokenType.SEMICOLON);// 匹配分号} while (lookahead.isBoolean());}// statement:声明public void statement() {if(lookahead.isIf()) {// -->if-->(-->expression-->)-->statement--->match(TokenType.IF);match(TokenType.LeftP);expression();match(TokenType.RightP);statement();if(lookahead.isElse()) {//缺陷：如果用全部代码测试时，程序走到这里停止了，while循环后的语句将不能执行！match(TokenType.ELSE);statement();} else {}} else if (lookahead.isWhile()) {match(TokenType.WHILE);match(TokenType.LeftP);expression();match(TokenType.RightP);statement();} else if (lookahead.isPrint()) {match(TokenType.PRINT);match(TokenType.LeftP);expression();while (lookahead.isComma()) {match(MA);expression();}match(TokenType.RightP);match(TokenType.SEMICOLON);} else if (lookahead.isSemicolon()) {// ;match(TokenType.SEMICOLON);} else if (lookahead.isLeftBrace()) {match(TokenType.LeftBrace);statement();while(!lookahead.isRightBrace() || lookahead.isId() ){//必须加入lookahead.isId()否则a = false;运行不出来（语法图缺陷吧！）statement();}match(TokenType.RightBrace);} else if (lookahead.isId()) {// id = expression;// System.out.println("++++++++++++++++++++");match(TokenType.ID);match(TokenType.EQUAL);expression();match(TokenType.SEMICOLON);} else {}}/***expression:式子-------->term()----(---->||------->term()---->);*/private void expression() {term();while (lookahead.isOr()) {// 如果是||就继续循环处理match(TokenType.OR);term();}}/***term:项 Factor(); While(match(‘&&’)){ Factor(); }*/private void term() {factor();while (lookahead.isAnd()) {// 判断是&&就继续进行match(TokenType.AND);factor();}}/*** --->(------>expression--------->)--------->* ---->true---->* ---->false---->* ---->id------>*/private void factor() {if (lookahead.isTrue()) {match(TokenType.TRUE);} else if (lookahead.isLeftP()) {match(TokenType.LeftP);expression();match(TokenType.RightP);} else if (lookahead.isFalse()) {match(TokenType.FALSE);} else if (lookahead.isId()) {match(TokenType.ID);} else{}}/*** 获取下一个Token*/public Token getToken() {int value = 0;char cur;while (true) {if (index >= src.length())return Token.EOF;else {// 取下一字符cur = next();// 如果下一个字符是空白，继续读取字符if (this.isBlank(cur))continue;else if (this.isAlpha(cur)) {// 字符缓冲区StringBuilder buffer = new StringBuilder();buffer.append(cur);while (isAlpha((char) peek())) {buffer.append(next());}if(buffer.toString().equals(KeyWord.BOOLEAN)) {return new Token(TokenType.BOOLEAN, buffer.toString());} else if (buffer.toString().equals(KeyWord.FALSE)) {return new Token(TokenType.FALSE, buffer.toString());} else if (buffer.toString().equals(KeyWord.TRUE)) {return new Token(TokenType.TRUE, buffer.toString());} else if(buffer.toString().equals(KeyWord.IF)) {return new Token(TokenType.IF, buffer.toString());} else if (buffer.toString().equals(KeyWord.WHILE)) {return new Token(TokenType.WHILE, buffer.toString());} else if (buffer.toString().equals(KeyWord.PRINT)) {return new Token(TokenType.PRINT, buffer.toString());} else {return new Token(TokenType.ID, buffer.toString());}} else if (cur == ',') {return MA;} else if (cur == '(') {return Token.LeftP;} else if (cur == ')') {return Token.RightP;} else if (cur == '|' && next() == '|') {return Token.OR;// 或者} else if (cur == '&' && next() == '&') {return Token.AND;// 且} else if (cur == '=') {return Token.EQUAL;} else if (cur == ';') {return Token.SEMICOLON;// 分号} else if (cur == '{') {// 左大括号return Token.LeftBrace;} else if (cur == '}') {return Token.RightBrace;} else if (cur == '\n') {line++;} else {this.error();}}}}运行这个测试代码的截图：String src = "boolean a = true;boolean b = false;boolean c = (a && b);if( a || b) print(a,b);else print(c);";运行这个测试代码的截图：String src = "boolean a = true; while(a && (b||c)){print(a,b,c);a = false;}";四、讨论（说明实验过程中遇到的问题及解决办法；未解决/需进一步研讨的问题或建议新实验方法等）在text.c中先是声明bool类型，然后是if语句，最后是while语句。

编译原理之递归下降语法分析程序（实验）

编译原理之递归下降语法分析程序（实验）

编译原理之递归下降语法分析程序（实验）⼀、实验⽬的利⽤C语⾔编制递归下降分析程序,并对简单语⾔进⾏语法分析。

编制⼀个递归下降分析程序,实现对词法分析程序所提供的单词序列的语法检查和结构分析。

⼆、实验原理每个⾮终结符都对应⼀个⼦程序。

该⼦程序根据下⼀个输⼊符号(SELECT集)来确定按照哪⼀个产⽣式进⾏处理，再根据该产⽣式的右端:每遇到⼀个终结符，则判断当前读⼊的单词是否与该终结符相匹配，若匹配，再读取下⼀个单词继续分析；不匹配，则进⾏出错处理每遇到⼀个⾮终结符，则调⽤相应的⼦程序三、实验要求说明输⼊单词串，以“＃”结束，如果是⽂法正确的句⼦，则输出成功信息，打印“success”,否则输出“error”，并指出语法错误的类型及位置。

例如：输⼊begin a:=9;b:=2;c:=a+b;b:=a+c end #输出success输⼊a:=9;b:=2;c:=a+b;b:=a+c end #输出‘end' error四、实验步骤1．待分析的语⾔的语法（参考P90）2．将其改为⽂法表⽰，⾄少包含–语句–条件–表达式E -> E+T | TT -> T*F | FF -> (E) | i3. 消除其左递归E -> TE'E' -> +TE' | εT -> FT'T' -> *FT' | εF -> (E) | i4. 提取公共左因⼦5. SELECT集计算SELECT(E->TE) =FIRST(TE')=FIRSI(T)-FIRST(F)U{*}={(, i, *}SELECT(E'->+TE')=FIRST(+TE')={+}SELECT(E'->ε)=follow(E')=follow(E)={#, )}SELECT(T -> FT')=FRIST(FT')=FIRST(F)={(, i}SELECT(T'->*FT')=FRIST(*FT')={*}SELECT(T'->ε)=follow(T')=follow(T)={#, ), +}SELECT(F->(E))=FRIST((E)) ={(}SELECT(F->i)=FRIST(i) ={i}6. LL(1)⽂法判断 其中SELECT(E'->+TE')与SELECT(E'->ε)互不相交，SELECT(T'->*FT')与SELECT(T'->ε)互不相交，SELECT(F->(E))与SELECT(F->i)互不相交，故原⽂法为LL（1）⽂法。

递归下降程序实验报告

递归下降程序实验报告

一、实验目的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)

编译原理实验报告二递归下降语法分析程序 (1)

编译原理实验报告实验名称：编写递归下降语法分析程序实验类型：验证型实验指导教师：专业班级：姓名：学号：电子邮件：实验地点：实验成绩：日期：201 年 5 月 25 日一、实验目的通过设计、调试递归下降语法分析程序，实现用词法分析从源程序中分出各种单词并对词法分析程序提供的单词序列进行语法检查和结构分析，熟悉并掌握常用的语法分析方法。

明确语法分析器的功能，在词法分析的基础上进一步分析程序；加深对课堂教学的理解；提高语法分析方法的实践能力；通过本实验，应达到以下目标：1、掌握递归下降的结构模型。

2、掌握语法分析的实现方法。

3、上机调试编出的语法分析程序。

二、实验过程有了第一次的经验，这次还是先画出流程图。

流程图如下：三、实验结果语法分析实验成功。

赋值时少写数字：缺少括号时：附（txt文档内容）：程序运行后写入的：四、讨论与分析这个程序是在实验一的基础上写的，用的递归下降的方法。

不止能识别，还能判断一些语法的正误。

刚看书上附录的代码时，头都大了，觉得自己完成不了。

但是真正一步一步看下去，画出了流程图，就很清晰明白了。

一个函数嵌套一个函数，一步一步往细处走，刚开始是大体轮廓，然后就深入，直到最低层的判断。

书上的程序还是有一些漏洞，比如要写多个语句时，if，for，while在语句内不能加括号，不然只能分析至第一个，遇到“｝”就结束了，所以在txt文件里写程序代码的时候要注意不能加｛｝，这样才可以全部printf出来。

五、附录：关键代码（给出适当注释，可读性高）全部代码附vc++，这里粘贴主程序，以及各类函数。

int TESTparse();int TESTscan();int program();int compound_stat();int statement();int expression_stat();int expression();int bool_expr();int additive_expr();int term();int factor();int if_stat();int while_stat();int for_stat();int write_stat();int read_stat();int declaration_stat();int declaration_list();int statement_list();int compound_stat();#include<stdio.h>#include<ctype.h>int TESTscan();int TESTparse();FILE *fin,*fout；void main(){int es=0;es=TESTscan();if(es>0)printf("词法分析有错！编译停止！\n");else{printf("词法分析成功！\n");}if(es==0){es=TESTparse();if(es==0)printf("语法分析成功！\n");elseprintf("语法分析错误！\n");}}六、实验者自评这个实验比第一个有难度，是在第一个完成的基础上进行的。

编译原理实验(递归向下语法分析法实验)

编译原理实验(递归向下语法分析法实验)

//定义一个数组大小常量
char string[N];
//定义一个用于存储算式字符串的数组
char *p;
//定义一个全局字符指针变量
函数说明：
1） 非终结符函数 E()
函数功能描述：根据以上文法要求 E->TG,所以从主函数开始调入第一个非终结符函数
执行，显示调用产生式，依次嵌套调用非终结符函数 T（）和 G（），进行递归向下分析。
void E(){printf("E--->TG..............%c\n",ch);
T();
G();}
2） 非终结符函数 T()
函数功能描述：根据以上文法要求 T->FS,首先显示算式匹配所用的显示调用的产生式，
依次嵌套调用非终结符函数 F（）和 S（），进行递归向下分析。
void T(){
（3）G->ε
（4）T->FS
（5）S->*FS| / FS
（6）S->ε
（7）F->(E)
（8）F->i
输入出的格式如下：
(1)E 盘建立一个文本文档" 222.txt"存储一个以#结束的符号串(包括+—*/（）i#)，在此
位置输入符号串例如：i+i*i#
(2)输出结果：i+i*i#为合法符号串
备注：输入一符号串如 i+i*#,要求输出为“非法的符号串”
此法分析，通过实验我对本章的语法分析也有了深刻的认识。同时通过本次编程，让我深刻
认识编程应该注重细节，编程之前首先要做好分析准备。
五、程序源代码
#include<stdio.h>
#include<stdlib.h>

编译原理实验报告3

编译原理实验报告3

编译原理实验报告3编译原理实验报告——表达式语法分析——表达式语法分析表达式语法分析实验报告一、实验题目设计一个简单的表达式语法分析器（采用递归下降方法设计实现）二、实验目的1、了解形式语言基础及其文法运算；2、熟悉语法分析原理及 4 种常用的语法分析方法；其中：四种算法为（1）设计算术表达式的递归下降子程序分析算法（2）设计算术表达式的 LL(1) 分析算法（3）设计算术表达式的简单优先分析算法（4）设计算术表达式的SLR(1) 分析算法3、选择上述一种方法并设计一个表达式的语法分析器。

（本实验设计的是递归下降的表达式语法分析器）三、实验内容1．设计递归下降语法分析器算法；2．编写代码并上机调试运行通过； 3、写出试验体会及心得。

四、实验要求1、给出算术表达式文法2、进行适当的文法变换3、选择一种语法分析的方法，并说明其原理4、根据原理给出相应的算法设计，说明主要的数据结构并画出算法流程图5、编写代码并上机调试运行通过6、写出程序运行结果7、写出相应的文档以及代码注释8、输入——表达式；输出——表达式语法是否正确。

五、递归下降的表达式语法分析器设计概要1．算术表达式文法．G(E)：E T F 2．文法变换：文法变换：G’(E)： E->TE' E'->+TE'|ε T->FT' T'->*FT'|ε F->(E)|I E +T | T T* F | F i | (E)3. 递归下降子程序框图：递归下降子程序框图：六、实验设计源程序#includechar inputstream[50]; int temp=0; int right; void e(); void e1(); void t(); void t1(); void f(); void main() { right=1;//存储输入句子//数组下标 //判断输出信息cout<<"请输入您要分析的字符串以#结束(^为空字符)："<>inputstream; e(); if((inputstream[temp]=='#')&&right) cout<<"分析成功"<<<"e-="" cout<<"分析失败"<TE'"<<<"e'-="" e1()="" e1();="" if(inputstream[temp]="='+')" t();="" void="" {="" }="">+TE'"<e1(); } else if (inputstream[temp]!='#'||inputstream[temp]!=')') { cout<<"T'->^"<<<"t-="" else="" return="" right="0;" t()="" void="" {="" }="">FT'"<<<"t'-="" f();="" if(inputstream[temp]="='*')" t1()="" t1();="" void="" {="" }="">*FT'"<<<"t'-="" else="" f();="" if="" t1();="" temp++;="" {="" }="">^"<} } void f() { if(inputstream[temp]=='i') { cout<<"F->i"<if(inputstream[temp]=='(') { cout<<"F->(E)"<<<"f-="" e();="" if(inputstream[temp]="=')')" temp++;="" {="">(E)"<七、运行结果八、实验思考题语法分析的任务是什么？语法分析的任务是什么？答：语法分析器的任务是识别和处理比单词更大的语法单位，如：程序设计语言中的表达式、各种说明和语句乃至全部源程序，指出其中的语法错误；必要时，可生成内部形式，便于下一阶段处理。

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

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

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

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

使用递归下降分析算法分析表达式是否符合下文法：exp → exp addop term | termAddop →+ | -term→ term mulop factor | factormulop → * | /factor → (exp) | id | number其中number可以是多位的十进制数字串（整数即可），因此这里还需要一个小的词法分析器来得到id 和number的值。

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);是为了忽略分析文件中的换行或空格，之后进入分析阶段，根据返回值判断是否是合法的表达式。

编译原理实验递归下降子程序

编译原理实验递归下降子程序

编译原理程序设计实验报告——表达式语法分析器的设计实现班级：计算机1306班姓名：王利达学号：20133959 实验目标：使用递归下降子程序法构造表达式语法分析器程序，分析并判别算术表达式，给出判别结果。

实验内容：一、概要设计算术表达式文法：E-> T | Eω0TT-> F | Tω1FF-> i | ( E )其中ω0：+ -ω1：* /i：数字或常数文法变换：E -> T E1E1 -> ω0 T E1 |εT -> F | T1T1 -> ω1 F T1 |εF -> i | ( E )其中ω0：+ -ω1：* /i：数字或常数二、数据结构输入表达式，存入一个大小为100、名为expstr的数组中，指针p指向数组expstr的首地址。

其中，数组内的表达式由用户输入，最后以字符“#”结束。

程序有subpE、subpE1、subpT、supbT1、supbF、i等子函数。

三、流程图E入口进入T进入E1E出口图1.E的子函数流程图 void subpE()E1入口进入T 进入E1E1出口当前字符是+或-？NY图2.E1子程序函数的流程图 void subpE1()图3.T 子程序函数的流程图 void subpT() T1入口进入F判断是否是*或/？读下一个字符进入T1T1出口N Y图4.T1的子程序流程图 void subpT1()F 入口E1出口判断是否是i ？NYch=( ?ch=) ?进入E读下一个字符读下一个字符读下一个字符YYError!NN图4.F 子程序的流程图 void subpF()四、关键函数函数int i()是一个能简单判断表达式中i 是否是常数或变量的函数，它还能对不符合算术表达式要求的i 报错。

int i(){char cn=*(p+1);//取数组中下一个字符if((ch>='0'&&ch<='9')&&((cn>='a'&&cn<='z')||(cn>='A'&&cn<='Z'))){cout<<"错误！i 的格式不正确！"<<endl;ch=0;return 0;}else if(ch!='('&&ch!='#'){if((cn>='a'&&cn<='z')||(cn>='A'&&cn<='Z')||(cn>='0'&&cn<='9')){p++;ch=*p;return i();}else if(cn=='.'){p++;ch=*p;return i();}}else if((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')||(ch>='0'&&ch<='9')) {return 1;}elsereturn 0;}源程序代码：（加入注释）//main.cpp#include<iostream>#include<stdio.h>#include<string.h>using namespace std;char ch;char expstr[100];//用户输入的数组char *p=expstr;//指向数组的指针void subpE();//E的子程序函数void subpE1();//E1的子程序函数void subpT();//T的子程序函数void subpT1();//T1的子程序函数void subpF();//F的子程序函数int i();//简易判断i元素的函数void subpE(){subpT();subpE1();}void subpE1(){if(ch=='+'||ch=='-'){p++; //指针指向下一个ch=*p;subpT();subpE1();}}void subpT(){subpF();subpT1();}void subpT1(){if(ch=='*'||ch=='/'){p++;ch=*p;subpF();subpT1();}}void subpF(){if(i()){p++;ch=*p;}else if(ch=='('){p++;ch=*p;if(ch==')'){p++;ch=*p;}else{cout<<"错误！括号不匹配！"<<endl;ch=0;}}else{cout<<"错误！括号不匹配！"<<endl;ch=0;}}int i(){char cn=*(p+1);//取数组中下一个字符if((ch>='0'&&ch<='9')&&((cn>='a'&&cn<='z')||(cn>='A'&&cn<='Z'))) {cout<<"错误！i的格式不正确！"<<endl;ch=0;return 0;}else if(ch!='('&&ch!='#'){if((cn>='a'&&cn<='z')||(cn>='A'&&cn<='Z')||(cn>='0'&&cn<='9')){p++;ch=*p;return i();}else if(cn=='.'){p++;ch=*p;return i();}}else if((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')||(ch>='0'&&ch<='9')) {}elsereturn 0;}int main(){cout<<"请输入一个表达式并以\"#\"结束:"<<endl;cin>>expstr;ch=*p;subpE();if(ch=='#')cout<<"正确！"<<endl;elsecout<<"错误！"<<endl;return 0;}程序运行结果：（截屏）图5. 正确的算术表达式判断((Aa+Bb)*((88.2)/3))思考问题回答：（如果有）。

实验报告四递归下降语法分析程序设计

实验报告四递归下降语法分析程序设计

实验报告四递归下降语法分析程序设计《编译原理》实验报告实验序号： 4 实验项⽬名称：递归下降语法分析程序设计SELECT（E’ →ε）={ε，)，#}对T SELECT（T→FT’）={(，i}对T’ SELECT（T’ →*FT’）={ * }SELECT（T’ →⁄FT’）={ ⁄ }SELECT（T’ →ε）={ε，+，?，)，#}对F SELECT（F→(E) ）={ ( }SELECT（F→i）={ i }∴SELECT(E’ →+TE’)∩SELECT（E’ →?TE’）∩SELECT（E’ →ε）=ΦSELECT(T’ →*FT’)∩SELECT（T’→⁄FT’）∩SELECT（T’ →ε）=ΦSELECT（F→(E) ）∩SELECT（F→i）= Φ由上可知，有相同左部产⽣式的SELECT集合的交集为空，所以⽂法是LL （1）⽂法。

因此，转化后的⽂法可以⽤递归下降分析法作语法分析。

（2）设计这⾥采⽤递归下降分析法形象描述递归⼦程序。

程序中将要⽤到的⼏个重要数据如下：⼀个全局变量ch，存放由⽂件输⼊得到的字符。

⼀个函数宏READ(ch)，实现读取⽂件中的字符。

五个⼦函数：P(E)、P(E’)、P(T)、P(T’)、P(F)。

（3）程序代码如下/******************************************************************** ***** ⽂件名：ana.c* ⽂件描述：递归下降语法分析器。

分析如下⽅法：* E->E+T | E-T | T* T->T*F | T/F |F* F->(E) | i* 输⼊：每⾏含⼀个表达式的⽂本⽂件。

* 输出：分析成功或不成功信息。

* 创建⼈：余洪周 2006-12-8* 版本号：1.0********************************************************************* **/#include#include#define READ(ch) ch=getc(fp) /*宏：READ(ch)*/char ch; /*声明为全局变量*/int right=0;FILE *fp;struct struCH{char ch;struct struCH *next;}struCH,*temp,*head,*shift;/*head指向字符线性链表的头结点*//*shift指向动态建成的结点(游标)*/void main(int argc,char *argv[]){void E (); /* P(E) */void E1(); /* P(E')*/void T (); /* P(T) */void T1(); /* P(T')*/void F (); /* P(F) */int errnum=0,k=0,m=0,countchar=0,rownum;int charerr=0; /*开关控制量*//************************以只读⽅式打开⽂件*********************/ if((fp=fopen(argv[1],"r"))==NULL){printf("\n\tCan not open file %s,or not exist it!\n",argv[1]);exit(0); /*⽂件不存在or打不开时，正常退出程序*/}else printf("\n\tSuccess open file: %s\n",argv[1]); /*成功打开⽂件*//******************遍历整个⽂件检测是否有⾮法字符********************//*如果⽤while(!feof(fp))语⾔，将会多出⼀个字符*所以这⾥采⽤以下⽅法遍历整个⽂件检测其否有⾮法字符*//*[1]计算⽂件中字符数量*/while(!feof(fp)){READ(ch); /*这⾥读取字符只是让⽂件指针往前移*/countchar++; /*统计⽂件中的字符数(包括换⾏符及⽂件结束符)*/}rewind(fp); /*将fp⽂件指针重新指向⽂件头处，以备后⾯对⽂件的操作*/if(countchar==0){ /*空⽂件*/printf("\t%s is a blank file!\n",argv[1]);exit(0); /*正常退出本程序*/}/*[2]开始遍历⽂件*/while(k<(countchar-1)){ /*加换⾏符后countchar仍多了⼀个，不知为何*/ ch=getc(fp);if(!(ch=='('||ch==')'||ch=='i'||ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='#'||ch=='\n')){ charerr=1;errnum++; /*charerror出错标记，errnum统计出错个数*/}k++;}rewind(fp); /*将fp⽂件指针重新指向⽂件头处，以备后⾯的建链表操作*/if(charerr==1){ /*⽂件中有⾮法字符*/printf("\n\t%d Unindentify characters in file %s \n",errnum,argv[1]);exit(0); /*正常退出本程序*/}/*******************⾮空且⽆⾮法字符，则进⾏识别操作*****************/for(rownum=1;m<(countchar-1);rownum++){ /*识别所有⾏,rownum记录⾏号*/ /*初始变量及堆栈和*/right=1;/*初始存放待识别的表达式的线性链表头*/shift=malloc(sizeof(struCH));/**/shift->next=NULL;head=shift;/*读取⼀⾏形成线性链表*/READ(ch);putchar(ch);m++;while(ch!='\n'&&m<(countchar)){ /*⾏末or到⽂件尾。

华工编译原理实验报告

华工编译原理实验报告

一、实验目的通过本次实验，加深对编译原理中语法分析部分的理解，掌握递归下降分析法和LR(1)分析法的原理和实现方法，并能够运用所学知识对简单的文法进行语法分析。

二、实验内容本次实验主要分为两个部分：1. 递归下降分析法- 实验要求：针对给定的文法，编写递归下降分析程序，实现对输入的字符串进行语法分析。

- 文法示例：```S -> A BA -> a A | εB -> b B | ε```- 实现过程：- 定义文法的非终结符号、终结符号和开始符号。

- 设计递归下降分析函数，按照文法的产生式进行递归调用。

- 处理输入字符串，调用递归下降分析函数进行语法分析。

2. LR(1)分析法- 实验要求：针对给定的文法，编写LR(1)分析程序，实现对输入的字符串进行语法分析。

- 文法示例：```S -> A BA -> a A | εB -> b B | ε```- 实现过程：- 求解文法的 FIRST 集和 FOLLOW 集。

- 构建LR(1)分析表，包括状态转移函数、接受状态和错误处理函数。

- 设计LR(1)分析程序，根据分析表进行状态转移和语法分析。

三、实验步骤1. 递归下降分析法- 步骤一：定义文法的非终结符号、终结符号和开始符号。

- 步骤二：设计递归下降分析函数，按照文法的产生式进行递归调用。

- 步骤三：编写主函数，读取输入字符串，调用递归下降分析函数进行语法分析。

2. LR(1)分析法- 步骤一：求解文法的 FIRST 集和 FOLLOW 集。

- 步骤二：构建LR(1)分析表，包括状态转移函数、接受状态和错误处理函数。

- 步骤三：设计LR(1)分析程序，根据分析表进行状态转移和语法分析。

四、实验结果1. 递归下降分析法- 对于输入字符串 "aaabbb"，程序能够正确分析并输出分析结果。

2. LR(1)分析法- 对于输入字符串 "aaabbb"，程序能够正确分析并输出分析结果。

实验三递归下降分析器设计与实现编译原理实验报告

实验三递归下降分析器设计与实现编译原理实验报告

实验三递归下降分析器设计与实现编译原理实验报告一、引言递归下降分析器是编译原理中常用的一种语法分析方法。

它根据文法规则和输入的源代码，递归地进行语法分析，判断源代码是否符合给定的文法规则。

本实验旨在通过设计与实现一个简单的递归下降分析器，加深对编译原理中语法分析的理解。

二、实验目的1.学习递归下降分析器的原理和设计方法；2.掌握使用递归下降分析器进行简单语法分析的过程；3.加深对编译原理中文法规则和语法分析的理解。

三、实验过程1.设计文法规则：根据实验要求，设计一个简单的算术表达式文法规则。

例如，我们可以采用以下文法规则：```E->E+T，E-T，TT->T*F，T/F，FF -> ( E ) ， num```2.设计分析器：根据设计的文法规则，设计递归下降分析器的结构和算法。

我们可以使用编程语言实现一个类，其中包含递归下降分析器所需要的方法和数据结构。

3. 实现分析器：根据设计的分析器结构和算法，使用编程语言实现递归下降分析器的代码。

可以选择常用的编程语言，如C++、Java、Python等。

4.进行语法分析：编写测试代码，使用实现的递归下降分析器对输入的算术表达式进行语法分析。

根据分析结果，判断输入的算术表达式是否符合给定的文法规则。

五、实验结果实验结果根据设计的分析器的实现和测试代码的编写而定。

例如，对于以下输入的算术表达式：(3+4)*5-2，经过递归下降分析器的分析，应该能正确判断其是否符合给定的文法规则。

六、实验总结递归下降分析器是编译原理中常用的一种语法分析方法。

通过实验三，我深入理解了递归下降分析器的原理和设计方法，并通过实现一个简单的递归下降分析器，加深了我对编译原理中文法规则和语法分析的理解。

在实验过程中，我学会了如何根据设计的文法规则来设计递归下降分析器的结构和算法。

我使用了编程语言实现了递归下降分析器的代码，并编写了相应的测试代码进行语法分析。

通过测试，我验证了递归下降分析器的正确性。

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

武汉工程大学计算机科学与工程学院
《编译原理》实验报告
专业班级实验地点
学生学号指导教师
学生姓名实验时间
实验项目实验二、算术表达式递归下降分析程序设计
实验类别操作性（）验证性（）设计性（√）综合性（）其它实
验目的及要求（1）掌握自上而下语法分析的要求与特点。

（2）掌握递归下降语法分析的基本原理和方法。

（3）掌握相应数据结构的设计方法。

成绩评定表
类别评分标准分值得分合计
上机表现积极出勤、遵守纪律
主动完成实验设计任务
30分
实验报告及时递交、填写规范
内容完整、体现收获
70分
说明：
评阅教师：
日期：
实验内容
一、实验目的
（1）掌握自上而下语法分析的要求与特点。

（2）掌握递归下降语法分析的基本原理和方法。

（3）掌握相应数据结构的设计方法。

二、实验内容
编程实现给定算术表达式的递归下降分析器。

算术表达式文法如下：E→E+T | T
T→T*F | F
F→(E) | i
设计说明：首先改写文法为LL(1)文法；然后为每一个非终结符，构造相应的递归函数，函数的名字表示规则左部的非终结符；函数体按规则右部符号串的顺序编写。

三、设计分析
（1）消去该文法左递归，得到文法：
E→TE1
E1→+TE1|ε
T→FT1
T1→*FT1|ε
F→(E)| I
（2）根据LL（1）文法的判断条件，计算这个文法的每个非终结符的FIRST 集和FOLLOW集，经验证，改后的文法已经是LL（1）文法。

（3）最后构造递归下降分析程序，每个函数名是相应的非终结符，函数体则是根据右部符号串的结构编写。

a.当遇到非终结符时，如：+。

则编写语句if(当读来的输入符号== +) 读下一个输入符号
b.当遇到非终结符时，例如：T。

则编写语句调用T()。

c.当遇到非终结符→ε规则时，例如：T→ε。

则编写语句 if(当前读来的输入字符不属于FOLLOW(T)) error()
d.当某个非终结符的规则有很多个候选式时。

按LL(1)文法的条件能唯一的选择一个候选式进行推导。

（4）递归下降分析法是确定的自上而下分析法，基本思想是，对文法中的每个非终结符编写一个函数，每个函数的功能是识别由该非终结符所表示的语法成分。

因此需要分别构造E,E1,T,T1,F函数来执行自己的识别功能，根据文法的内容顺序决定函数的识别功能。

Scaner函数用于字符串的推进，input函数用于字符串的输入。

四、程序代码
#include <stdio.h>
#include <string.h>
#include <iostream>
using namespace std;
char a[80];
char sym;
int i=0;
void E();
void E1();
void T();
void T1();
void F();
void input();
void Scaner();
void Error();
void input()
{
puts("输入需要分析的字符串（以#键结尾）:");
cin>>a;
}
void Scaner()
{
sym = a[i];
i++;
}
void Error()
{
cout<<"Error"<<endl;
exit (0);
}
void main()
{
while(1)
{
input();
Scaner();
E();
if (sym == '#')
printf("此字符串是该文法的字符串!\n");
else
printf("Error!\n");
i=0;
}
}
void E()
{
T();
E1();
}
void E1()
{
if (sym == '+')
{
Scaner();
T();
E1();
}
else if ((sym!=')') && (sym!='#'))
Error();
}
void T()
{
F();
T1();
}
void T1()
{
if (sym == '*')
{
Scaner();
F();
T1();
}
else if ((sym!='+' && sym!=')') && sym!='#')
Error();
}
void F()
{
if (sym == '(')
{
Scaner();
E();
if (sym == ')')
Scaner();
else
Error();
}
else if (sym =='i')
Scaner();
else
Error();
}
五、测试用例
1.输入的字符串只含有一个字符时：
输入i#
a#
2．输入的字符串含有+ 时：
输入++#
输入i++#
输入i+i#
3．输入的字符串含有* 时：输入**#
输入**i#
输入*i*#
输入i*i#
i*i*#
3．输入的字符串含有（）时：
输入（）#
（i）#
4．输入的字符串含有多种字符：输入i+i*i#
(i+i)*i#
(i+i)*(i+i)#
(i+*#
实验总结
此次实验，使我掌握自上而下语法分析的要求与特点，也更加了解递归下降语法分析的基本原理和方法并学会相应数据结构的设计方法。

递归下降分析法简单、直观，易于构造程序，但它对文法要求较高，必须是LL（1）文法，同时递归调用较多，在编程的时候要特别注意，函数的顺序不能打乱，函数声明要位置明确，不能乱，掌握一定的规律，使程序有条理。

在实验中也出现了一些错误和碰到了一些难题，不过在同学的帮助下基本上都解决了。

在刚开始的设计分析思路和程序设计中，也遇到过一些问题，一般的情况是对所学的知识还没有完全掌握好，没有透彻理解，对所学知识不能够灵活运用，在课后需要多巩固。

在以后的日子里，需要学习的还有很多，不能懈怠。

相关文档
最新文档