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

合集下载

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

武汉工程大学计算机科学与工程学院《编译原理》实验报告一、实验目的（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)就说明两者可以相互替代。

编译原理递归下降

《编译原理》课程实验实验二：自顶向下的语法分析：递归下降法1、实验目的：编制一个递归下降分析程序，实现对词法分析程序所提供的单词序列的语法检查和结构分析。

2、实验要求：文法（教材199页）（1）把词法分析作为语法分析的子程序实现（5分）（2）独立的语法分析程序（4分）（3）输入串以‘#’结束，输出成功（success）或出错（error）、指出出错位置（行、列以及错误类型）#include<iostream>#include<ctype.h>#include<fstream>#include<string.h>#include<malloc.h>using namespace std;ifstream fp("in.txt",ios::in);char cbuffer;char *key[13]={"if","else","for","while","do","return","break","continue","int","void" ,"main","begin","end"}; //关键字char *border[8]={ "," , ";" , "{" , "}" , "(" , ")" ,"//","\""}; //分界符char *arithmetic[6]={"+" , "-" , "*" , "/" , "++" , "--"}; //运算符char *relation[7]={"<" , "<=" , "=" , ">" , ">=" , "==" ,"!="}; //关系运算符char *lableconst[80]; //标识符int constnum=40;int lableconstnum=0;int colnum = 1, linenum=1; //统计常数和标识符数量int type1, type2;int search(char searchchar[],int wordtype){int i=0,t=0;switch (wordtype){case 1:{ for (i=0;i<=12;i++) //关键字{if (strcmp(key[i],searchchar)==0)return(i+1);}return(0);}case 2:{for (i=0;i<=6;i++) //分界符{if (strcmp(border[i],searchchar)==0)return(i+1);}return(0);}case 3:{for (i=0;i<=5;i++) //运算符{if (strcmp(arithmetic[i],searchchar)==0)return(i+1);}return(0);}case 4:{for (i=0;i<=6;i++) //关系运算符{if (strcmp(relation[i],searchchar)==0)return(i+1);}return(0);}case 5:{for (t=40;t<=constnum;t++) //常数{if (strcmp(searchchar,lableconst[t])==0)//判断该常数是否已出现过return(t+1);}lableconst[t-1]=(char *)malloc(sizeof(searchchar));//为新的元素分配内存空间strcpy(lableconst[t-1],searchchar);//为数组赋值lableconst指针数组名constnum++; //常数个数自加return(t);}case 6:{for (i=0;i<=lableconstnum;i++){if (strcmp(searchchar,lableconst[i])==0) //判断标识符是否已出现过return(i+1);}lableconst[i-1]=(char *)malloc(sizeof(searchchar));strcpy(lableconst[i-1],searchchar);lableconstnum++; //标识符个数自加return(i);}default:cout<<"错误！";return 0;}}char alphaprocess(char buffer) //字符处理过程{int atype;int i=-1;char alphatp[20];while (((isalpha(buffer))||(isdigit(buffer))) && !fp.eof()){alphatp[++i]=buffer;fp.get(buffer);}alphatp[i+1]='\0';//在末尾添加字符串结束标志if (atype=search(alphatp,1)){cout<<alphatp<<"\t\t\t"<<"关键字"<<endl;type1 = 0;}else{atype=search(alphatp,6); //标识符cout<<alphatp<<"\t\t\t"<<"标识符"<<endl;type1 = 1;}type2 = atype;return(buffer);}char digitprocess(char buffer) //数字处理过程{int i=-1;char digittp[20];int dtype;while((isdigit(buffer)||buffer=='.'||buffer=='e'||buffer=='+'||buffer=='-')&& !fp.eof()) {digittp[++i]=buffer;fp.get(buffer);}digittp[i+1]='\0';dtype=search(digittp,5);cout<<digittp<<"\t\t\t"<<"数据"<<endl;type1 = 8;type2 = dtype;return(buffer);}char otherprocess(char buffer) //分界符、运算符、逻辑运算符、等{int i=-1;char othertp[20];int otype,otypetp;othertp[0]=buffer;othertp[1]='\0';if (otype=search(othertp,3)){fp.get(buffer);othertp[1]=buffer;othertp[2]='\0';if (otypetp=search(othertp,3)) //判断该运算符是否是//由连续的两个字符组成的{cout<<othertp<<"\t\t\t"<<"运算符"<<endl;fp.get(buffer);type1 = 2;goto out;}else//单字符逻辑运算符{othertp[1]='\0';cout<<othertp<<"\t\t\t"<<"逻辑运算符"<<endl;type1 = 3;goto out;}}if (otype=search(othertp,4)) //关系运算符{fp.get(buffer);othertp[1]=buffer;othertp[2]='\0';if (otypetp=search(othertp,4)) //判断该关系运算符是否是//由连续的两个字符组成的{cout<<othertp<<"\t\t\t"<<"关系运算符"<<endl;fp.get(buffer);type1 = 4;goto out;}else//单字符逻辑运算符{othertp[1]='\0';cout<<othertp<<"\t\t\t"<<"逻辑运算"<<endl;type1 = 5;goto out;}}if (buffer=='!') //"=="的判断{fp.get(buffer);if (buffer=='=')//cout<<"!= (2,2)\n";fp.get(buffer);type1 = 6;goto out;}else{if (otype=search(othertp,2)) //分界符{cout<<othertp<<"\t\t\t"<<"分界符"<<endl;fp.get(buffer);type1 = 7;goto out;}}if ((buffer!='\n')&&(buffer!=' '))cout<<"错误！,字符非法"<<"\t\t\t"<<buffer<<endl;fp.get(buffer);out:type2 = otypetp;return(buffer);}void getWord(){type1 = -1;while(type1 == -1){if (fp.eof()) break;colnum++;if(cbuffer=='\n'){linenum++;colnum = 1;fp.get(cbuffer);}else if (isalpha(cbuffer)){cbuffer=alphaprocess(cbuffer);}else if (isdigit(cbuffer)){cbuffer=digitprocess(cbuffer);}elsecbuffer=otherprocess(cbuffer);}}string eText;bool hasError;void setError(string text) {hasError = true;eText = text;}void checkExpression();void checkFactor() {cout << type1 << " " << type2 << endl;if (type1 == 1 || type1 == 8) getWord();else if (type1 == -1) setError("缺少值或变量。

