实验二--语法分析程序的设计-

编译原理实验报告班级姓名：学号：自我评定：实验一词法分析程序实现一、实验目的与要求通过编写和调试一个词法分析程序，掌握在对程序设计语言的源程序进行扫描的过程中，将字符形式的源程序流转化为一个由各类单词符号组成的流的词法分析方法。

二、实验内容根据教学要求并结合学生自己的兴趣和具体情况，从具有代表性的高级程序设计语言的各类典型单词中，选取一个适当大小的子集。

例如，可以完成无符号常数这一类典型单词的识别后，再完成一个尽可能兼顾到各种常数、关键字、标识符和各种运算符的扫描器的设计和实现。

输入：由符合或不符合所规定的单词类别结构的各类单词组成的源程序。

输出：把单词的字符形式的表示翻译成编译器的内部表示，即确定单词串的输出形式。

例如，所输出的每一单词均按形如（CLASS，VALUE）的二元式编码。

对于变量和常数，CLASS字段为相应的类别码；VALUE字段则是该标识符、常数的具体值或在其符号表中登记项的序号（要求在变量名表登记项中存放该标识符的字符串；常数表登记项中则存放该常数的二进制形式）。

对于关键字和运算符，采用一词一类的编码形式；由于采用一词一类的编码方式，所以仅需在二元式的CLASS字段上放置相应的单词的类别码，VALUE字段则为“空”。

另外，为便于查看由词法分析程序所输出的单词串，要求在CLASS字段上放置单词类别的助记符。

三、实现方法与环境词法分析是编译程序的第一个处理阶段，可以通过两种途径来构造词法分析程序。

其一是根据对语言中各类单词的某种描述或定义（如BNF），用手工的方式（例如可用C语言）构造词法分析程序。

一般地，可以根据文法或状态转换图构造相应的状态矩阵，该状态矩阵同控制程序便组成了编译器的词法分析程序；也可以根据文法或状态转换图直接编写词法分析程序。

构造词法分析程序的另外一种途径是所谓的词法分析程序的自动生成，即首先用正规式对语言中的各类单词符号进行词型描述，并分别指出在识别单词时，词法分析程序所应进行的语义处理工作，然后由一个所谓词法分析程序的构造程序对上述信息进行加工。

实验二LL(1)分析法一、实验目的通过完成预测分析法的语法分析程序，了解预测分析法和递归子程序法的区别和联系。

使学生了解语法分析的功能，掌握语法分析程序设计的原理和构造方法，训练学生掌握开发应用程序的基本方法。

有利于提高学生的专业素质，为培养适应社会多方面需要的能力。

二、实验内容及设计原理所谓LL（1）分析法，就是指从左到右扫描输入串（源程序），同时采用最左推导，且对每次直接推导只需向前看一个输入符号，便可确定当前所应当选择的规则。

实现LL（1）分析的程序又称为LL（1）分析程序或LL1（1）分析器。

我们知道一个文法要能进行LL（1）分析，那么这个文法应该满足：无二义性，无左递归，无左公因子。

当文法满足条件后，再分别构造文法每个非终结符的FIRST和FOLLOW集合，然后根据FIRST和FOLLOW集合构造LL（1）分析表，最后利用分析表，根据LL(1)语法分析构造一个分析器。

LL（1）的语法分析程序包含了三个部分，总控程序，预测分析表函数，先进先出的语法分析栈，本程序也是采用了同样的方法进行语法分析，该程序是采用了C++语言来编写，其逻辑结构图如下：LL（1）预测分析程序的总控程序在任何时候都是按STACK栈顶符号X和当前的输入符号a做哪种过程的。

对于任何（X，a），总控程序每次都执行下述三种可能的动作之一：（１）若X = a =‘#’，则宣布分析成功，停止分析过程。

（２）若X = a ‘#’，则把X从STACK栈顶弹出，让a指向下一个输入符号。

（３）若X是一个非终结符，则查看预测分析表M。

若M[A，a]中存放着关于X的一个产生式，那么，首先把X弹出STACK栈顶，然后，把产生式的右部符号串按反序一一弹出STACK栈（若右部符号为ε，则不推什么东西进STACK栈）。

若M[A，a]中存放着“出错标志”，则调用出错诊断程序ERROR。