编译原理递归下降子程序

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

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

二、实验内容及要求1．针对算术表达式文法：E→TE’E’→ +TE’|εT→FT’T’→*FT’ |εF→(E) |i为其编写递归下降子程序，判定某个算术表达式是否正确：如j+k*m，j*k+m输入：其输入数据应该为词法分析器输出的记号形式：i+i*i，i*i+i输出：分析结果：算术表达式结构正确或结构错误。

三、实验程序设计说明1．实验方案设计各个函数之间的调用关系如下图所示：2．程序源代码源代码如下：#include<stdio.h>#include<iostream>#include<fstream>#include<string>char a[10];int lookahead=0;void E1();void T();void T1();void F();void E(){printf("E->TE'\n");T();E1();}void E1(){if(a[lookahead]=='+'){printf("E'->+TE'\n");lookahead++;T();E1();}elseprintf("T'->ε\n"); }void T(){printf("T->FT'\n");F();T1();}void T1(){if(a[lookahead]=='*'){printf("T'->*FT'\n");lookahead++;F();T1();}elseprintf("T'->ε\n"); }void F(){if(a[lookahead]=='i'){printf("F->i\n");lookahead++;}else if (a[lookahead]=='('){lookahead++;E();if(a[lookahead]==')'){printf("F->(E)\n");lookahead++;}else{printf("\n括号不匹配分析失败!\n");exit (0);}}else{printf("括号不匹配,分析失败!\n");exit(0);}}int main(){while(1){printf("请输入算数表达式(以#键结束)：");scanf("%s",a);E();if((a[lookahead]=='#'))printf("句子结构正确\n");elseprintf("无结束标志，分析失败\n");}return 0;}3．程序的执行结果程序运行结果如下所示：四、实验中出现的问题及解决方法1.错误处理：最初程序只是将所有的错误都简单的显示为句子结构错误，并没有进行具体详细的说明和解释，最后通过修改程序，细化错误类型，使用了对if语句的嵌套，将错误分为三种类型。

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

根据某一文法编制调试递归下降分析程序，以便对任意输入的符号串进行分析。

#include<stdio.h>#include<stdlib.h>#define N 20char Str[N]; /* 用于存放输入的字符串 */int i=0;int max=0; /* 输入字符串的长度下标 */int curr=0; /* 当前字符的下标 */int flag=0; /* 用于标记判断过程中是否出现错误 */void inputString(); /* 输入要分析的字符串 */void nextChar(); /* 分析下一个字符 */void E();void G();void T();void S();void F();void outputResult(); /* 输出分析结果 */void inputString(){printf("\n实验名：递归下降分析程序\n\n");printf("姓名：汪茁\t学号：0904011035\t班级：09计本(4)班\n\n");printf("文法如下：\n");printf("(1) E->TG\n(2) G->+TG|-TG\n(3) G->ε\n(4) T->FS\n");printf("(5) S->*FS|/FS\n(6) S->ε\n(7) F->(E)\n(8) F->i\n\n");printf("请输入要分析的字符串（以'#'号结束）：\n");for(i=0;i<N;i++){scanf_s("%c",&Str[i]);if(Str[i]=='#'){max=i;break;}}printf("\n");}void nextChar(){if(curr==max){exit(0);}else{curr++;}}void E(){T();}void G(){if(Str[curr]=='+'){nextChar();T();G();}else if(Str[curr]=='-'){nextChar();T();G();}}void T(){F();S();}void S(){if(Str[curr]=='*'){nextChar();F();S();}else if(Str[curr]=='/'){nextChar();F();S();}}void F(){if(Str[curr]=='('){nextChar();E();if(Str[curr]==')'){nextChar();}else{flag=1;}}else if(Str[curr]=='i'){nextChar();}{flag=1;}}void outputResult(){printf("分析结果：符号串");for(i=0;i<max;i++){printf("%c",Str[i]);}if(flag==0){printf("是合法的符号串！\n\n");}else{printf("是非法的符号串！\n\n");}}void main(){inputString();E();outputResult();}图 1 合法符号串[i*i+i-i/i]图 2 非法符号串[i*i+i-i/i-]图 3 带括号的合法符号串[i*(i+i)-i]图 4 带括号的非法符号串[i*(i+i-i]。

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

编译原理之递归下降语法分析程序（实验）⼀、实验⽬的利⽤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)

编译原理实验报告实验名称：编写递归下降语法分析程序实验类型：验证型实验指导教师：专业班级：姓名：学号：电子邮件：实验地点：实验成绩：日期：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>

编译原理实验_递归下降语法分析

递归下降语法分析姓名：郝梦朔学号：日期：2010-1-17一、实验目的构造文法的语法分析程序，要求采用递归下降语法分析方法对输入的字符串进行语法分析，实现对词法分析程序所提供的单词序列的语法检查和结构分析，进一步掌握递归下降的语法分析方法。

二、实验内容编写为一上下文无关文法构造其递归下降语法分析程序，并对任给的一个输入串进行语法分析检查。

程序要求能对输入串进行递归下降语法分析，能判别程序是否符合已知的语法规则，如果不符合（编译出错），则输出错误信息。

三、实验要求利用C语言编制递归下降分析程序，并对语言进行语法分析。

（1）待分析的语言的语法。

用扩充额BNF表示如下。