三、程序结构描述1、定义的变量初始化预测分析表：LL E[8]={"TG","TG","error","error","error","error","error","error"}; LL G[8]={"error","error","null","+TG","-TG","error","error","null"}; LL T[8]={"FS","FS","error","error","error","error","error","error"}; LL S[8]={"error","error","null","null","null","*FS","/FS","null"};LL F[8]={"i","(i)","error","error","error","error","error","error"}; const int MaxLen=10; 初始化栈的长度const int Length=10; 初始化数组长度char Vn[5]={'E','G','T','S','F'}; 非终结符数组char Vt[8]={'i','(',')','+','-','*','/','#'}; 终结符数组char ch,X; /全局变量，ch用于读当前字符，X用于获取栈顶元素char strToken[Length]; 存储规约表达式2、定义的函数class stack 栈的构造及初始化int length(char *c) 输出字符数组的长度void print(int i,char*c) 剩余输入串的输出void run() 分析程序3、LL(1)预测分析程序流程图四、程序源代码及运行结果#include<iostream>using namespace std;const int MaxLen=10; //初始化栈的长度const int Length=10;//初始化数组长度char Vn[5]={'E','G','T','S','F'};//非终结符数组char Vt[8]={'i','(',')','+','-','*','/','#'};//终结符数组char ch,X;//全局变量，ch用于读当前字符，X用于获取栈顶元素char strToken[Length];//存储规约表达式struct LL//ll(1)分析表的构造字初始化{char*c;};LL E[8]={"TG","TG","error","error","error","error","error","error"}; LL G[8]={"error","error","null","+TG","-TG","error","error","null"}; LL T[8]={"FS","FS","error","error","error","error","error","error"}; LL S[8]={"error","error","null","null","null","*FS","/FS","null"};LL F[8]={"i","(i)","error","error","error","error","error","error"}; class stack//栈的构造及初始化{public:stack();//初始化bool empty() const;//是否为空bool full() const;//是否已满bool get_top(char &c)const;//取栈顶元素bool push(const char c);//入栈bool pop();//删除栈顶元素void out();//输出栈中元素~stack(){}//析构private:int count;//栈长度char data[MaxLen];//栈中元素};stack::stack(){count=0;}bool stack::empty() const{if(count==0)return true;return false;}bool stack::full() const{if(count==MaxLen)return true;return false;}bool stack::get_top(char &c)const{if(empty())return false;else{c=data[count-1];return true;}}bool stack::push(const char c){if(full())return false;data[count++]=c;return true;}bool stack::pop(){if(empty())return false;count--;return true;}void stack::out(){for(int i=0;i<count;i++)cout<<data[i];cout<<" ";}int length(char *c){int l=0;for(int i=0;c[i]!='\0';i++)l++;return l;}void print(int i,char*c)//剩余输入串的输出{for(int j=i;j<Length;j++)cout<<c[j];cout<<" ";}void run(){bool flag=true;//循环条件int step=0,point=0;//步骤、指针int len;//长度cout<<"请输入要规约的字符串："<<endl;cin>>strToken;ch=strToken[point++];//读取第一个字符stack s;s.push('#');//栈中数据初始化s.push('E');s.get_top(X);//取栈顶元素cout<<"步骤"<<"分析栈"<<"剩余输入串"<<"所用产生式"<<"动作"<<endl;cout<<step++<<" ";s.out();print(point-1,strToken);cout<<" "<<"初始化"<<endl;while(flag){if((X==Vt[0])||(X==Vt[1])||(X==Vt[2])||(X==Vt[3])||(X==Vt[4])||(X==Vt[5])||(X==V t[6])) //判断是否为终结符（不包括#）{if(X==ch)//终结符,识别，进行下一字符规约{s.pop();s.get_top(X);ch=strToken[point++];cout<<step++<<" ";s.out();print(point-1,strToken);cout<<" "<<"GETNEXT(I)"<<endl;}else{flag=false;cout<<"error!"<<endl;}}else if(X=='#')//规约结束{if(X==ch){cout<<step++<<" ";s.out();print(point-1,strToken);cout<<" "<<X<<"->"<<ch<<" "<<"结束"<<endl;s.pop();flag=false;}else{flag=false;cout<<"error!"<<endl;}}else if(X==Vn[0]) //非终结符E{for(int i=0;i<8;i++)//查分析表if(ch==Vt[i]){if(strcmp(E[i].c,"error")==0)//出错{flag=false;cout<<"error"<<endl;}else{ //对形如X->X1X2的产生式进行入栈操作s.pop();len=length(E[i].c)-1;for(int j=len;j>=0;j--)s.push(E[i].c[j]);cout<<step++<<" ";s.out();print(point-1,strToken);cout<<X<<"->"<<E[i].c<<" "<<"POP,PUSH(";for(int z=len;z>=0;z--)cout<<E[i].c[z];cout<<")"<<endl;s.get_top(X);}}}else if(X==Vn[1]) //同上，处理G{for(int i=0;i<8;i++)if(ch==Vt[i]){if(strcmp(G[i].c,"null")==0){s.pop();cout<<step++<<" ";s.out();print(point-1,strToken);cout<<" "<<X<<"->"<<"ε"<<" "<<"POP"<<endl;s.get_top(X);}else if(strcmp(G[i].c,"error")==0){flag=false;cout<<"error"<<endl;}else{s.pop();len=length(G[i].c)-1;for(int j=len;j>=0;j--)s.push(G[i].c[j]);cout<<step++<<" ";s.out();print(point-1,strToken);cout<<X<<"->"<<G[i].c<<" "<<"POP,PUSH(";for(int z=len;z>=0;z--)cout<<G[i].c[z];cout<<")"<<endl;s.get_top(X);}}}else if(X==Vn[2]) //同上处理T{for(int i=0;i<8;i++)if(ch==Vt[i]){if(strcmp(T[i].c,"error")==0){flag=false;cout<<"error"<<endl;}else{s.pop();len=length(T[i].c)-1;for(int j=len;j>=0;j--)s.push(T[i].c[j]);cout<<step++<<" ";s.out();print(point-1,strToken);cout<<X<<"->"<<T[i].c<<" "<<"POP,PUSH(";for(int z=len;z>=0;z--)cout<<T[i].c[z];cout<<")"<<endl;s.get_top(X);}}}else if(X==Vn[3])//同上处理S{for(int i=0;i<8;i++)if(ch==Vt[i]){if(strcmp(S[i].c,"null")==0){s.pop();cout<<step++<<" ";s.out();print(point-1,strToken);cout<<" "<<X<<"->"<<"ε"<<" "<<"POP"<<endl;s.get_top(X);}else if(strcmp(S[i].c,"error")==0){flag=false;cout<<"error"<<endl;}else{s.pop();len=length(S[i].c)-1;for(int j=len;j>=0;j--)s.push(S[i].c[j]);cout<<step++<<" ";s.out();print(point-1,strToken);cout<<X<<"->"<<S[i].c<<" "<<"POP,PUSH(";for(int z=len;z>=0;z--)cout<<S[i].c[z];cout<<")"<<endl;s.get_top(X);}}}else if(X==Vn[4]) //同上处理F{for(int i=0;i<7;i++)if(ch==Vt[i]){if(strcmp(F[i].c,"error")==0){flag=false;cout<<"error"<<endl;}else{s.pop();len=length(F[i].c)-1;for(int j=len;j>=0;j--)s.push(F[i].c[j]);cout<<step++<<" ";s.out();print(point-1,strToken);cout<<X<<"->"<<F[i].c<<" "<<"POP,PUSH(";for(int z=len;z>=0;z--)cout<<F[i].c[z];cout<<")"<<endl;s.get_top(X);}}}else //出错处理{flag= false;cout<<"error"<<endl;}}}int main(){run();system("pause");return 0;}测试：输入i*i+i#结果：实验二--LL(1)分析法实验报告五、实验总结1. 本实例能利用正确的LL1文法分析表判断任意符号串是否属于该文法的句子；显示了具体分析过程；支持打开、新建、保存分析表；保存分析结果。

《c语⾔程序设计》实验报告（实验-2）《C语⾔程序设计》实验报告2013～2014学年第⼆学期班级姓名学号指导教师实验⼀实验项⽬名称：C程序的运⾏环境和运⾏C程序的⽅法所使⽤的⼯具软件及环境：Visual C++ 6.0⼀、实验⽬的：1．了解在Visual C++ 6.0环境下如何编辑、编译、连接和运⾏⼀个C程序；2．通过运⾏简单的C程序，初步了解C源程序的特点。

⼆、预习内容：教材《C语⾔程序设计教程》第1章。

三、实验内容：1. 在Visual C++ 6.0环境下输⼊并运⾏下⾯的程序：#includeint main( ){printf(＂This is a C program.\n＂);return 0；}2. 在Visual C++ 6.0环境下输⼊下⾯的程序(有语法错误)，编译、连接、调试该程序，直⾄程序⽆语法错误，然后运⾏程序，并观察分析运⾏结果。

#includeint main( ){int a,b,suma=3;b=4;sun=a+b;print(“%d+%d=%d\n”,a,b,sum);return 0;}四、实验结果：1. 运⾏结果(或截图)：This is a C program.Press any key to continue2. (1) 改正后的源程序：#includeint main( ){int a,b,sum;a=3;b=4;sum=a+b;printf("%d+%d=%d\n",a,b,sum);return 0;}(2) 运⾏结果(或截图)：3+4=7五、思考题：1. ⼀个C程序上机的步骤有哪些？答：上级输⼊与编辑源程序—对原程序进⾏编译–与库函数链接–运⾏可执⾏的⽬标程序。

2. 组成C程序的基本单位是函数，⼀个函数包括哪⼏个部分？答：⼀个函数包括两部分：分别为函数头或函数⾸部和函数体。

成绩指导教师签名实验⼆实验项⽬名称：数据类型、运算符和表达式所使⽤的⼯具软件及环境：Visual C++ 6.0⼀、实验⽬的：1．掌握整型、实型与字符型这三种基本类型的概念；2．掌握常量及变量的使⽤⽅法；3. 掌握基本算术运算符及其表达式的使⽤⽅法；4. 掌握++、--运算符、赋值运算符及其表达式的使⽤⽅法。

实验二 C语言中的分支语句程序设计一、实验目的：1.掌握C语言的基本语法;2.掌握C语言的表达式运算及标准库函数的调用方法;3.掌握C语言的基本输入输出语句;4.掌握字符类型、整型和浮点型数据的输入输出及表达式计算方法;5.掌握if语句和switch语句的用法;6.掌握分支程序结构的设计思想;二、实验内容（一）分析程序，用程序验证下面各个表达式的值1、当整型变量a,b,c的值分别为3,4,5时,以下各语句执行后a,b,c的值为多少? (1) if(a>c) {a=b; b=c; c=a;}else {a=c; c=b; b=a;}执行后a,b,c的值为，，(2) if(a<c) a=c;else a=b; c=b; b=a;执行后a,b,c的值为，，(3) if(a!=c) ;else a=c; c=b; b=a;执行后a,b,c的值为，，2、若整数x分别等于95、87、100、43、66、79，57，则以下程序段运行后屏幕显示是什么？switch(x/10){ case 6:case 7: printf("Pass\n"); break;case 8: printf("Good\n"); break;case 9:case 10: printf("V eryGood\n"); break;case 5 : printf("Between Pass and Fail\n");default: printf("Fail\n");}x等于95时,程序段运行后屏幕上显示。

x等于87时,程序段运行后屏幕上显示。

x等于100时,程序段运行后屏幕上显示。

x等于43时,程序段运行后屏幕上显示。

x等于66时,程序段运行后屏幕上显示。

x等于79时,程序段运行后屏幕上显示。

x等于57时,程序段运行后屏幕上显示。

专题3_LL(1)语法分析设计原理与实现李若森 13281132 计科1301一、理论传授语法分析的设计方法和实现原理；LL(1) 分析表的构造；LL(1)分析过程；LL(1)分析器的构造。

二、目标任务实验项目实现LL(1)分析中控制程序（表驱动程序）；完成以下描述算术表达式的 LL(1)文法的LL(1)分析程序。

G[E]:E→TE’E’→ATE’|εT→FT’T’→MFT’|εF→(E)|iA→+|-M→*|/设计说明终结符号i为用户定义的简单变量，即标识符的定义。

加减乘除即运算符。

设计要求(1)输入串应是词法分析的输出二元式序列，即某算术表达式“专题 1”的输出结果，输出为输入串是否为该文法定义的算术表达式的判断结果；(2)LL(1)分析程序应能发现输入串出错；(3)设计两个测试用例（尽可能完备，正确和出错），并给出测试结果。

任务分析重点解决LL(1)表的构造和LL(1)分析器的实现。

三、实现过程实现LL(1)分析器a)将#号放在输入串S的尾部b)S中字符顺序入栈c)反复执行c)，任何时候按栈顶Xm和输入ai依据分析表，执行下述三个动作之一。

构造LL(1)分析表构造LL(1)分析表需要得到文法G[E]的FIRST集和FOLLOW集。

构造FIRST(α)构造FOLLOW(A)构造LL(1)分析表算法根据上述算法可得G[E]的LL(1)分析表，如表3-1所示：表3-1 LL(1)分析表主要数据结构pair<int, string>:用pair<int, string>来存储单个二元组。

该对照表由专题1定义。

map<string, int>:存储离散化后的终结符和非终结符。

vector<string>[][]:存储LL(1)分析表函数定义init:void init();功能：初始化LL(1)分析表，关键字及识别码对照表，离散化（非）终结符传入参数：（无）传出参数：（无）返回值：（无）Parse:bool Parse( const vector<PIS> &vec, int &ncol )；功能：进行该行的语法分析传入参数：vec:该行二元式序列传出参数：emsg:出错信息epos:出错标识符首字符所在位置返回值：是否成功解析。

《编译原理》实验教学大纲一、实验目的和任务编译原理是计算机科学与技术专业的一门重要课程，它主要研究的是将高级语言程序翻译成机器语言程序的方法和技术。

通过本实验课程的学习，旨在使学生掌握编译原理的基本原理和方法，培养学生对编译器结构与构造技术的专门知识和技能，为学生今后进行编译器设计与实现打下基础。

二、实验设备和工具1.计算机和相关硬件设备2. 编程语言的开发环境，如C/C++或Java三、实验内容1.实验一：词法分析器设计与实现a)实验目的：学习词法分析器的原理和设计方法，掌握正则表达式、DFA和NFA的转换方法。

b)实验任务：i.设计并实现一个词法分析器的原型，能够正确地识别出给定的程序中的词法单元。

ii. 使用给定的正则表达式设计并实现识别给定程序中的关键字、标识符、常量等的词法分析器。

2.实验二：语法分析器设计与实现a)实验目的：学习语法分析器的原理和设计方法，掌握上下文无关文法和LR分析表的构造方法。

b)实验任务：i.学习并理解上下文无关文法和LR分析表的构造方法。

ii. 设计并实现一个简单的递归下降语法分析器。

3.实验三：语义分析器设计与实现a)实验目的：学习语义分析器的原理和设计方法，掌握语义动作的定义和处理方法。

b)实验任务：i.学习并理解语义分析器的原理和设计方法。

ii. 设计并实现一个简单的语义分析器，能够对给定的程序进行语义分析和语义动作的处理。

4.实验四：中间代码生成器设计与实现a)实验目的：学习中间代码生成器的原理和设计方法，掌握中间代码的生成和优化方法。

b)实验任务：i.学习并理解中间代码生成器的原理和设计方法。

ii. 设计并实现一个简单的中间代码生成器，能够将给定的程序翻译成中间代码。

5.实验五：目标代码生成器设计与实现a)实验目的：学习目标代码生成器的原理和设计方法，掌握目标代码的生成和优化方法。

b)实验任务：i.学习并理解目标代码生成器的原理和设计方法。

ii. 设计并实现一个简单的目标代码生成器，能够将中间代码翻译成目标代码。

学号《编译原理》实验2：语法分析器设计学生姓名专业、班级指导教师赵璐成绩计算机与信息工程学院2018 年11 月27 日一、实验目的1.理解语法分析程序的功能。

2.熟悉语法分析程序的设计原理和构造方法。

3.掌握递归下降语法分析程序的构造方法。

4.设计一个递归下降的语法分析器，作为实验一构造的词法分析器的下一步编译工具，能语法分析前一步词法分析器输出的单词符号序列。

二、实验要求1.根据书P206给出的简单语言的语法规则，编写C或C++语言源程序，实现针对该简单语言的递归下降的语法分析器；2.独立做实验，输入、调试所编程序；3.实验结束后，根据实验报告模板编写实验报告。

三、实验内容和步骤用Visual C++作为实验开发环境，创建一个Win32 Console Application工程，工程名为你的学号，添加三个文件：（1）存储结构定义：以ParserDef.h和LexerDef.h为文件名；（2）基本操作的算法：以ParserAlgo.h和LexerAlgo.h为文件名；（3）调用基本操作的主程序：以ParserMain.cpp为文件名。

编写程序：（1）文件LexerDef.h和LexerAlgo.h为实验一的内容。

（2）文件ParserDef.h定义语法分析所需的全局变量等。

（3）文件ParserAlgo.h实现对语法规则中各语法成分的分析子算法。

（4）文件ParserMain.cpp实现针对P206简单语言语法规则的递归下降语法分析器。