①<程序>::=function<语言串>endfunc②<语言串>::=<语句>{;<语句>}③<语句>::=<赋值语句>④<赋值语句>::=ID=<表达式>⑤<表达式>::=<项>{+<项>|-<项>}⑥<项>::=<因子>{*<因子>|/<因子>}⑦<因子>::=ID|NUM|(<表达式>)（2）实验要求说明输入单词串以“#”结束，如果是文法正确的句子，则输出成功信息，打印“success”，否则输出“error”，具体例子如下。

输入functiona=9;x=2*3;b=a+x;endfunc#输出success又如，输入：x=a+b*cendfunc#输出error（3）语法分析程序的算法思想为翟玉庆老师上课所讲。

四、实验源程序#include<stdio.h>#include<string.h>char prog[80],token[8];char ch;int syn,p,m=0,n,sum,kk=0;char *rwtab[6]={"function","if","then","while","do","endfunc"};void scaner();void lrparser();void yucu();void statement();void expression();void term();void factor();void main(){p = 0;printf("please input the string:\n");do{ch = getchar();prog[p++] = ch;}while(ch != '#');p = 0;ch = prog[p++];scaner();lrparser();return;}void scaner(){for(n=0;n<8;n++)token[n]=NULL;//printf("\n%c in scaner()",ch);while(ch == ' ' || ch == '\n' )ch = prog[p++];//printf("\n%c in scaner()",ch);m = 0;if((ch<='z' && ch>='a') ||(ch<='Z' && ch>='A')){while((ch<='z' && ch>='a') ||(ch<='Z' && ch>='A')||(ch<='9' && ch>='0')){token[m++] = ch;ch = prog[p++];}syn=10;for(n=0;n<6;n++)if(strcmp(token,rwtab[n]) == 0){syn = n+1;//printf("\n%d in keyword",syn);break;}token[m++] = '\0';}else if(ch<='9' && ch>='0'){sum=0;while(ch<='9' && ch>='0'){sum = sum*10 + ch - '0';ch = prog[p++];}syn = 11;}else{switch(ch){case '<':m = 0;token[m++] = ch;ch = prog[++p];if(ch == '='){syn = 22;token[m++] = ch;}else{syn = 20;ch = prog[--p];}break;case '>':m = 0;token[m++] = ch;ch = prog[++p];if(ch == '='){syn = 24;token[m++] = ch;}else{syn = 23;ch = prog[--p];}break;case '=':m = 0;token[m++] = ch;ch = prog[++p];if(ch == '='){syn = 25;token[m++] = ch;}else{syn = 18;ch = prog[--p];}break;case '!':m = 0;token[m++] = ch;ch = prog[++p];if(ch == '='){syn = 22;token[m++] = ch;}elsesyn = -1;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 = 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;}ch = prog[p++];}}void lrparser(){if(syn ==1){//printf("\n%d",syn);scaner();//printf("\n%d",syn);yucu();/**/// printf("\n%d after yucu()",syn);if(syn == 6){scaner();//printf("\n%d in lrparser() after scaner()",syn);if(syn == 0 && kk == 0)printf("\nsuccess!\n");else{if(kk != 1){printf("error!need 'endfunc'");kk = 1;}}}else{printf("error!need 'function'");kk =1;}return;}void yucu(){//printf("\n%d in yucu() first",syn);statement();//printf("\n%d after statement() in yucu()",syn);while(syn == 26){scaner();//syn = 6;//printf("\n%d after scaner() in yucu()",syn);statement();}return;}void statement(){//printf("\n%d in statement() at first",syn);if(syn == 10){scaner();//printf("\n%d after scaner() in statement()",syn);if(syn == 18){scaner();// printf("\n%d after scaner when syn=18",syn);expression();// printf("\n%d after expression()",syn);else{printf("error! evaluate tag error");kk = 1;}}else if(syn == 6)return;else{printf("error! the statement error!");kk = 1;}return;}void expression(){// printf("\n%d in expression at first",syn);term();while(syn == 13 || syn == 14){scaner();term();}return;}void term(){// printf("\n%d in term() at first",syn);factor();while(syn == 15 || syn == 16){scaner();factor();}return;}void factor(){// printf("\n%d in factor() at first",syn);if(syn == 10 || syn == 11){scaner();}else{if(syn == 27){scaner();expression();if(syn == 28){scaner();}else{printf("error! need another ')'");kk = 1;}}else{printf("error! expression error!");}}}五、程序运行效果截图六、心得体会这个实验其实是上个实验的扩展，有个上个实验的基础做这个实验就比较轻松了。

编译原理实验报告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.运用所学知识，编程实现递归下降语法分析程序。

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 实验目标：使用递归下降子程序法构造表达式语法分析器程序，分析并判别算术表达式，给出判别结果。

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

程序有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))思考问题回答：（如果有）。

递归下降分析器程序(c语言版,编译原理实验)1

《编译原理》实验报告实验二：语法分析程序设计班级：08计算计（3）班姓名：斯军浩学号：E08620325递归下降分析器设计[实验目的]：1．了解语法分析的主要任务。

2．熟悉编译程序的编制。

[实验内容]：根据某文法，构造一基本递归下降语法分析程序。

给出分析过程中所用的产生式序列。

实验报告中要说明分析使用的方法。

4.生成并输出分析过程中所用的产生式序列：1 产生式12 产生式2……[实验步骤]：1.写出一个小语言的文法，根据情况自由选择C语言或Pascal语言。

2.写出该小语言的算术表达式等价的LL(1)文法。

G[E]：其中E→TG G为E’G→+TG|∧∧为εT→FS S为T’S→*FS|∧F→i|(E)3.编写递归下降语法分析程序。

4.调试运行程序。

5.结果分析。

6.撰写实验报告。

实验代码#include<stdio.h>void E();void T();void E1();void T1();void F();char s[100];int i, SIGN;int main(){printf("请输入一个语句，以#号结束语句（直接输入#号推出）\n");while( 1 ){SIGN = 0;i=0;scanf("%s",&s);if( s[0] == '#')return 0;E();if(s[i]=='#')printf("正确语句！\n");printf("请输入一个语句，以#号结束语句\n");}return 1;}void E(){if(SIGN==0){T();E1();}}void E1(){if(SIGN==0){if(s[i]=='+'){++i;T();E1();}else if(s[i]!='#'&&s[i]!=')'){printf("语句有误！\n");SIGN=1;}}}void T(){if(SIGN==0){F();T1();}}void T1(){if(SIGN==0){if(s[i]=='*'){++i;F();T1();}else if(s[i]!='#'&&s[i]!=')'&&s[i]!='+'){printf("语句有误！\n");SIGN=1;}}}void F(){if(SIGN==0){if(s[i]=='('){++i;E();if(s[i]==')')++i;else if(s[i]== '#'){printf("语句有误！\n");SIGN=1;++i;}}else if(s[i]=='i')++i;else{printf("语句有误！\n");SIGN=1;}}}测试用例（1）输入i，预期显示语句正确！（2）输入iii，预期显示语句有误！（3）输入a，预期显示语句有误！（4）输入(i)，预期显示语句正确！（5）输入(a)，预期显示语句有误！（6）输入(i+i)，预期显示语句正确！（7）输入(i+i，预期显示语句有误！（8）输入((i*i)+i)*i，预期显示语句正确！（9）输入((((i+i*i))))，预期显示语句正确！（10）输入(i+ia，预期显示语句有误！（11）输入i+i*i+i*a，预期显示语句有误！。

编译原理编写递归下降语法分析器

降语法分析器学院：信息与控制工程学院专业：计算机科学与技术班级：计算机1401班姓名：叶达成2016年10月31日一、上机目的通过设计、编制、调试一个递归下降语法分析程序，实现对词法分析程序所提供的单词序列进行语法检查与结构分析，掌握常用的语法分析方法。