源程序代码：=============================ParserDef.h================================ int kk;#define _KEY_WORD_END "waiting for your expanding"char * rwtab[]={"begin","if","then","while","do","end",_KEY_WORD_END};char input[255];char token[255]="";int p_input;int p_token;char ch;============================ParserAlgo.h================================ char prog[80];int syn,p,m,n,sum=0;void scaner() {m=0;for(n=0; n<8; n++) token[n]=NULL;ch=prog[p++];while(ch==' ') ch=prog[p++];if((ch>='a' && ch<='z') ||(ch>='A' && ch<='Z')) {while((ch>='a' && ch<='z') ||(ch>='A' && ch<='Z')||(ch>='0' && ch<='9')) {token[m++]=ch;ch=prog[p++];}token[m++]='\0';syn=10;p=p-1; //回退一个字符for(n=0; n<6; n++) {if(strcmp(token,rwtab[n])==0) {syn=n+1;break;}}} else if(ch>='0' && ch<='9') {sum=0;while(ch>='0' && ch<='9') {sum=sum*10+ch-'0';ch=prog[p++];}p=p-1;syn=11;} else {switch(ch) {case '<':m=0;token[m++]=ch;ch=prog[p];if(ch=='>') {syn=21;token[m++]=ch;} else if(ch=='=') {syn=22;token[m++]=ch;} else {syn=20;p=p-1;}p=p+1;token[m]='\0';break;case '>':m=0;token[m++]=ch;ch=prog[p++];if(ch=='=') {syn=24;token[m++]=ch;} else {syn=23;p=p-1;}break;case ':':m=0;token[m++]=ch;ch=prog[p++];if(ch=='=') {syn=18;token[m++]=ch;} else {syn=17;p=p-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=25;token[0]=ch;break;case '#':syn=0;token[0]=ch;break;default:syn=-1;}}}============================ParserMain.cpp============================== #include<stdio.h>#include<stdlib.h>#include<string.h>#include"LexerDef.h"#include"ParserDef.h"#include"LexerAlgo.h"#include"ParserAlgo.h"void lrparser();void yucu();void statement();void expression();void term();void factor();void lrparser() {if (syn==1) { //beginscaner();yucu();if (syn==6) { //endscaner();if (syn==0 && kk==0) printf("success \n");} else {if(kk!=1) printf("error,lose 'end' ! \n");kk=1;}} else {printf("error,lose 'begin' ! \n");kk=1;}return;}void yucu() {statement();while(syn==26) {scaner();statement();}return;}void statement() {if (syn==10) { //为标识符scaner();if (syn==18) { //为:=scaner();expression();} else {printf("error!");kk=1;}} else {printf("error!");kk=1;}return;}void expression() {term();while(syn==13 || syn==14) {scaner();term();}return;}void term() {factor();while(syn==15 || syn==16) {scaner();factor();}return;}void factor() {if(syn==10 || syn==11)scaner(); //为标识符或整常数时，读下一个单词符号else if(syn==27) {scaner();expression();if(syn==28)scaner();else {printf(" ')' 错误\n");kk=1;}} else {printf("表达式错误\n");kk=1;}return;}void main() {p=0;printf("********************语法分析程序***************\n");printf("请输入源程序:\n");do {scanf("%c",&ch);prog[p++]=ch;} while(ch!='#');p=0;scaner();lrparser();printf("语法分析结束！\n");}四、解答下列问题（1）简述该语法分析器的算法思想。

一、实验目的与要求1. 实验目的(1) 理解编译原理的基本概念和流程。

(2) 掌握常用的编译方法和技术。

(3) 熟练使用编译器开发工具。

2. 实验要求(1) 熟悉计算机专业基础知识。

(2) 掌握C/C++编程语言。

(3) 了解基本的编译原理。

二、实验环境1. 硬件环境(1) 计算机一台。

(2) 编译器开发工具（如GCC、Clang等）。

2. 软件环境(1) 操作系统（如Windows、Linux等）。

(2) 文本编辑器或集成开发环境（如Visual Studio、Eclipse等）。

三、实验内容1. 实验一：词法分析(1) 实现一个简单的词法分析器，识别出关键字、标识符、常量等。

(2) 分析输入的程序，输出词法分析结果。

2. 实验二：语法分析(1) 实现一个简单的语法分析器，根据给定的语法规则分析输入的程序。

(2) 分析输入的程序，输出语法分析树。

3. 实验三：语义分析(1) 实现一个简单的语义分析器，检查程序中的语义错误。

(2) 分析输入的程序，输出语义分析结果。

4. 实验四：中间代码(1) 实现一个简单的中间代码器，将转换为中间代码表示。

(2) 对输入的程序进行转换，输出中间代码。

5. 实验五：目标代码(1) 实现一个简单的目标代码器，将中间代码转换为目标代码。

(2) 对输入的中间代码进行转换，输出目标代码。

四、实验步骤与方法1. 实验一：词法分析(1) 编写词法分析器的代码。

(2) 测试并调试词法分析器。

2. 实验二：语法分析(1) 编写语法分析器的代码。

(2) 测试并调试语法分析器。

3. 实验三：语义分析(1) 编写语义分析器的代码。

(2) 测试并调试语义分析器。

4. 实验四：中间代码(1) 编写中间代码器的代码。

(2) 测试并调试中间代码器。

5. 实验五：目标代码(1) 编写目标代码器的代码。

(2) 测试并调试目标代码器。

五、实验注意事项1. 按照实验要求编写代码，注意代码规范和可读性。

编译原理实验⼆：LL（1）语法分析器⼀、实验要求 1. 提取左公因⼦或消除左递归（实现了消除左递归） 2. 递归求First集和Follow集 其它的只要按照课本上的步骤顺序写下来就好（但是代码量超多...），下⾯我贴出实验的⼀些关键代码和算法思想。

⼆、基于预测分析表法的语法分析 2.1 代码结构 2.1.1 Grammar类 功能：主要⽤来处理输⼊的⽂法，包括将⽂法中的终结符和⾮终结符分别存储，检测直接左递归和左公因⼦，消除直接左递归，获得所有⾮终结符的First集，Follow集以及产⽣式的Select集。

#ifndef GRAMMAR_H#define GRAMMAR_H#include <string>#include <cstring>#include <iostream>#include <vector>#include <set>#include <iomanip>#include <algorithm>using namespace std;const int maxn = 110;//产⽣式结构体struct EXP{char left; //左部string right; //右部};class Grammar{public:Grammar(); //构造函数bool isNotTer(char x); //判断是否是终结符int getTer(char x); //获取终结符下标int getNonTer(char x); //获取⾮终结符下标void getFirst(char x); //获取某个⾮终结符的First集void getFollow(char x); //获取某个⾮终结符的Follow集void getSelect(char x); //获取产⽣式的Select集void input(); //输⼊⽂法void scanExp(); //扫描输⼊的产⽣式，检测是否有左递归和左公因⼦void remove(); //消除左递归void solve(); //处理⽂法，获得所有First集，Follow集以及Select集void display(); //打印First集,Follow集,Select集void debug(); //⽤于debug的函数~Grammar(); //析构函数protected:int cnt; //产⽣式数⽬EXP exp[maxn]; //产⽣式集合set<char> First[maxn]; //First集set<char> Follow[maxn]; //Follow集set<char> Select[maxn]; //select集vector<char> ter_copy; //去掉$的终结符vector<char> ter; //终结符vector<char> not_ter; //⾮终结符};#endif 2.1.2 AnalyzTable类 功能：得到预测分析表，判断输⼊的⽂法是否是LL(1)⽂法，⽤预测分析表法判断输⼊的符号串是否符合刚才输⼊的⽂法，并打印出分析过程。