通过本实验，应达到以下目标：1、掌握从源程序文件中读取有效字符的方法与产生源程序的内部表示文件的方法。

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

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

二、基本原理与上机步骤递归下降分析程序实现思想简单易懂。

程序结构与语法产生式有直接的对应关系。

因为每个过程表示一个非终结符号的处理，添加语义加工工作比较方便。

递归下降分析程序的实现思想是：识别程序由一组子程序组成。

每个子程序对应于一个非终结符号。

每一个子程序的功能是：选择正确的右部，扫描完相应的字。

在右部中有非终结符号时，调用该非终结符号对应的子程序来完成。

自上向下分析过程中，如果带回溯，则分析过程是穷举所有可能的推导，看是否能推导出待检查的符号串。

分析速度慢。

而无回溯的自上向下分析技术，当选择某非终结符的产生时，可根据输入串的当前符号以及各产生式右部首符号而进行，效率高，且不易出错。

无回溯的自上向下分析技术可用的先决条件是：无左递归与无回溯。

无左递归：既没有直接左递归，也没有间接左递归。

无回溯：对于任一非终结符号U的产生式右部x1|x2|…|x n，其对应的字的首终结符号两两不相交。

如果一个文法不含回路（形如P⇒+ P的推导），也不含以ε为右部的产生式，那么可以通过执行消除文法左递归的算法消除文法的一切左递归（改写后的文法可能含有以ε为右部的产生式）。

三、上机结果测试数据：(1)输入一以#结束的符号串(包括+—*/（）i#)：在此位置输入符号串例如：i+i*i#(2)输出结果：i+i*i#为合法符号串(3)输入一符号串如i+i*#,要求输出为“非法的符号串”。

程序清单：#include<stdio.h>#include<string>char str[50];int index=0;void E(); //E->TX;void X(); //X->+TX | evoid T(); //T->FYvoid Y(); //Y->*FY | evoid F(); //F->(E) | iint main() /*递归分析*/int len;int m;printf("请输入要测试的次数：");scanf("%d",&m);while(m--)printf("请输入字符串(长度<50>）:\n");scanf("%s",str);len=strlen(str);//str[len]='#';str[len+1]='\0';E();printf("%s为合法符号串!\n",str);strcpy(str,"");index=0;} return 0;void E(){ T(); X();}void X()if(str[index]=='+'){ index++;T();X();void T(){ F(); Y(); }void Y(){ i f(str[index]=='*') {index++;F();Y();void F()if(str[index]=='i'){ index++; }else if (str[index]=='(')index++;E();if(str[index]==')'){ index++; }elseprintf("\n非法的符号串!\n");exit (0);elseprintf("非法的符号串!\n");exit(0);屏幕截图：四、讨论与分析通过本次实验对递归下降词法分析器的结构，过程有了更进一步的了解，通过学习书本与试验原理书上的内容，对它的工作原理，具体实行步骤有了进一步的掌握，由于本次试验是测试性试验，所以要求输出的结果是成功与否，输入一个句型，进过分析，判断它是否合法，主要内容在于其判断过程中。

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

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

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

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

二、实验目的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，经过递归下降分析器的分析，应该能正确判断其是否符合给定的文法规则。

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

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

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

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

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

编译原理语法分析实验二表达式语法分析器的设计实现

编译原理程序设计实验报告——实验题目班级：计算机1306姓名：学号：实验目标：表达式语法分析器的设计实现1) 递归下降子程序 2) LL （1）分析法实验内容： 1. 概要设计1) 按照流程图，调用子程序实现；2) 通过ll （1）分析表和对应压栈、弹栈操作实现。