编译原理实验报告实验名称：自底向上语法分析姓名：覃立明专业班级：网工101学号：*********实验二：自底向上语法分析算法程序设计基本要求：完成自底向上语法分析算法的程序设计。

主要内容：设计、调试并测试自底向上语法分析算法程序。

操作要点：程序设计、调试与测试，撰写实验报告。

主要仪器设备：计算机程序代码：/*说明：本程序只针对文法G[E]E→E+T | TT→T*F | FF→( E ) | i*/#include <stdio.h>#include <string.h>//初始化变量char p[10][10]={{'N','+','N'},{'N'},{'N','*','N'},{'N'},{'N','^','N'},{'N'},{'(','N',')'},{'i'}};char pp[10];char m[20]={'+','*','^','i','(',')','#'};char t[20][20]={{'>','<','<','<','<','>','>'},{'>','>','<','<','<','>','>'},{'>','>','<','<','<','>','>'},{'>','>','>','n','n','>','>'},{'<','<','<','<','<','=','n'},{'>','>','>','n','n','>','>'},{'<','<','<','<','<','n','='}};int termin(char arr[20],char c); //函数：判断是否终结符char compare(char xarr[20][20],char c1,char c2);//函数：比较两个终结符之间的优先关系void error(); //函数：报错int rule(char parr[10][10],char pparr[10]);//函数：检查是否存在相应的规则void prn(char stack[50],int pt); //函数：打印运行栈中的数据main (){char str[50];char a,q;char s[50];int k,j,n,i,ii;scanf("%s",str);s[0]='n';n=0;k=1;s[k]='#';do{a=str[n];if (termin(m,a)<0) { error();return(0); }if (termin(m,s[k])>=0) j=k; else j=k-1;if (compare(t,s[j],a)=='>'){do{q=s[j];if ((j-1)<=0){error();return(0);}if (termin(m,s[j-1])>=0) j=j-1; else j=j-2;}while (compare(t,s[j],q)!='<');ii=0; //修改流程图的部分for(i=j+1;i<=k;i++){pp[ii]=s[i];ii++;}pp[ii]='\0';if(rule(p,pp)){k=j+1;s[k]='N';prn(s,k);}else{error();return(0);}}else{if (compare(t,s[j],a)=='<'){k=k+1;s[k]=a;n=n+1;prn(s,k);}else{if (compare(t,s[j],a)!='='){error();return(0);}else{if (compare(t,s[j],'#')=='='){printf("The sentence is legal\n");return(1);}else{k=k+1;s[k]=a;n=n+1;prn(s,k);}}}}}while (str[n]!='\0');printf("The sentence is legal!\n");}int termin(char arr[20],char c){int i=0;int l=0;while (arr[i]!='\0'){if (arr[i]==c){l=1;break;}i=i+1;}if (l==1) return(i); else return(-1); }char compare(char xarr[20][20],char c1,char c2) {int i,j;char r;i=termin(m,c1);j=termin(m,c2);r=xarr[i][j];return(r);}void error(){printf("The sentence is not legal\n!");}int rule(char parr[10][10],char pparr[10]) {int i;for(i=0;i<=7;i++)if(strcmp(pparr,parr[i])==0) return(1); return(0);}void prn(char stack[50],int pt){int i;for(i=1;i<=pt;i++)printf("%c",stack[i]);printf("\n");}运行结果截图：实验体会：此次实验通过算符优先算法设计语法分析程序，借助教材P117图6.8算符优先分析规约过程流程图设计程序。

语法分析器的设计实验报告一、实验内容语法分析程序用LL(1)语法分析方法。

首先输入定义好的文法书写文件(所用的文法可以用LL(1)分析)，先求出所输入的文法的每个非终结符是否能推出空，再分别计算非终结符号的FIRST集合，每个非终结符号的FOLLOW集合，以及每个规则的SELECT集合，并判断任意一个非终结符号的任意两个规则的SELECT集的交集是不是都为空，如果是，则输入文法符合LL(1)文法，可以进行分析。

对于文法：G[E]:E->E+T|TT->T*F|FF->i|(E)分析句子i+i*i是否符合文法。

二、基本思想1、语法分析器实现语法分析是编译过程的核心部分，它的主要任务是按照程序的语法规则，从由词法分析输出的源程序符号串中识别出各类语法成分，同时进行词法检查，为语义分析和代码生成作准备。

这里采用自顶向下的LL(1)分析方法。

语法分析程序的流程图如图5-4所示。

语法分析程序流程图该程序可分为如下几步：（1）读入文法（2）判断正误（3）若无误，判断是否为LL(1)文法（4）若是，构造分析表；（5）由句型判别算法判断输入符号串是为该文法的句型。

三、核心思想该分析程序有15部分组成：（1）首先定义各种需要用到的常量和变量；（2）判断一个字符是否在指定字符串中；（3）读入一个文法；（4）将单个符号或符号串并入另一符号串；（5）求所有能直接推出&的符号；（6）求某一符号能否推出‘& ’；（7）判断读入的文法是否正确；（8）求单个符号的FIRST；（9）求各产生式右部的FIRST；（10）求各产生式左部的FOLLOW；（11）判断读入文法是否为一个LL(1)文法；（12）构造分析表M；（13）句型判别算法；（14）一个用户调用函数；（15）主函数；下面是其中几部分程序段的算法思想：1、求能推出空的非终结符集Ⅰ、实例中求直接推出空的empty集的算法描述如下：void emp(char c){ 参数c为空符号char temp[10];定义临时数组int i;for(i=0;i<=count-1;i++)从文法的第一个产生式开始查找{if 产生式右部第一个符号是空符号并且右部长度为1,then将该条产生式左部符号保存在临时数组temp中将临时数组中的元素合并到记录可推出&符号的数组empty中。

一、概述Python是一种直观、易学、功能强大的计算机编程语言，广泛应用于Web开发、数据分析、人工智能等领域。

本文将介绍Python程序设计的8个实验内容，帮助读者深入了解和掌握Python编程技能。

二、实验一：基础语法1. 学习Python的基本语法，包括变量、数据类型、运算符等。

2. 编写一个简单的Python程序，实现对用户输入的数字进行排序并输出结果。

三、实验二：条件控制和循环1. 掌握Python的条件控制语句，如if-else和switch-case。

2. 熟练运用循环结构，包括for循环和while循环。

3. 编写一个Python程序，实现对用户输入的数字进行判断，输出是否为素数。

四、实验三：函数1. 学习Python函数的定义和调用。

2. 掌握参数传递和返回值的用法。

3. 编写一个Python程序，实现计算两个数的最大公约数和最小公倍数的函数，并进行调用测试。

五、实验四：列表和元组1. 了解Python中列表和元组的概念和用法。

2. 编写一个Python程序，实现对列表和元组的增删改查操作，并输出结果。

六、实验五：字典和集合1. 掌握Python中字典和集合的特点和用法。

2. 编写一个Python程序，实现对字典和集合的遍历和操作，并输出结果。

七、实验六：文件操作1. 学习Python文件的打开、读取和写入操作。

2. 编写一个Python程序，从文件中读取数据并进行处理，然后将结果写入新文件。

八、实验七：异常处理1. 理解Python中异常的概念和分类。

2. 编写一个Python程序，模拟发生异常并进行处理，保证程序正常运行。

九、实验八：面向对象编程1. 学习Python面向对象编程的相关知识，包括类、对象、继承等。

2. 编写一个简单的Python程序，实现一个基本的面向对象应用，并进行测试。

十、结语通过以上8个实验内容的学习，读者可以系统地了解和掌握Python程序设计的基础知识和技能，为进一步深入学习和应用Python打下坚实的基础。

实验二语法分析程序设计[实验目的]：1．了解语法分析的主要任务。

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

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

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

[实验要求]：1.选择一个文法，进行实验，可选的文法包括以下三个：P190 4.8P190 4.9P190 4.102.设计语法分析程序的输出形式（输出应为语法树或推导），一个可以参考的例子，可见图1。

3.编写递归下降语法分析程序（参考P148-149 Topdown parsing byrecursive-descent）,实现基本的递归下降分析器，能够分析任给的符号串是否为该文法所定义的合法句子。

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

4.根据所作业题选项e所给出的input,生成并输出分析过程中所用的产生式序列(show the actions of parser)：1 产生式12 产生式2……5.自已设计一个不合法的句子，作为输出进行分析，给出结果。

[实验过程]本次实验选择的文法为P190 4.8lexp->atom|listatom->number|identifierlist->(lexp-seq)lexp-seq->lexp lexp-seq1.写出实现的算法，并画流程图。

本次实验采用递归下降算法，算法流程图如下图1-1：图1-1 算法流程图2.根据你选择的文法，分析左递归或左因子是否会影响本算法的结果。

会影响本算法的结果。

递归下降分析法要求的文法是LL(1)文法，需要消除左递归和左因子的影响。

如果存在左因子，对相同的字符跳转到不同的函数，无法实现递归。

3.列举实验设计过程中出现的问题及解决的方法（至少3条，选择实验中最困扰的问题）。

1).会多次输出accept/error结果解决方案：所有的递归函数返回类型为int，若accept返回1，error返回0，在main主函数中统一判断输出语句。

编译原理程序设计实验报告——实验题目班级：计算机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))输出：目录第一章总论 ........................................................................................ 错误！未定义书签。