2. 流程图1) 递归： Z ’(main):N Err开始Read （w ） E #? 结束E: E1:Y NY NT: T1：YNYNF ：N N err Y YY N err入口 TE1 入口+? -？出口Read(w) T出口入口 FT1 出口入口*？/？出口Read （w ）T入口I ？（？ Read （w ）E )? Read （w ）出口2) LL （1）：BeginPUSH(#),PUSH(E)POP(x)x ∈VTx ∈VNx=wendW=#nyNEXT(w)yn err查LL （1）分析表空？nPUSH （i ）errny逆序压栈开始构建LL(1)分析表调用函数token （）切分单词调用*Analyse(char *token)进行分析结束3.关键函数1)递归下降子程序void E(); //E->TX;int E1(); //X->+TX | evoid T(); //T->FYint T1(); //Y->*FY | eint F(); //F->(E) | i2)LL（1）分析法char *Find(char vn,char vt)//是否查到表char *Analyse(char *token)//分析过程int Token()//将token中数字表示成i，标识符表示成n源程序代码：（加入注释）1)递归下降子程序：#include<stdio.h>#include<iostream>#include <string.h>#include <stdlib.h>using namespace std;/********全局变量**********/char str[30];int index=0;void E();//E->TX;int E1();//X->+TX | evoid T();//T->FYint T1();//Y->*FY | eint F();//F->(E) | iFILE *fp;char cur;/*************主函数************/int main(){int len;int m;if((fp=fopen("source.txt","r"))==NULL){cout<<"can not open the source file!"<<endl;exit(1);}cur=fgetc(fp);while(cur!='#'){E();}cout<<endl;cout<<"success"<<endl;return 0;}/*************************************/void E(){T();E1();}/*************************************/int E1(){if(cur=='+'){cur=fgetc(fp);T();cout<<'+'<<" ";E1();}else if(cur=='-'){cur=fgetc(fp);T();cout<<'-'<<" ";E1();}return 0;}/************************************/void T(){F();T1();}/***********************************/int T1(){if(cur=='*'){cur=fgetc(fp);F();cout<<'*'<<" ";T1();}else if(cur=='/'){cur=fgetc(fp);F();cout<<'/'<<" ";T1();}return 0;}int F(){if((cur<='z'&&cur>='a')||(cur<='Z'&&cur>='A')||cur=='_'){for(int i=0;i<20;i++){str[i]='\0';index=0;}str[index++]=cur;cur=fgetc(fp);while((cur<='z'&&cur>='a')||(cur<='Z'&&cur>='A')||cur=='_'||(cur<='9'&&cur>='0')){str[index++]=cur;cur=fgetc(fp);}cout<<str;cout<<" ";return NULL;}else if (cur<='9'&&cur>='0'){for(int i=0;i<20;i++){str[i]='\0';index=0;}while(cur<='9'&&cur>='0'){str[index++]=cur;cur=fgetc(fp);}if(cur=='.'){str[index++]=cur;cur=fgetc(fp);while(cur<='9'&&cur>='0'){str[index++]=cur;cur=fgetc(fp);}cout<<str;cout<<" ";return NULL;}else if((cur<='z'&&cur>='a')||(cur<='Z'&&cur>='A')||cur=='_'){printf("error6\n");exit(1);}else{cout<<str;cout<<" ";return NULL;}}else if (cur=='('){cur=fgetc(fp);E();if(cur==')'){cur=fgetc(fp);return 0;}else{printf("error3\n");exit (1);}}else{printf("error4\n");exit(1);}return 0;}程序运行结果：（截屏）输入：Source.txt文本((Aa+Bb)*(88.2/3))#输出：2)LL（1）#include <iostream>#include <cstdio>#include <cstdlib>#include <cstring>#include <stack>using namespace std;struct Node1{char vn;char vt;char s[12];}MAP[22];//存储分析预测表每个位置对应的终结符，非终结符，产生式int k;char token[30];int token_index=0;charG[12][12]={"E->TR","R->+TR","R->-TR","R->e","T->FW","W->*FW","W->/FW", "W->e","F->(E)","F->i","F->n"};//存储文法中的产生式,用R代表E',W代表T',e代表空//char VN[6]={'E','R','T','W','F'};//存储非终结符//char VT[9]={'i','n','+','-','*','/','(',')','#'};//存储终结符char Select[12][12]={"(,i,n","+","-","),#","(,i,n","*","/","+,-,),#","(","i","n"};//存储文法中每个产生式对应的select集合charRight[12][8]={"->TR","->+TR","->-TR","->e","->FW","->*FW","->/FW","->e","->( E)","->i","->n"};stack<char> stak,stak1,stak2;char *Find(char vn,char vt){int i;for(i=0;i<k;i++){if(MAP[i].vn==vn&& MAP[i].vt==vt)return MAP[i].s;}return "error";}char *Analyse(char *token){char p,action[10],output[10];int i=1,j,k=0,l_act,m;while(!stak.empty())//判断栈中是否为空，若不空就将栈顶元素与分析表匹配进行相应操作stak.pop();stak.push('#');//栈底标志stak.push('E');//起始符号先入栈printf(" 步骤栈顶元素输入串推导所用产生式或匹配\n");p=stak.top();while(p!='#')//查预测分析表将栈顶元素进行匹配，若栈顶元素与输入串匹配成功则向前匹配，否则生成式反序入栈{printf("%7d ",i++);p=stak.top();//从栈中弹出一个栈顶符号，由p记录并输出stak.pop();printf("%6c ",p);for(j=0,m=0;j<token_index;j++)//将未被匹配的剩余输入串输出output[m++]=token[j];output[m]='\0';printf("%10s",output);if(p==token[k]){ if(p=='#')//若最后一个结束符号匹配说明输入表达式被接受，否则继续匹配{printf(" 接受\n");return "SUCCESS";}printf(" “%c”匹配\n",p);k++;}else{ //将未被匹配的第一个字符与find函数的结果进行比较,在预测分析表中查找相应生成式strcpy(action,Find(p,token[k]));if(strcmp(action,"error")==0){printf(" 没有可用的产生式\n");return "ERROR";}printf(" %c%s\n",p,action);int l_act=strlen(action);if(action[l_act-1]=='e')continue;for(j=l_act-1;j>1;j--)stak.push(action[j]);}}return "ERROR";}int Token(){FILE *fp;char cur;int i,j;fp=fopen("source.txt","r");cur=fgetc(fp);while(cur!=EOF)//把用字母数字表示的输入串转换为token序列的表示方法{if((cur<='z'&&cur>='a')||(cur<='Z'&&cur>='A')||cur=='_'){cur=fgetc(fp);while((cur<='z'&&cur>='a')||(cur<='Z'&&cur>='A')||cur=='_'||(cur<='9'&&cur>='0')){cur=fgetc(fp);} token[token_index++]='i';continue;}else if (cur<='9'&&cur>='0'){while(cur<='9'&&cur>='0')cur=fgetc(fp);if(cur=='.'){cur=fgetc(fp);while(cur<='9'&&cur>='0')cur=fgetc(fp);}token[token_index++]='n';continue;}else{token[token_index++]=cur;cur=fgetc(fp);continue;} }token[token_index]='#';cout<<"把文件中字符串用i表示，数字用n表示，转化后：";for(int index=0;index<=token_index;index++)cout<<token[index];cout<<endl<<endl;return 0;}int main (){int i,j,l,m;for(i=0,k=0;i<11;i++)//通过select集合生成预测分析表{l=strlen(Select[i]);for(j=0;j<l;j+=2){MAP[k].vn=G[i][0];MAP[k].vt=Select[i][j];strcpy(MAP[k].s,Right[i]);k++;}}Token();cout<<"分析过程如下："<<endl;cout<<Analyse(token)<<endl;return 0;}程序运行结果：（截屏）输入：Source.txt文本((Aa+Bb)*(88.2/3))输出：目录第一章总论 ........................................................................................ 错误！未定义书签。