《编译原理》实验指导书实验一词法分析器的设计一、实验目的和要求加深对状态转换图的实现及词法分析器的理解。

熟悉词法分析器的主要算法及实现过程。

要求学生掌握词法分析器的设计过程，并实现词法分析。

二、实验基本内容给出一个简单语言的词法规则，画出状态转换图，并依据状态转换图编制出词法分析程序，能从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类。

并依次输出各个单Error”，然后跳过错误部分继续显示）词法规则如下：三、实验时间：上机三次。

第一次按照自己的思路设计一个程序。

第二、三次在理论课学习后修改程序，使得程序结构更加合理。

四、实验过程和指导：（一）准备：1.阅读课本有关章节（c/c++，数据结构），花一周时间明确语言的语法，写出基本算法以及采用的数据结构和要测试的程序例。

2.初步编制好程序。

3.准备好多组测试数据。

（二）上课上机：将源代码拷贝到机上调试，发现错误，再修改完善。

（三）程序要求：程序输入/输出示例：输入如下一段：main(){/*一个简单的c++程序*/int a,b; //定义变量a = 10;b = a + 20;}要求输出如右图。

要求：(1) 剔除注解符(2) 常数为无符号整数（可增加实型数，字符型数等）（四）练习该实验的目的和思路：程序开始变得复杂起来，可能是大家以前编过的程序中最复杂的，但相对于以后的程序来说还是简单的。

因此要认真把握这个过渡期的练习。

程序规模大概为200行及以上。

通过练习，掌握对字符进行灵活处理的方法。

（五）为了能设计好程序，注意以下事情：1.模块设计：将程序分成合理的多个模块（函数/类），每个模块（类）做具体的同一事情。

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

3.编程时注意编程风格：空行的使用、注释的使用、缩进的使用等。

4．程序设计语言不限，建议使用面向对象技术及可视化编程语言，如C++，VC,JA V A,VJ++等。

编译原理实验指导目录实验1：文法的读入和输出 (3)实验2：词法分析程序的设计 (5)实验3：LL（1）文法构造 (7)实验4：语法分析程序的设计（1） (9)实验5：语法分析程序的设计（2） (11)实验6：逆波兰式的翻译和计算 (15)实验7：语法制导的三地址代码生成 (17)实验1 文法的读入和输出一、实验目的熟悉文法的结构，了解文法在计算机内的表示方法。

二、实验内容1、设计一个表示文法的数据结构；2、从文本文件中读入文法，利用定义的数据结构存放文法，并输出；3、本实验结果还将用于实验3。

三、实验要求1、了解文法定义的4个部分：G（Vn, Vt, S, P）Vn 文法的非终结符号集合，在实验中用大写的英文字母表示；Vt 文法的终结符号集合，在实验中用小写的英文字母表示；S 开始符号，在实验中是Vn集合中的一个元素；P 产生式，分左部和右部，左部为非终结符号中的一个，右部为终结符号或非终结符号组成的字符串，如S->ab|c2、根据文法各个部分的性质，设计一个合理的数据结构用来表示文法，1）若使用C语言编写，则文法可以设计成结构体形式，结构体中应包含上述的4部分，2）若使用C++语言编写，则文法可以设计成文法类形式，类中至少含有4个数据成员，分别表示上述4个部分文法数据结构的具体设计由学生根据自己想法完成，并使用C或C++语言实现设计的数据结构。

3、利用完成的数据结构完成以下功能：1）从文本文件中读入文法（文法事先应写入文本文件）；2）根据文法产生式的结构，分析出文法的4个部分，分别写入定义好的文法数据结构的相应部分；3）整理文法的结构；4）在计算机屏幕或者文本框中输出文法，文法输出按照一个非终结符号一行，开始符号引出的产生式写在第一行，同一个非终结符号的候选式用“|”分隔的方式输出。

四、实验环境PC微机DOS操作系统或Windows 操作系统Turbo C 程序集成环境或Visual C++ 程序集成环境五、实验步骤1、根据文法定义，设计出文法数据结构2、用学生选择的语言，实现文法的数据结构3、编写调试文法读入和输出程序，4、测试程序运行效果：从文本文件中读入一个文法，在屏幕上输出，检查输出结果。

广州大学实验课程建设项目《编译原理实验》实验指导书广州大学信息与机电工程学院计算机系2006年10月目录实验1 Pascal 语言的编译器的使用 3 实验2 词法分析（一） 13 (调试一个词法分析程序)实验3 词法分析（二） 16 (设计、编制并调试一个词法分析程序)实验4 语法分析（一） 19 （调试一个语法分析程序，了解编译程序中LR分析表的作用）实验5 语法分析（二） 22（设计、编制并调试一个语法分析程序）实验6 语义分析 24实验7 编译原理综合实验 26 实验报告示例：词法分析程序 47考试考核方式 53实验一：Pascal 语言的编译器的使用实验目的:调试一个Pascal 语言的编译器，加深对语言编译器的理解实验内容：此程序为Pascal 语言的编译器，支持Proc ，Repeat，If，While，For，Fun函数结构代码的编译，能生成变量表、常量表和汇编程序。

界面如下：图1 Pascal 语言的编译器的使用界面下面给出软件所能编译的代码和编译出的结果。

―――――――――――――――――――――――――――――――――――Proc函数结构代码：vara, b, i: integer;procedure p1(arg1: integer; arg2: integer);begina := arg1 * arg2;end;beginb := 123;p1(3, b);――――――――――――――――――――――――――――――――――－编译状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = unsigned[静], OffPos = 0[2]b = unsigned[静], OffPos = 0[3]i = unsigned[静], OffPos = 0[4]arg1 = unsigned[参], OffPos = 0[5]arg2 = unsigned[参], OffPos = 1常量[0]Number = 123[静], OffPos = 0[1]Number = 3[静], OffPos = 0方法ID = 1, Name = p1, MethodType = 过程, ParamList = (4, 5), DynaV arList = (), Addr = 2 ＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋运行状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = 369[静], OffPos = 0[2]b = 123[静], OffPos = 0[3]i = unsigned[静], OffPos = 0[4]arg1 = unsigned[参], OffPos = 0[5]arg2 = unsigned[参], OffPos = 1汇编语句：0:Goto 0, 71:Return 0, 02:Mov 0, 43:Mov 0, 54:Mul 0, 05:Sto 1, 16:Return 0, 07:LoadConst 0, 08:Sto 0, 29:LoadConst 0, 110:Mov 0, 211:Call 0, 1 ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――For结构代码：vara, b, i: integer;a := 0;for i := 0 to 100 dobegina := a + i;end;end;――――――――――――――――――――――――――――――――――－编译状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = unsigned[静], OffPos = 0[2]b = unsigned[静], OffPos = 0[3]i = unsigned[静], OffPos = 0常量[0]Number = 0[静], OffPos = 0[1]Number = 0[静], OffPos = 0[2]Number = 100[静], OffPos = 0方法ID = 0, Name = ShowMessage, MethodType = 过程, ParamList = (0), DynaV arList = (), Addr = 1＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋运行状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = 5050[静], OffPos = 0[2]b = unsigned[静], OffPos = 0[3]i = 101[静], OffPos = 0汇编语句：0:Goto 0, 21:Return 0, 02:LoadConst 0, 03:Sto 0, 14:LoadConst 0, 15:Sto 0, 36:LoadConst 0, 27:Mov 0, 38:>=? 0, 09:IfFalseGoto 0, 1810:Mov 0, 111:Mov 0, 312:Add 0, 013:Sto 0, 114:Mov 0, 315:IncV ar 0, 116:Sto 0, 317:Goto 0, 6 ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――While函数结构代码：vara, i: integer;begini := 0;a := 0;while i <= 100 dobegina := a +i;i := i +1;end;end;――――――――――――――――――――――――――――――――――－编译状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = unsigned[静], OffPos = 0[2]i = unsigned[静], OffPos = 0常量[0]Number = 0[静], OffPos = 0[1]Number = 0[静], OffPos = 0[2]Number = 100[静], OffPos = 0[3]Number = 1[静], OffPos = 0方法ID = 0, Name = ShowMessage, MethodType = 过程, ParamList = (0), DynaV arList = (), Addr = 1＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋运行状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = 5050[静], OffPos = 0[2]i = 101[静], OffPos = 0汇编语句：0:Goto 0, 21:Return 0, 02:LoadConst 0, 03:Sto 0, 24:LoadConst 0, 15:Sto 0, 16:Mov 0, 27:LoadConst 0, 28:<=? 0, 09:IfFalseGoto 0, 1910:Mov 0, 111:Mov 0, 212:Add 0, 013:Sto 0, 114:Mov 0, 215:LoadConst 0, 316:Add 0, 017:Sto 0, 218:Goto 0, 6 ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――Repeat函数结构代码：vara, i: integer;begina := 0;i := 0;repeata := a + i;i := i + 1;until i > 100;end; ――――――――――――――――――――――――――――――――――－编译状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = unsigned[静], OffPos = 0[2]i = unsigned[静], OffPos = 0常量[0]Number = 0[静], OffPos = 0[1]Number = 0[静], OffPos = 0[2]Number = 1[静], OffPos = 0[3]Number = 100[静], OffPos = 0方法ID = 0, Name = ShowMessage, MethodType = 过程, ParamList = (0), DynaV arList = (), Addr = 1＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋运行状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = 5050[静], OffPos = 0[2]i = 101[静], OffPos = 0汇编语句：0:Goto 0, 21:Return 0, 02:LoadConst 0, 03:Sto 0, 14:LoadConst 0, 15:Sto 0, 26:Mov 0, 17:Mov 0, 28:Add 0, 09:Sto 0, 110:Mov 0, 211:LoadConst 0, 212:Add 0, 013:Sto 0, 214:Mov 0, 215:LoadConst 0, 316:>? 0, 017:IfFalseGoto 0, 6 ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――Fun函数结构代码：vara, i: integer;function fun1(arg1, arg2: integer): integer;beginResult := arg1 + arg2;end;begina := 0;for i := 1 to 100 dobegina := fun1(a, i);end;end;――――――――――――――――――――――――――――――――――－编译状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = unsigned[静], OffPos = 0[2]i = unsigned[静], OffPos = 0[3]arg1 = unsigned[参], OffPos = 0[4]arg2 = unsigned[参], OffPos = 1[5]Result = unsigned[动], OffPos = 2常量[0]Number = 0[静], OffPos = 0[1]Number = 1[静], OffPos = 0[2]Number = 100[静], OffPos = 0方法ID = 1, Name = fun1, MethodType = 函数, ParamList = (3, 4), DynaV arList = (5), Addr = 2 ＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋运行状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = 5050[静], OffPos = 0[2]i = 101[静], OffPos = 0[3]arg1 = unsigned[参], OffPos = 0[4]arg2 = unsigned[参], OffPos = 1[5]Result = unsigned[动], OffPos = 2汇编语句：0:Goto 0, 71:Return 0, 02:Mov 0, 33:Mov 0, 44:Add 0, 05:Sto 0, 56:Return 0, 07:LoadConst 0, 08:Sto 0, 19:LoadConst 0, 110:Sto 0, 211:LoadConst 0, 212:Mov 0, 213:>=? 0, 014:IfFalseGoto 0, 2315:Mov 0, 116:Mov 0, 217:Call 0, 118:Sto 0, 119:Mov 0, 220:IncV ar 0, 121:Sto 0, 222:Goto 0, 11 ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――If 结构代码：vara, i: integer;begina := 2;if a = 1 thenbegini := 10;endelse begini := 100;end;end;――――――――――――――――――――――――――――――――――－编译状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = unsigned[静], OffPos = 0[2]i = unsigned[静], OffPos = 0常量[0]Number = 2[静], OffPos = 0[1]Number = 1[静], OffPos = 0[2]Number = 10[静], OffPos = 0[3]Number = 100[静], OffPos = 0方法ID = 0, Name = ShowMessage, MethodType = 过程, ParamList = (0), DynaV arList = (), Addr = 1 ＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋运行状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = 2[静], OffPos = 0[2]i = 100[静], OffPos = 0汇编语句：0:Goto 0, 21:Return 0, 02:LoadConst 0, 03:Sto 0, 14:Mov 0, 15:LoadConst 0, 16:=? 0, 07:IfFalseGoto 0, 118:LoadConst 0, 29:Sto 0, 210:Goto 0, 1311:LoadConst 0, 312:Sto 0, 2 ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――递归结构代码：vara, b: integer;function f1(arg: integer): integer;beginif arg <= 1 thenbeginResult := 1;endelse beginResult := arg * f1(arg - 1);end;end;begina := 10;b := f1(a);ShowMessage(b);end; ――――――――――――――――――――――――――――――――――－编译状态下：变量[0]str = unsigned[参], OffPos = 0[1]a = unsigned[静], OffPos = 0[2]b = unsigned[静], OffPos = 0[3]arg = unsigned[参], OffPos = 0[4]Result = unsigned[动], OffPos = 1常量[0]Number = 1[静], OffPos = 0[1]Number = 1[静], OffPos = 0[2]Number = 1[静], OffPos = 0[3]Number = 10[静], OffPos = 0方法ID = 1, Name = f1, MethodType = 函数, ParamList = (3), DynaV arList = (4), Addr = 2 ＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋＋运行状态下：变量：无汇编语句：Goto 0, 171:Return 0, 02:Mov 0, 33:LoadConst 0, 04:<=? 0, 05:IfFalseGoto 0, 96:LoadConst 0, 17:Sto 0, 48:Goto 0, 169:Mov 0, 310:Mov 0, 311:LoadConst 0, 212:Sub 0, 013:Call 0, 114:Mul 0, 015:Sto 0, 416:Return 0, 017:LoadConst 0, 318:Sto 0, 119:Mov 0, 120:Call 0, 121:Sto 0, 222:Mov 0, 223:Call 0, 0 ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――实验二：词法分析（一）实验目的:调试一个词法分析程序，加深对词法分析原理的理解实验内容：（1）设一小型编译程序关于高级语言有如下的规定：高级语言程序具有四种基本结构：顺序结构﹑选择结构﹑循环结构和过程。

杭州电子科技大学班级: 12052312 专业: 计算机科学与技术实验报告【实验名称】实验二语法分析一. 实验目的编写一个语法分析程序, 实现对词法分析程序所提供的单词序列的语法检查和结构分析。

二. 实验内容利用编程语言实现语法分析程序, 并对简单语言进行语法分析。

2.1 待分析的简单语言的语法用扩充的BNF表示如下:⑴<程序>: : =begin<语句串>end⑵<语句串>: : =<语句>{；<语句>}⑶<语句>: : =<赋值语句>⑷<赋值语句>: : =ID: =<表达式>⑸<表达式>: : =<项>{+<项> | -<项>}⑹<项>: : =<因子>{*<因子> | /<因子>⑺<因子>: : =ID | NUM | （<表达式>）2.2 实验要求说明输入单词串, 以“#”结束, 如果是文法正确的句子, 则输出成功信息, 打印“success”, 否则输出“error”。

例如:输入begin a:=9; x:=2*3; b:=a+x end #输出success！输入x:=a+b*c end #输出error测试以上输入的分析, 并完成实验报告。

2.3 语法分析程序的算法思想（1）主程序示意图如图2-1所示。

图2-1 语法分析主程序示意图（2）递归下降分析程序示意图如图2-2所示。

（3）语句串分析过程示意图如图2-3所示。

图2-3 语句串分析示意图图2-2 递归下降分析程序示意图（4）statement 语句分析程序流程如图2-4.2-5.2-6.2-7所示。

图2-4 statement 语句分析函数示意图 图2-5 expression 表达式分析函数示意图图2-7 factor 分析过程示意图三．个人心得一、 通过该实验, 主要有以下几方面收获: 二、 对实验原理有更深的理解。

编译原理实验报告实验一一、实验名称：词法分析器的设计二、实验目的：1，词法分析器能够识别简单语言的单词符号2，识别出并输出简单语言的基本字。

标示符。

无符号整数.运算符.和界符。

三、实验要求：给出一个简单语言单词符号的种别编码词法分析器四、实验原理:1、词法分析程序的算法思想算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号，其基本思想是根据扫描到单词符号的第一个字符的种类，拼出相应的单词符号.2、程序流程图(1）主程序（2）扫描子程序3、各种单词符号对应的种别码五、实验内容:1、实验分析编写程序时，先定义几个全局变量a[]、token[]（均为字符串数组)，c,s( char型)，i,j,k（int型），a［］用来存放输入的字符串,token[]另一个则用来帮助识别单词符号,s用来表示正在分析的字符.字符串输入之后，逐个分析输入字符,判断其是否‘#’,若是表示字符串输入分析完毕，结束分析程序,若否则通过int digit(char c）、int letter(char c）判断其是数字，字符还是算术符,分别为用以判断数字或字符的情况，算术符的判断可以在switch语句中进行，还要通过函数int lookup(char token［])来判断标识符和保留字。

2 实验词法分析器源程序:＃include 〈stdio.h〉＃include <math.h>#include <string。

h>int i,j,k;char c,s,a［20]，token[20]=｛’0’｝;int letter(char s){if（(s〉=97)&&（s〈=122）) return(1);else return（0);｝int digit（char s）｛if（(s〉=48）＆＆（s<=57）) return(1)；else return(0);}void get(){s=a［i];i=i+1；｝void retract()｛i=i-1；}int lookup（char token[20］)｛if（strcmp（token，"while"）==0） return（1）;else if(strcmp(token,"if"）==0) return（2）;else if(strcmp(token,"else”）==0） return(3）;else if（strcmp（token，"switch”)==0） return(4）；else if（strcmp（token,"case")==0） return（5）;else return（0）;｝void main(）｛printf（”please input string ：\n"）；i=0;do{i=i+1；scanf("%c",＆a［i]）;｝while（a[i］!=’#’)；i=1;j=0;get();while(s!=’#')｛ memset(token，0，20);switch（s)｛case 'a':case ’b'：case ’c'：case ’d':case ’e’：case ’f’:case 'g’:case ’h'：case 'i'：case ’j'：case 'k’:case ’l':case 'm’：case 'n':case ’o'：case ’p'：case ’q’：case 'r’:case 's’：case 't’:case ’u’：case ’v’:case ’w’:case ’x'：case ’y':case ’z’：while（letter(s）||digit(s)）{token[j］=s;j=j+1；get()；｝retract();k=lookup（token）;if（k==0)printf（"（%d,％s）”,6,token）;else printf("（%d,—)"，k);break;case ’0':case ’1’:case ’2'：case ’3':case '4’：case '5’：case ’6'：case ’7’：case ’8’:case '9’：while（digit(s）)｛token[j]=s;j=j+1；get（）;｝retract(）;printf(”％d,％s",7,token）；break;case '+'：printf(”（’+',NULL)”）；break;case ’-':printf("（’-'，null）"）;break；case ’＊':printf（”（'＊’，null）"）;break;case '<':get()；if(s=='=’） printf（”（relop,LE)”）；else｛retract(）；printf（"（relop，LT)"）;｝break;case ’='：get（）;if(s=='=’）printf（"(relop,EQ)"）；else{retract（）；printf(”('=',null）”)；｝break；case ’；'：printf（”（；,null)")；break；case ' ’：break；default:printf（"！\n”)；}j=0;get(）；｝ }六：实验结果：实验二一、实验名称：语法分析器的设计二、实验目的：用C语言编写对一个算术表达式实现语法分析的语法分析程序，并以四元式的形式输出，以加深对语法语义分析原理的理解,掌握语法分析程序的实现方法和技术.三、实验原理：1、算术表达式语法分析程序的算法思想首先通过关系图法构造出终结符间的左右优先函数f(a)，g(a）。