编译原理词法分析器语法分析课程设计范本
编译原理课程设计说明书--词法分析,语法分析,语义分析
编译原理课程设计说明书题目：编译器原型设计与开发院（系）：计算机科学与工程学院专业：计算机科学与技术目录1 引言 (1)1.1 设计概述 (1)1.2 设计目标 (2)1.3 小组分工 (3)2 开发过程 (3)2.1 词法分析 (3)2.1.1 消除白空格以及注释 (3)2.1.2 词法分析 (6)2.2 .语法分析 (8)2.2.1 递归下降手工编码 (8)2.2.2 first集合的计算 (8)2.2.3 左递归消除 (9)2.2.4 selection表自动生成 (10)2.2.5 LL(1)手工编码 (11)2.3 语义分析 (11)2.3.1 表达式求值LR(1) (11)2.3.2 四元式 (13)3 测试过程 (14)4 总结 (19)5 参考文献 (20)6 代码附录 (20)1引言编译程序是现代计算机系统的基本组成部分之一，而且多数计算机系统都配有不止一个高级语言的编译程序，对有些高级语言甚至配置了几个不同性能的编译程序。
从功能上看，一个编译程序就是一个语言翻译程序。
语言翻译程序把一种语言（称作源语言）书写的程序翻译成另一种语言（称作目标语言）的等价程序。
一个编译程序的重要性体现在它使得多数计算机用户不必考虑与机器有关的繁琐细节，使程序员和程序设计专家独立于机器，这对于当今机器的数量和种类持续不断地增长的年代尤为重要。
编译程序完成从源程序到目标程序的翻译工作，是一个复杂的整体的过程。
将编译过程划分成词法分析、语法分析、语义分析、中间代码生成、代码优化和目标代码生成六个阶段。
1.1设计概述编译原理程序结构框图词法分析词法分析是编译过程的第一个阶段。
这个阶段的任务是从左到右有一个字符一个字符地读入源程序，对构成源程序的字符流进行扫描和分解，从而识别出一个个单词（也称单词符号或符号）。
这里所谓的单词是指逻辑上紧密相连的一组字符，这些字符基友具体含义。
比如标识符是由字母字符开头，后跟字母、数字字符的字符序列组成的一种单词。
编译原理课程设计—词法分析器
编译原理课程设计（一）——词法分析器1、题目编写程序实现一个简易的词法分析器。
2、实验目的对一段程序代码进行词法分析，将程序段中的关键字、标识符、常数、运算符、界符按照一定的种别编码分析出来。
3、环境及工具操作系统：windows XP ；使用工具：Microsoft Visual C++ 6.0； 编程语言：C 语言；4、分析程序输入：从文件中读入程序段；程序输出：由单词种别和单词符号的属性值组成的二元式；单词种别通常使用整数编码，编码方式可以有多种，在设计词法分析器之前应确定一种程序处理起来较方便的编码方式。
当一个种别中含有多个单词符号时，在分析出其属于哪个种别的时候应同时给出其单词符号属性，本程序为方便起见，采用单词符号本身来作为其属性，以标识同种别种的不同单词符号。
标识符及关键字的识别：字母开头的字母和数字组成的串是多数编程语言的标识符，所以我们的简易词法分析器中，将标识符定义为这种字母数字串。
当第一个字母为字母且紧接着的字符为数字或字母时，应将其串接在一起为一个单词，直到紧跟着的不在是字母数字时。
由于关键字通常为一个单词，则这样得到的串可能是标识符也可能是关键字，又因为一种语言的关键字通常是有限个，则我们可以构造一个存放所有关键字的表，查询关键字表，可以判断得到的串是否为关键字。
界符和运算符的识别：它们多为当个字符，建立两个分别存放界符合运算符的表，读取字符后，进行查表便可以得出它们的类型。
为方便词法分析器的设计，可以使用状态转换图，根据一种特定的编程语言先设计出其状态转换图才能更好将其用代码实现。
典型状态转换图结构如下：(a)有不含回路含分支的状态节点：对应if …else if …else …语句；(b)有含回路的状态节点：对应while …if …语句。
（b ）5、状态转换图6、程序框架描述程序中编写了以下函数，各个函数实现的作用如下：1. GetChar()：将下一输入的字符读入到全局变量ch中，搜素指示器前移一个字符的位置。
编译原理课程设计教案
编译原理课程设计教案第一章：编译原理概述1.1 编译器的作用与重要性解释编译器将高级语言程序转换为机器语言程序的过程强调编译器在软件开发中的关键角色1.2 编译原理的基本概念介绍编译程序的基本组成部分，如词法分析器、语法分析器、语义分析器、中间代码器、目标代码器和代码优化器等解释源程序、目标程序和中间代码的概念1.3 编译过程的阶段详细介绍编译过程的各个阶段，包括词法分析、语法分析、语义分析、中间代码、代码优化和目标代码强调每个阶段的目标和重要性第二章：词法分析2.1 词法分析的基本概念解释词法分析器的任务和作用介绍词法单位的概念，如标识符、关键字、常量和符号等2.2 词法分析的技术和方法介绍词法分析常用的技术和方法，如有限自动机、正则表达式和词法规则等解释词法分析过程中的扫描线和词法单元的产生过程2.3 词法分析器的实现介绍如何实现一个简单的词法分析器，包括词法规则的定义和词法分析器的构造提供相关的编程练习，让学生通过编写代码实现基本的词法分析功能第三章：语法分析3.1 语法分析的基本概念解释语法分析器的任务和作用介绍语法规则和语法树的概念3.2 语法分析的技术和方法介绍语法分析常用的技术和方法，如递归下降分析法、LL分析法、LR分析法等解释语法分析过程中的分析表和状态机的概念3.3 语法分析器的实现介绍如何实现一个简单的语法分析器，包括语法规则的定义和语法分析器的构造提供相关的编程练习，让学生通过编写代码实现基本的语法分析功能第四章：语义分析4.1 语义分析的基本概念解释语义分析器的任务和作用介绍语义规则和语义错误的概念4.2 语义分析的技术和方法介绍语义分析常用的技术和方法，如类型检查、上下文无关文法分析、语义规则等解释语义分析过程中的语义规则和语义冲突的解决方法4.3 语义分析器的实现介绍如何实现一个简单的语义分析器，包括语义规则的定义和语义分析器的构造提供相关的编程练习，让学生通过编写代码实现基本的语义分析功能第五章：中间代码5.1 中间代码的基本概念解释中间代码器的任务和作用介绍中间代码的概念和中间代码的原则5.2 中间代码的技术和方法介绍中间代码的常用技术和方法，如三地址代码、静态单赋值代码等解释中间代码过程中的基本规则和操作符的转换5.3 中间代码器的实现介绍如何实现一个简单的中间代码器，包括中间代码的定义和中间代码器的构造提供相关的编程练习，让学生通过编写代码实现基本的中间代码功能第六章：代码优化6.1 代码优化的基本概念解释代码优化器的任务和作用介绍代码优化的目标和常见的优化技术6.2 常见代码优化技术详细介绍各种代码优化技术，如常量折叠、死代码消除、循环优化、表达式简化等强调优化技术对提高程序性能的重要性6.3 代码优化器的实现介绍如何实现一个简单的代码优化器，包括优化规则的定义和代码优化器的构造提供相关的编程练习，让学生通过编写代码实现基本的代码优化功能第七章：目标代码7.1 目标代码的基本概念解释目标代码器的任务和作用介绍目标代码的概念和目标代码的原则7.2 目标代码的技术和方法介绍目标代码的常用技术和方法，如寄存器分配、指令调度等解释目标代码过程中的基本规则和操作符的转换7.3 目标代码器的实现介绍如何实现一个简单的目标代码器，包括目标代码的定义和目标代码器的构造提供相关的编程练习，让学生通过编写代码实现基本的目标代码功能第八章：调试技术8.1 调试技术的基本概念解释调试器的作用和重要性介绍调试过程中的常见问题和调试技术8.2 调试器的结构和原理详细介绍调试器的结构和原理，如断点、单步执行、查看变量等功能强调调试技术对发现和修复程序错误的重要性8.3 调试器的实现介绍如何实现一个简单的调试器，包括断点的设置、单步执行、变量查看等功能提供相关的编程练习，让学生通过编写代码实现基本的调试功能第九章：编译器性能评价9.1 编译器性能评价的基本概念解释编译器性能评价的目的和方法介绍编译器性能评价的指标和评价方法9.2 编译器性能评价的指标和评价方法详细介绍编译器性能评价的指标，如执行速度、内存占用、编译时间等介绍常用的编译器性能评价方法和工具9.3 编译器性能评价的实践介绍如何进行编译器性能评价的实践，包括评价指标的选取和评价方法的实施提供相关的实践练习，让学生通过实际操作评价编译器的性能第十章：编译原理应用与发展趋势10.1 编译原理在软件开发中的应用介绍编译原理在软件开发中的应用领域，如解释器设计、即时编译、程序分析等强调编译原理在提高程序性能和开发效率方面的重要性10.2 编译原理的研究现状与未来发展介绍编译原理研究领域的前沿技术和最新研究成果探讨编译原理未来的发展趋势和挑战10.3 编译原理在实践中的应用案例分析分析编译原理在实际项目中的应用案例，如开源编译器项目、商业编译器产品等引导学生思考如何将编译原理应用于实际工程实践中的问题重点和难点解析重点环节一：编译器的作用与重要性编译器作为程序设计语言和计算机硬件之间的桥梁，其作用不可忽视。
编译原理课程设计(词法分析,语法分析,语义分析,代码生成)
#include<cstdio>#include<iostream>#include<cstdlib>#include<fstream>#include<string>#include<cmath>using namespace std;/*********************下面是一些重要数据结构的声明***************************/struct token//词法token结构体{int code;//编码int num;//递增编号token *next;};token *token_head,*token_tail;//token队列struct str//词法string结构体{int num;//编号string word;//字符串内容str *next;};str *string_head,*string_tail;//string队列struct ivan//语法产生式结构体{char left;//产生式的左部string right;//产生式的右部int len;//产生式右部的长度};ivan css[20];//语法20个产生式struct pank//语法action表结构体{char sr;//移进或归约int state;//转到的状态编号};pank action[46][18];//action表int go_to[46][11];//语法go_to表struct ike//语法分析栈结构体，双链{ike *pre;int num;//状态int word;//符号编码ike *next;};ike *stack_head,*stack_tail;//分析栈首尾指针struct L//语义四元式的数据结构{int k;string op;//操作符string op1;//操作数string op2;//操作数string result;//结果L *next;//语义四元式向后指针L *Ltrue;//回填true链向前指针L *Lfalse;//回填false链向前指针};L *L_four_head,*L_four_tail,*L_true_head,*L_false_head;//四元式链，true链，false链struct symb//语义输入时符号表{string word;//变量名称int addr;//变量地址symb *next;};symb *symb_head,*symb_tail;//语义符号链表/*********************下面是与词法分析相关的一些函数的声明***************************/void scan();//按字符读取源文件void cifa_main();//词法分析主程序int judge(char ch);//判断输入字符的类型void out1(char ch);//写入token.txtvoid out3(char ch,string word);//写入string.txtvoid input1(token *temp);//插入结点到队列tokenvoid input3(str *temp);//插入结点到队列stringvoid output();//输出三个队列的内容void outfile();//输出三个队列的内容到相应文件中/*********************下面是与语法分析相关的一些函数的声明***************************/void yufa_main();//语法分析主程序void yufa_initialize();//初始化语法分析数据结构int yufa_SLR1(int a);//语法分析主体部分int ID1(int a);//给输入字符编号，转化成action表列编号string ID10(int i);//给输入字符反编号int ID2(char ch);//给非终结状态编号，转化成go_to表列编号int ID20(char ch);//给非终结状态编号char ID21(int j);//给非终结状态反编号void add(ike *temp);//给ike分析栈链表增加一个结点void del();//给ike分析栈链表删除一个结点/*********************下面是与语义分析相关的一些函数的声明***************************/void yuyi_main(int m);//语义分析主程序void add_L_four(L *temp);//向四元式链中加一个结点void add_L_true(L *temp);//向true链中加一个结点void add_L_false(L *temp);//向false链中加一个结点void add_symb(symb *temp);//向语义符号表链中加一个结点void output_yuyi();//输出中间代码四元式和最后符号表string newop(int m);//把数字变成字符串string id_numtoname(int num);//把编号转换成相应的变量名int lookup(string m);//变量声明检查/*********************下面是一些全局变量的声明***************************/FILE *fp;//文件指针int wordcount;//标志符计数int err;//标志词法分析结果正确或错误int nl;//读取行数int yuyi_linshi;//语义临时变量string E_name,T_name,F_name,M_name,id_name,id1_name,id2_name,errword;//用于归约时名称传递和未声明变量的输出int id_num,id1_num,id2_num,id_left,id_while,id_then,id_do;//用于记录一些特殊的字符位置信息/****************************主程序开始**************************/int main(){cout<<"************************"<<endl;cout<<"* 说明：*"<<endl;cout<<"* 第一部分：词法分析*"<<endl;cout<<"* 第二部分：语法分析*"<<endl;cout<<"* 第三部分：语义分析*"<<endl;cout<<"************************"<<endl;cifa_main();//词法yufa_main();//语法output_yuyi();//语义cout<<endl;system("pause");return(0);}/****************************以上是主程序，以下是词法**************************/void cifa_main(){token_head=new token;token_head->next=NULL;token_tail=new token;token_tail->next=NULL;string_head=new str;string_head->next=NULL;string_tail=new str;string_tail->next=NULL;//初始化三个队列的首尾指针L_four_head=new L;L_four_head->next=NULL;L_four_tail=new L;L_four_tail->k=0;L_four_tail->next=NULL;L_true_head=new L;L_true_head->Ltrue=NULL;L_false_head=new L;L_false_head->Lfalse=NULL;symb_head=new symb;symb_head->next=NULL;symb_tail=new symb;symb_tail->next=NULL;yuyi_linshi=-1;id_num=0;wordcount=0;//初始化字符计数器err=0;//初始化词法分析错误标志nl=1;//初始化读取行数scan();if(err==0){char m;output();cout<<"词法分析正确完成!"<<endl<<endl<<"如果将结果保存到文件中请输入y ，否则请输入其它字母：";cin>>m;cout<<endl;if(m=='y'){outfile();cout<<"结果成功保存在token.txt和sting.txt两个文件中，请打开查看"<<endl;cout<<endl;}}void scan(){cout<<endl;system("pause");cout<<endl;char ch;string word;char document[50];int flag=0;cout<<"请输入源文件路径及名称:";cin>>document;cout<<endl;cout<<"************************"<<endl;cout<<"* 第一部分：词法分析*"<<endl;cout<<"************************"<<endl;if((fp=fopen(document,"rt"))==NULL){err=1;cout<<"无法找到该文件!"<<endl;return;}while(!feof(fp)){word="";ch=fgetc(fp);flag=judge(ch);if(flag==1)out1(ch);else if(flag==3)out3(ch,word);else if(flag==4 || flag==5 ||flag==6)continue;else{cout<<nl<<"行"<<"错误:非法字符! "<<ch<<endl;err=1;}}fclose(fp);}int judge(char ch)int flag=0;if(ch=='=' || ch=='+' || ch=='*' || ch=='>' || ch==':' || ch==';' || ch=='{' || ch=='}' || ch=='(' || ch==')') flag=1;//界符else if(('a'<=ch && ch<='z') || ('A'<=ch && ch<='Z'))flag=3;//字母else if(ch==' ')flag=4;//空格else if(feof(fp))flag=5;//结束else if(ch=='\n'){flag=6;//换行nl++;}elseflag=0;//非法字符return(flag);}void out1(char ch){int id;switch(ch){case '=' : id=1;break;case '+' : id=2;break;case '*' : id=3;break;case '>' : id=4;break;case ':' : id=5;break;case ';' : id=6;break;case '{' : id=7;break;case '}' : id=8;break;case '(' : id=9;break;case ')' : id=10;break;//界符编码default : id=0;}token *temp;temp=new token;temp->code=id;temp->num=-1;temp->next=NULL;input1(temp);return;}void out3(char ch,string word){token *temp;temp=new token;temp->code=-1;temp->num=-1;temp->next=NULL;str *temp1;temp1=new str;temp1->num=-1;temp1->word="";temp1->next=NULL;int flag=0;word=word+ch;ch=fgetc(fp);flag=judge(ch);if(flag==1 || flag==4 || flag==5 || flag==6){if(word=="and" || word=="if" || word=="then" || word=="while" || word=="do" || word=="int") {if(word=="and")temp->code=31;else if(word=="if")temp->code=32;else if(word=="then")temp->code=33;else if(word=="while")temp->code=35;else if(word=="do")temp->code=36;else if(word=="int")temp->code=37;//关键字编码input1(temp);if(flag==1)out1(ch);else if(flag==4 || flag==5 || flag==6)return;}else if(flag==1){wordcount++;temp->code=25;temp->num=wordcount;input1(temp);temp1->num=wordcount;temp1->word=word;input3(temp1);out1(ch);}else if(flag==4 || flag==5 || flag==6){wordcount++;temp->code=25;temp->num=wordcount;input1(temp);temp1->num=wordcount;temp1->word=word;input3(temp1);}return;}else if(flag==2 || flag==3)out3(ch,word);//形成字符串else{err=1;cout<<nl<<"行"<<"错误:非法字符! "<<ch<<endl; return;}}void input1(token *temp){if(token_head->next == NULL){token_head->next=temp;token_tail->next=temp;}else{token_tail->next->next=temp;token_tail->next=temp;}}void input3(str *temp){if(string_head->next == NULL){string_head->next=temp;string_tail->next=temp;}else{string_tail->next->next=temp;string_tail->next=temp;}}void output(){cout<<"token表内容如下："<<endl;token *temp1;temp1=new token;temp1=token_head->next;while(temp1!=NULL){cout<<temp1->code;if(temp1->num == -1){cout<<endl;}else{cout<<" "<<temp1->num<<endl;}temp1=temp1->next;}cout<<"符号表内容如下："<<endl;str *temp3;temp3=new str;temp3=string_head->next;while(temp3!=NULL){cout<<temp3->num<<" "<<temp3->word<<endl; temp3=temp3->next;}}void outfile(){ofstream fout1("token.txt");//写文件ofstream fout3("string.txt");token *temp1;temp1=new token;temp1=token_head->next;while(temp1!=NULL){fout1<<temp1->code;if(temp1->num == -1)fout1<<endl;elsefout1<<" "<<temp1->num<<endl;temp1=temp1->next;}str *temp3;temp3=new str;temp3=string_head->next;while(temp3!=NULL){fout3<<temp3->num<<" "<<temp3->word<<endl;temp3=temp3->next;}}/****************************以上是词法，以下是语法**************************/void yufa_main(){if(err==0){system("pause");cout<<endl;cout<<"************************"<<endl;cout<<"* 第二部分：语法分析*"<<endl;cout<<"************************"<<endl;yufa_initialize();//初始化语法分析数据结构token *temp;temp=new token;temp=token_head->next;int p,q;p=0;q=0;cout<<"语法分析过程如下："<<endl;while(temp!=NULL){int w;w=ID1(temp->code);p=yufa_SLR1(w);if(p==1) break;if(p==0)temp=temp->next;if(temp==NULL) q=1;}//语法分析if(q==1)while(1){p=yufa_SLR1(17);if(p==3) break;}//最后输入$来完成语法分析}}void yufa_initialize(){stack_head=new ike;stack_tail=new ike;stack_head->pre=NULL;stack_head->next=stack_tail;stack_head->num=0;stack_head->word='!';stack_tail->pre=stack_head;stack_tail->next=NULL;//初始化栈分析链表css[0].left='Q';css[0].right="P";css[1].left='P';css[1].right="id()L;R";css[2].left='L';css[2].right="L;D";css[3].left='L';css[3].right="D";css[4].left='D';css[4].right="id:int";css[5].left='E';css[5].right="E+T";css[6].left='E';css[6].right="T";css[7].left='T';css[7].right="T*F";css[8].left='T';css[8].right="F";css[9].left='F';css[9].right="(E)";css[10].left='F';css[10].right="id";css[11].left='B';css[11].right="B and B";css[12].left='B';css[12].right="id>id";css[13].left='M';css[13].right="id=E";css[14].left='S';css[14].right="if B then M";css[15].left='S';css[15].right="while B do M";css[16].left='S';css[16].right="M";css[17].left='N';css[17].right="N;S";css[18].left='N';css[18].right="S";css[19].left='R';css[19].right="{N}";int i,j;for(i=0;i<20;i++){char *css_len;css_len=&css[i].right[0];css[i].len=strlen(css_len);}css[1].len=6;css[4].len=3;css[10].len=1;css[11].len=3;css[12].len=3;css[13].len=3;css[14].len=4;css[15].len=4;//初始化产生式for(i=0;i<46;i++){for(j=0;j<18;j++)action[i][j].sr='#';}//初始化action表for(i=0;i<46;i++){for(j=0;j<11;j++)go_to[i][j]=-1;}//初始化go_to表/****************************以下是给action表和go_to表赋初值************************/action[0][0].sr='s';action[0][0].state=2; action[1][17].sr='@';//结束action[2][1].sr='s';action[2][1].state=3; action[3][2].sr='s';action[3][2].state=4; action[4][0].sr='s';action[4][0].state=5; action[5][4].sr='s';action[5][4].state=6; action[6][11].sr='s';action[6][11].state=7; action[7][3].sr='r';action[7][3].state=4; action[8][3].sr='r';action[8][3].state=3; action[9][3].sr='s';action[9][3].state=10; action[10][0].sr='s';action[10][0].state=5; action[10][9].sr='s';action[10][9].state=13; action[11][17].sr='r';action[11][17].state=1; action[12][3].sr='r';action[12][3].state=2; action[13][0].sr='s';action[13][0].state=14; action[13][13].sr='s';action[13][13].state=23; action[13][15].sr='s';action[13][15].state=27; action[14][8].sr='s';action[14][8].state=15; action[15][0].sr='s';action[15][0].state=36; action[15][1].sr='s';action[15][1].state=41; action[16][6].sr='s';action[16][6].state=43; action[16][3].sr='r';action[16][3].state=13; action[16][10].sr='r';action[16][10].state=13; action[17][3].sr='s';action[17][3].state=19; action[17][10].sr='s';action[17][10].state=18; action[18][17].sr='r';action[18][17].state=19; action[19][0].sr='s';action[19][0].state=14; action[19][13].sr='s';action[19][13].state=23; action[19][15].sr='s';action[19][15].state=27; action[20][3].sr='r';action[20][3].state=17; action[20][10].sr='r';action[20][10].state=17; action[21][3].sr='r';action[21][3].state=18; action[21][10].sr='r';action[21][10].state=18; action[22][3].sr='r';action[22][3].state=16; action[22][10].sr='r';action[22][10].state=16; action[23][0].sr='s';action[23][0].state=31; action[24][12].sr='s';action[24][12].state=34; action[24][14].sr='s';action[24][14].state=25; action[25][0].sr='s';action[25][0].state=14; action[26][3].sr='r';action[26][3].state=14; action[26][10].sr='r';action[26][10].state=14; action[27][0].sr='s';action[27][0].state=31; action[28][12].sr='s';action[28][12].state=34; action[28][16].sr='s';action[28][16].state=29;action[30][3].sr='r';action[30][3].state=15; action[30][10].sr='r';action[30][10].state=15; action[31][7].sr='s';action[31][7].state=32; action[32][0].sr='s';action[32][0].state=33; action[33][12].sr='r';action[33][12].state=12; action[33][14].sr='r';action[33][14].state=12; action[33][16].sr='r';action[33][16].state=12; action[34][0].sr='s';action[34][0].state=31; action[35][12].sr='r';action[35][12].state=11; action[35][14].sr='r';action[35][14].state=11; action[35][16].sr='r';action[35][16].state=11; action[36][2].sr='r';action[36][2].state=10; action[36][3].sr='r';action[36][3].state=10; action[36][5].sr='r';action[36][5].state=10; action[36][6].sr='r';action[36][6].state=10; action[36][10].sr='r';action[36][10].state=10; action[37][2].sr='r';action[37][2].state=8; action[37][3].sr='r';action[37][3].state=8; action[37][5].sr='r';action[37][5].state=8; action[37][6].sr='r';action[37][6].state=8; action[37][10].sr='r';action[37][10].state=8; action[38][2].sr='r';action[38][2].state=6; action[38][3].sr='r';action[38][3].state=6; action[38][5].sr='s';action[38][5].state=39; action[38][6].sr='r';action[38][6].state=6; action[38][10].sr='r';action[38][10].state=6; action[39][0].sr='s';action[39][0].state=36; action[39][1].sr='s';action[39][1].state=41; action[40][2].sr='r';action[40][2].state=7; action[40][3].sr='r';action[40][3].state=7; action[40][5].sr='r';action[40][5].state=7; action[40][6].sr='r';action[40][6].state=7; action[40][10].sr='r';action[40][10].state=7; action[41][0].sr='s';action[41][0].state=36; action[41][1].sr='s';action[41][1].state=41; action[42][2].sr='s';action[42][2].state=45; action[42][6].sr='s';action[42][6].state=43; action[43][0].sr='s';action[43][0].state=36; action[43][1].sr='s';action[43][1].state=41; action[44][2].sr='r';action[44][2].state=5; action[44][3].sr='r';action[44][3].state=5; action[44][5].sr='s';action[44][5].state=39; action[44][6].sr='r';action[44][6].state=5;action[45][2].sr='r';action[45][2].state=9;action[45][3].sr='r';action[45][3].state=9;action[45][5].sr='r';action[45][5].state=9;action[45][6].sr='r';action[45][6].state=9;action[45][10].sr='r';action[45][10].state=9;go_to[0][0]=1;go_to[4][1]=8;go_to[4][9]=9;go_to[10][1]=12;go_to[10][2]=11;go_to[13][7]=22;go_to[13][8]=2 1;go_to[13][10]=17;go_to[15][3]=16;go_to[15][4]=38;go_to[15][5]=37;go_to[19][7]=20;go_to[19][8]=20;go_to[23][6]=24;go_to[2 5][7]=26;go_to[27][6]=28;go_to[29][7]=30;go_to[34][6]=35;go_to[39][5]=40;go_to[41][3]=42;go_to[41][4]=38;go_to[41][5]=37;go_to[4 3][4]=44;go_to[43][5]=37;/****************************action表和go_to表赋初值完毕************************/}int ID1(int i)//按action表，给输入字符编号{int j;j=-1;if(i==25) {j=0;id_num++;}//设置变量名称标志if(i==1) {j=8,id_left=id_num;}//设置产生试左边变量名称标志if(i==2) j=6;if(i==3) j=5;if(i==4) j=7;if(i==5) j=4;if(i==6) j=3;if(i==7) j=9;if(i==8) j=10;if(i==9) j=1;if(i==10) j=2;if(i==31) j=12;if(i==32) j=13;if(i==33) {j=14;id_then=L_four_tail->k+1;}//设置if语句中then位置标志if(i==35) {j=15;id_while=L_four_tail->k+1;}//设置while语句中while位置标志if(i==36) {j=16;id_do=L_four_tail->k+1;}//设置while语句中do位置标志if(i==37) j=11;return(j);}string ID10(int i)//反编号输入字符{string ch;if(i==0) ch="id";if(i==1) ch="(";if(i==2) ch=")";if(i==3) ch=";";if(i==4) ch=":";if(i==5) ch="*";if(i==6) ch="+";if(i==7) ch=">";if(i==8) ch="=";if(i==9) ch="{";if(i==10) ch="}";if(i==11) ch="int";if(i==12) ch="and";if(i==13) ch="if";if(i==14) ch="then";if(i==15) ch="while";if(i==16) ch="do";if(i==17) ch="$";return(ch);}int ID2(char ch)//按go_to表给非终结符编号{int j;j=-1;if(ch=='P') j=0;if(ch=='D') j=1;if(ch=='R') j=2;if(ch=='E') j=3;if(ch=='T') j=4;if(ch=='F') j=5;if(ch=='B') j=6;if(ch=='M') j=7;if(ch=='S') j=8;if(ch=='L') j=9;if(ch=='N') j=10;return(j);}int ID20(char ch)//给非终结符编号{int j;j=-1;if(ch=='P') j=100;if(ch=='D') j=101;if(ch=='R') j=102;if(ch=='E') j=103;if(ch=='T') j=104;if(ch=='F') j=105;if(ch=='B') j=106;if(ch=='M') j=107;if(ch=='S') j=108;if(ch=='L') j=109;if(ch=='N') j=1010;return(j);}char ID21(int j)//反编号非终结符{char ch;if(j==100 || j==0) ch='P';if(j==101 || j==1) ch='D';if(j==102 || j==2) ch='R';if(j==103 || j==3) ch='E';if(j==104 || j==4) ch='T';if(j==105 || j==5) ch='F';if(j==106 || j==6) ch='B';if(j==107 || j==7) ch='M';if(j==108 || j==8) ch='S';if(j==109 || j==9) ch='L';if(j==1010 || j==10) ch='N'; return(ch);}void add(ike *temp)//加一个结点{if(stack_head->next==stack_tail) {temp->pre=stack_head;temp->next=stack_tail;stack_head->next=temp;stack_tail->pre=temp;}else{temp->pre=stack_tail->pre; temp->next=stack_tail;stack_tail->pre->next=temp; stack_tail->pre=temp;}}void del()//删除一个结点{stack_tail->pre->pre->next=stack_tail;stack_tail->pre=stack_tail->pre->pre;}int yufa_SLR1(int w){/*cout<<"当前输入符号："<<ID10(w)<<" ";*/int i,flag=0,state_temp;//flag错误标志，0正常移进，1错误,2归约，3结束char sr_temp;sr_temp=action[stack_tail->pre->num][w].sr;//动作state_temp=action[stack_tail->pre->num][w].state;//状态变化if(sr_temp=='#')//错误动作{flag=1;err=3;cout<<"语法分析出错!"<<endl;}else if(sr_temp=='s')//移进动作{ike *temp;temp=new ike;temp->next=NULL;temp->pre=NULL;temp->word=w;temp->num=state_temp;add(temp);cout/*<<"动作（移进）："*/<<sr_temp<<state_temp<<" "/*<<"状态转为："<<stack_tail->pre->num<<" "<<"栈顶符号："<<ID10(stack_tail->pre->word)*/<<endl;flag=0;}else if(sr_temp=='r')//归约动作{int p=ID2(css[state_temp].left);int q=css[state_temp].len;for(i=0;i<q;i++)del();ike *temp;temp=new ike;temp->next=NULL;temp->pre=NULL;temp->word=ID20(css[state_temp].left);temp->num=go_to[stack_tail->pre->num][p];//查go_to表add(temp);cout/*<<"动作（归约）："*/<<sr_temp<<state_temp<<" "<<css[state_temp].left<<"→"<<css[state_temp].right<<" "/*<<"状态转为："<<stack_tail->pre->num<<" "<<"栈顶符号："<<ID21(stack_tail->pre->word)*/<<endl;flag=2;yuyi_main(state_temp);//在产生树的同时进行语义分析}else if(sr_temp=='@')//结束动作{cout<<"END"/*<<"动作（归约）："<<sr_temp<<state_temp*/<<" "<<css[state_temp].left<<"→"<<css[state_temp].right<<" "/*<<"状态转为："<<stack_tail->pre->num<<" "<<"栈顶符号："<<ID21(stack_tail->pre->word)*/<<endl;flag=3;cout<<"语法分析正确完成!"<<endl;}else//其他意外情况{flag=1;err=3;cout<<"语法分析出错!"<<endl;}return(flag);}/****************************以上是语法，以下是语义**************************/void yuyi_main(int m){L *temp;int k;k=1;temp=new L;temp->op=" ";temp->op1=" ";temp->op2=" ";temp->result="";temp->next=NULL;temp->Ltrue=NULL;temp->Lfalse=NULL;if(m==4)//变量声明时加入符号表链{symb *Stemp;Stemp=new symb;id_name=id_numtoname(id_num);Stemp->word=id_name;Stemp->next=NULL;add_symb(Stemp);}if(m==5)//归约E→E+T{temp->op="+";temp->op1=E_name;temp->op2=T_name;yuyi_linshi++;//申请临时变量E_name="t"+newop(yuyi_linshi); temp->result=E_name;add_L_four(temp);//加一个四元式结点}if(m==6)//归约E→T{E_name=T_name;}if(m==7)//归约T→T*F{temp->op="*";temp->op1=T_name;temp->op2=F_name;yuyi_linshi++;//申请临时变量T_name="t"+newop(yuyi_linshi); temp->result=T_name;add_L_four(temp);//加一个四元式结点}if(m==8)//归约T→F{T_name=F_name;}if(m==9)//归约F→(E){F_name=E_name;}if(m==10)//归约F→id{id_name=id_numtoname(id_num);F_name=id_name;k=lookup(id_name);//检查变量是否声明if(k==0){err=2;errword=id_name;return;}}if(m==12)//归约B→id>id{temp->op="J>";id1_num=id_num-1;id1_name=id_numtoname(id1_num);k=lookup(id1_name);//检查变量是否声明if(k==0){err=2;errword=id1_name;return;}id2_num=id_num;id2_name=id_numtoname(id2_num);k=lookup(id2_name);//检查变量是否声明if(k==0){err=2;errword=id2_name;return;}temp->result="-1";temp->op1=id1_name;temp->op2=id2_name;add_L_four(temp);//加一个四元式结点add_L_true(temp);//加一个true链结点L *temp2;temp2=new L;temp2->op="J";temp2->op1=" ";temp2->op2=" ";temp2->result="-1";add_L_four(temp2);//加一个四元式结点add_L_false(temp2);//加一个false链结点}if(m==13)//归约M→id=E{temp->op="=";temp->op1=E_name;temp->op2=" ";id_name=id_numtoname(id_left);temp->result=id_name;add_L_four(temp);//加一个四元式结点yuyi_linshi=-1;//临时变量开始重新计数}if(m==14)//归约S→if B then M{int a;a=id_then;temp=L_true_head->Ltrue;while(temp!=NULL){temp->result="L"+newop(a);a=temp->k;temp=temp->Ltrue;}a=L_four_tail->k+1;temp=L_false_head->Lfalse;while(temp!=NULL){temp->result="L"+newop(a);temp=temp->Lfalse;}L_true_head->Ltrue=NULL;L_false_head->Lfalse=NULL;//回填并清空true链和false链}if(m==15)//归约S→while B do M{int a;a=id_do;temp=L_true_head->Ltrue;while(temp!=NULL){temp->result="L"+newop(a);a=temp->k;temp=temp->Ltrue;}a=L_four_tail->k+2;temp=L_false_head->Lfalse;while(temp!=NULL){temp->result="L"+newop(a);temp=temp->Lfalse;}L *temp1;temp1=new L;temp1->op="J";temp1->op1=" ";temp1->op2=" ";temp1->next=NULL;temp1->result="L"+newop(id_while);add_L_four(temp1);//加一个四元式结点L_true_head->Ltrue=NULL;L_false_head->Lfalse=NULL;//回填并清空true链和false链}}string newop(int m)//数字变成字符串{int shang,yushu;string chuan,chuan1;shang=m;chuan="";while(1){yushu=shang%10;chuan=chuan+char(48+yushu);shang=shang/10;if(shang==0)break;}int i;char *ch;ch=&chuan[0];chuan1="";for(i=strlen(ch)-1;i>=0;i--)chuan1=chuan1+chuan[i];return(chuan1);}void add_L_four(L *temp)//加一个四元式结点{temp->k=L_four_tail->k+1;if(L_four_head->next == NULL){L_four_head->next=temp;L_four_tail->next=temp;}else{L_four_tail->next->next=temp;L_four_tail->next=temp;}L_four_tail->k=L_four_tail->next->k;}void add_L_true(L *temp)//加一个true链结点{temp->Ltrue=L_true_head->Ltrue;L_true_head->Ltrue=temp;}void add_L_false(L *temp)//加一个false链结点{temp->Lfalse=L_false_head->Lfalse;L_false_head->Lfalse=temp;}void add_symb(symb *temp)//加一个语义符号表链结点{if(symb_head->next == NULL){temp->addr=0;symb_head->next=temp;symb_tail->next=temp;}else{temp->addr=symb_tail->next->addr+4;symb_tail->next->next=temp;symb_tail->next=temp;}}void output_yuyi(){if(err==0)//语义分析正确时的输出{cout<<endl;system("pause");cout<<endl;cout<<"************************"<<endl;cout<<"* 第三部分：语义分析*"<<endl;cout<<"************************"<<endl;cout<<"中间代码如下："<<endl;L *temp;temp=L_four_head->next;while(temp!=NULL){。
编译原理词法语法语义分析器设计(江苏大学版本)
编译技术课程设计班级计算机0802学号3080602049姓名周勇指导老师朱玉全二零一一年七月编译技术课程设计一、目的<<编译技术>>是理论与实践并重的课程，而其实验课要综合运用一、二年级所学的多门课程的内容，用来完成一个小型编译程序。
从而巩固和加强对词法分析、语法分析、语义分析、代码生成和报错处理等理论的认识和理解；培养学生对完整系统的独立分析和设计的能力，进一步培养学生的独立编程能力。
二、任务及要求基本要求：1．词法分析器产生下述小语言的单词序列这个小语言的所有的单词符号，以及它们的种别编码和内部值如下表：对于这个小语言，有几点重要的限制：首先，所有的关键字（如IF﹑WHILE等）都是“保留字”。
所谓的保留字的意思是，用户不得使用它们作为自己定义的标示符。
例如，下面的写法是绝对禁止的： IF（5）=x其次，由于把关键字作为保留字，故可以把关键字作为一类特殊标示符来处理。
也就是说，对于关键字不专设对应的转换图。
但把它们（及其种别编码）预先安排在一张表格中（此表叫作保留字表）。
当转换图识别出一个标识符时，就去查对这张表，确定它是否为一个关键字。
再次，如果关键字、标识符和常数之间没有确定的运算符或界符作间隔，则必须至少用一个空白符作间隔（此时，空白符不再是完全没有意义的了）。
例如，一个条件语句应写为IF i>0 i= 1;而绝对不要写成IFi>0 i=1;因为对于后者，我们的分析器将无条件地将IFI看成一个标识符。
这个小语言的单词符号的状态转换图，如下图：2．语法分析器能识别由加+ 减- 乘* 除/ 乘方^ 括号（）操作数所组成的算术表达式，其文法如下：E→E+T|E-T|TT→T*F|T/F|FF→P^F|Pp→(E)|i使用的算法可以是：预测分析法；递归下降分析法；算符优先分析法；LR分析法等。
3．中间代码生成器产生上述算术表达式的中间代码（四元式序列）较高要求：1．扩充上述小语言的单词；2．增加语法分析器的功能，能识别条件语句和循环语句等；3．增加中间代码生成器的功能，能产生条件语句和循环语句等的中间代码（四元式序列）4．增加报错功能；5．将中间代码翻译成汇编语言。
编译原理课程设计报告C语言词法与语法分析器的实现
编写原理课程设计报告题目:编译原理课程设计C语言词法和语法分析器的实现C-词法和语法分析器的实现1.课程设计目标(1)题目的实用性C语言具有完整语言的基本属性，写C语言的词法分析和语法分析对理解编译原理的相关理论和知识会起到很大的作用。
通过编写C语言词法和语法分析程序，可以对编译原理的相关知识:正则表达式、有限自动机、语法分析等有一个清晰的认识和掌握。
(2)C语言的词法描述①语言的关键词:else if int返回void while的所有关键字都是保留字，必须小写。
②特殊符号:+ - * / < <= > >= == != = ;, ( ) [ ] { } /* */③其他标记是ID和NUM，它们由以下正则表达式定义:ID =字母字母*NUM =数字数字*字母= a|..|z|A|..|Zdigit = 0|..|9注:ID表示标识符，NUM表示数字，letter表示字母，digit表示数字。
小写字母和大写字母是有区别的。
④它由空格、换行符和制表符组成。
空格通常会被忽略。
⑤用常用的C语言符号/*将注释括起来...*/.注释可以放在任何空白位置(也就是注释不能放在标记上)，可以多行。
注释不能嵌套。
(3)规划目标能够正确分析程序的词法和语法。
2.分析和设计(1)设计理念a.词汇分析词法分析的实现主要使用有限自动机理论。
有限自动机可以用来描述识别输入字符串中模式的过程，因此也可以用来构造扫描程序。
词法分析器可以很容易地用有限自动机理论来设计。
b.语法分析语法分析采用递归下降分析法。
递归下降法是语法分析中最容易理解的方法。
其主要原理是根据每个非终结符的产生式结构为其构造相应的解析子程序，其中终结符生成匹配命令，非终结符生成过程调用命令。
这种方法被称为递归子例程下降法或递归下降法，因为语法递归的相应子例程也是递归的。
子程序的结构与产生式的结构几乎相同。
(2)程序流程图主程序流程图:词法分析:语法分析:词汇分析子流程图:语法分析子流程图:3.程序代码实现整个词法与语法程序设计在同一个项目中，包含八个文件，分别是main.cpp、parse.cpp、scan.cpp、util.cpp、scan.h、util.h、globals.h和parse.h，其中scan.cpp和scan.h是词法分析程序。
编译原理词法分析器语法分析课程设计报告书
《编译原理》课程设计院系信息科学与技术学院专业软件工程年级 2011级学号 20112723姓名林苾湲西南交通大学信息科学与技术学院2013年 12月目录课程设计1 词法分析器 (2)1.1 设计题目 (2)1.2 设计容 (2)1.3 设计目的 (2)1.4 设计环境 (2)1.5 需求分析 (2)1.6 概要设计 (2)1.7 详细设计 (4)1.8 编程调试 (5)1.9 测试 (11)1.10 结束语 (13)课程设计2 赋值语句的解释程序设计 (14)2.1 设计题目 (14)2.2 设计容 (14)2.3 设计目的 (14)2.4 设计环境 (14)2.5 需求分析 (15)2.6 概要设计 (16)2.7 详细设计 (16)2.8 编程调试 (24)2.9 测试 (24)2.10 结束语 (25)课程设计一词法分析器设计一、设计题目手工设计c语言的词法分析器（可以是c语言的子集）。
二、设计容处理c语言源程序，过滤掉无用符号，判断源程序中单词的合法性，并分解出正确的单词，以二元组形式存放在文件中。
三、设计目的了解高级语言单词的分类，了解状态图以及如何表示并识别单词规则，掌握状态图到识别程序的编程。
四、设计环境该课程设计包括的硬件和软件条件如下：4.1.硬件（1）Intel Core Duo CPU P8700（2）存4G4.2.软件（1）Window 7 32位操作系统（2）Microsoft Visual Studio c#开发平台4.3.编程语言C#语言五、需求分析5.1.源程序的预处理：源程序中，存在许多编辑用的符号，他们对程序逻辑功能无任何影响。
例如：回车，换行，多余空白符，注释行等。
在词法分析之前，首先要先剔除掉这些符号，使得词法分析更为简单。
5.2.单词符号的识别并判断单词的合法性：将每个单词符号进行不同类别的划分。
单词符号可以划分成5中。
(1)标识符：用户自己定义的名字，常量名，变量名和过程名。
词法分析和语法分析设计编译器编译原理课程设计word精品文档35页
编译原理课程设计报告课题名称：C- Minus词法分析和语法分析设计提交文档学生姓名：X X X提交文档学生学号：XXXXXXXXXX同组成员名单：X X X指导教师姓名：X X指导教师评阅成绩：指导教师评阅意见：提交报告时间：2019年6月10日1.课程设计目标实验建立C-编译器。
只含有扫描程序（scanner）和语法分析（parser）部分。
2.分析与设计C-编译器设计的整体框架，本实验实现扫描处理和语法分析程序（图中粗黑部分）。
2.1 、扫描程序scanner部分2.1.1系统设计思想设计思想：根据DFA图用switch-case结构实现状态转换。
惯用词法：①语言的关键字：else if int return void while②专用符号：+ - * / < <= > >= == != = ; , ( ) [ ] { } /* */③其他标记是ID和NUM，通过下列正则表达式定义：ID = letter letter*NUM = digit digit*letter = a|..|z|A|..|Zdigit = 0|..|9大写和小写字母是有区别的④空格由空白、换行符和制表符组成。
空格通常被忽略，除了它必须分开ID、NUM关键字。
⑤注释用通常的C语言符号/ * . . . * /围起来。
注释可以放在任何空白出现的位置(即注释不能放在标记内)上，且可以超过一行。
注释不能嵌套说明：当输入的字符使DFA到达接受状态的时候，则可以确定一个单词了。
初始状态设置为START，当需要得到下一个token时，取得次token的第一个字符，并且按照DFA与对此字符的类型分析，转换状态。
重复此步骤，直到DONE为止，输出token类型。
当字符为“/”时，状态转换为SLAH再判断下一个字符，如果为“*”则继续转到INCOMMENT，最后以“*”时转到ENDCOMMENT状态，表明是注释，如果其他的则是字符停滞于当前字符，并且输出“/”。
编译原理课程设计报告-词法语法分析器
编译原理课程设计Course Design of Compiling（课程代码3273526）半期题目：词法和语法分析器实验学期：大三第二学期学生班级：2014级软件四班学生学号：18学生姓名：何华均任课教师：丁光耀信息科学与技术学院课程设计1-C语言词法分析器1.题目C语言词法分析2.内容选一个能正常运行的c语言程序，以该程序出现的字符作为单词符号集，不用处理c语言的所有单词符号。
将解析到的单词符号对应的二元组输出到文件中保存可以将扫描缓冲区与输入缓冲区合成一个缓冲区，一次性输入源程序后就可以进行预处理了3.设计目的掌握词法分析算法，设计、编制并调试一个词法分析程序，加深对词法分析原理的理解4.设计环境（电脑语言环境）语言环境:C语言CPU:i7HQ6700内存：8G5.概要设计（单词符号表，状态转换图）词法分析器的结构词法分析程序的功能：输入：所给文法的源程序字符串。
输出：二元组（syn,token或sum）构成的序列。
词法分析程序可以单独为一个程序；也可以作为整个编译程序的一个子程序，当需要一个单词时，就调用此法分析子程序返回一个单词.为便于程序实现,假设每个单词间都有界符或运算符或空格隔开,并引入下面的全局变量及子程序:1) ch 存放最新读进的源程序字符2) strToken 存放构成单词符号的字符串3) Buffer 字符缓冲区4）struct keyType 存放保留字的符号和种别（1）保留字break、case、char、const、int、do、while…（2）运算符和界符= 、+、-、* 、/、%、，、；、（、）、、#各种单词符号对应的种别码状态转换图6.详细设计（数据结构，子程序）算法思想：首先设置3个变量：①strToken用来存放构成单词符号的字符串；②ch用来字符；③struct keyType用来存放单词符号的种别码。
扫描子程序主要部分流程如下图所示。
子程序结构：子程序名功能GETCHAR()读一个字符到ch 中GETBC()读一个非空白字符到ch 中CONCAT()把CHAR 中字符连接到strToken 之后LETTER()判断CHAR 中字符是否为字母7.程序清单eyname) == 0)return Key[i].value;return 0;}void Retract()alue;}else if (ch >= '0'&&ch <= '9') {ConCat();GetChar();while (Digit()) {ConCat();GetChar();}Retract();strcpy, strToken);= 1;}else {ConCat();strcpy, strToken);= Reserve();}return tempkey;}/*主函数*/int main() {行结果E:/作业/编译原理/运行结果九、 实验体会通过本次次法分析设计实验，我加深了对词法分析过程的理解。
编译原理词法分析和语法分析报告+代码(C语言版)[1]
![编译原理词法分析和语法分析报告+代码(C语言版)[1]](https://img.taocdn.com/s3/m/3eed6f446ad97f192279168884868762cbaebb15.png)
词法分析一、实验目的二、设计、编制并调试一个词法分析程序, 加深对词法分析原理的理解。
三、实验要求2.1 待分析的简单的词法（1）关键字:begin if then while do end所有的关键字都是小写。
（2）运算符和界符: = + - * / < <= <> > >= = ; ( ) #（3）其他单词是标识符（ID）和整型常数（SUM）, 通过以下正规式定义：ID = letter (letter | digit)*NUM = digit digit*（4）空格有空白、制表符和换行符组成。
空格一般用来分隔ID.SUM、运算符、界符和关键字, 词法分析阶段通常被忽略。
2.2 各种单词符号对应的种别码:输入: 所给文法的源程序字符串。
输出: 二元组（syn,token或sum）构成的序列。
其中: syn为单词种别码；token为存放的单词自身字符串；sum为整型常数。
例如: 对源程序begin x:=9: if x>9 then x:=2*x+1/3; end #的源文件, 经过词法分析后输出如下序列:(1,begin)(10,x)(18,:=)(11,9)(26,;)(2,if)……三、词法分析程序的算法思想:算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号, 其基本思想是根据扫描到单词符号的第一个字符的种类, 拼出相应的单词符号。
3.1 主程序示意图:主程序示意图如图3-1所示。
其中初始包括以下两个方面:⑴关键字表的初值。
关键字作为特殊标识符处理, 把它们预先安排在一张表格中（称为关键字表）, 当扫描程序识别出标识符时, 查关键字表。
如能查到匹配的单词, 则该单词为关键字, 否则为一般标识符。
关键字表为一个字符串数组, 其描述如下:Char *rwtab[6] = {“begin”, “if”, “then”, “while”, “do”, “end”,};图3-1（2）程序中需要用到的主要变量为syn,token和sum3.2 扫描子程序的算法思想:首先设置3个变量: ①token用来存放构成单词符号的字符串；②sum用来整型单词；③syn 用来存放单词符号的种别码。
编译原理课程设计教案
编译原理课程设计教案一、课程简介1.1 课程背景编译原理是计算机科学与技术领域的基础课程，旨在培养学生对编译器设计和实现的理解。
通过本课程的学习，学生将掌握编译器的基本原理、构造方法和实现技巧。
1.2 课程目标（1）理解编译器的基本概念、工作原理和分类；（2）熟悉源程序的词法分析、语法分析、语义分析、中间代码、目标代码和优化等基本过程；（3）掌握常用的编译器构造方法和技术；（4）能够设计和实现简单的编译器。
二、教学内容2.1 词法分析（1）词法规则的定义和描述；（2）词法分析器的实现方法；（3）词法分析在编译器中的作用和重要性。
2.2 语法分析（1）语法规则的定义和描述；（2）语法分析树的构建方法；（3）常用的语法分析算法及其特点。
2.3 语义分析（1）语义规则的定义和描述；（2）语义分析的方法和技巧；（3）语义分析在编译器中的作用和重要性。
2.4 中间代码（1）中间代码的定义和表示；（2）中间代码的方法和策略；（3）中间代码在编译器中的作用和重要性。
2.5 目标代码和优化（1）目标代码的方法和技巧；（2）代码优化的方法和策略；（3）目标代码和优化在编译器中的作用和重要性。
三、教学方法3.1 讲授法通过讲解编译原理的基本概念、理论和方法，使学生掌握编译器的设计和实现技巧。
3.2 案例分析法分析实际编译器的设计和实现案例，使学生更好地理解编译原理的应用。
3.3 实验法安排实验课程，让学生动手设计和实现简单的编译器组件，提高学生的实际操作能力。
3.4 小组讨论法组织学生进行小组讨论，培养学生的团队合作精神和沟通能力。
四、教学评价4.1 平时成绩包括课堂表现、作业完成情况和小测验成绩，占总评的30%。
4.2 实验成绩包括实验报告和实验演示，占总评的30%。
4.3 期末考试包括理论知识考核和实际操作考核，占总评的40%。
五、教学资源5.1 教材推荐使用《编译原理》教材，为学生提供系统、全面的学习资料。
5.2 课件制作精美、清晰的课件，辅助课堂教学。
(完整版)编译原理毕业课程设计(语法分析程序)
编译原理实验报告题目：对下面的文法对象，使用c语言构造它的预测分析程序；并任意给一算术表达式进行分析测试．分析对象对象定义如下：算术表达式→项｜算术表达式+项｜算术表达式－项项→因式｜项*因式｜项因式因式→变量｜（算术表达式）变量→字母字母→A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z一、分析语法分析部分我们我们采用ｌｌ（１）方法实现，采用ｌｌ（１）方法实现语法发分析要求文法满足以下要求：一个文法能否用确定的自顶向下分析与文法中相同左部的每个产生式右部的开始符号集合有关，当有右部能=*=>ε时则与其左部非终结符的后跟符号集合也有关，此外在产生式中不存在左递归即经过压缩，无左递归，无回溯。
它的基本思想是从左到右扫描源程序，同时从识别符号开始生成句子的最左推导，并只向前查看一个输入符号，便能唯一确定应选择的规则。
下面将确切地定义满足确定的自顶向下分析条件的文法即LL(1)文法及LL(1)文法的判别并介绍如何对非LL(1)文法进行等价变换问题，也就是消除一个文法中的左递归和左公共因子。
注意：一个文法中含有左递归和左公共因子绝对不是LL(1)文法，所以也就不可能用确定的自顶向下分析法，对此结论可以证明。
然而，某些含有左递归和左公共因子的文法在通过等价变换把它们消除以后可能变为LL(1)文法，但需要用LL(1)文法的定义判别，也就是说文法中不含左递归和左公共因子，只是LL(1)文法的必要条件。
LL(1) 文法的定义（5种定义）：一个文法符号串的开始符号集合定义如下：定义 1. 设G=(VT，VN，S，P)是上下文无关文法,α是任意的文法符号串,FIRST(α)是从α推导出的串的开始符号的终结符集合。
FIRST(α)={a|α=*=>aβ,a∈VT，α,β∈V*}若α=*=>ε,则规定ε∈FIRST(α)．当一个文法中相同左部非终结符的右部存在能=*=>ε的情况则必须知道该非终结符的后跟符号的集合中是否含有其它右部开始符号集合的元素。
编译原理课程设计报告词法分析器
一.课程设计题目：词法分析器的实现二.课程设计成员三.课程设计内容和要求设计一个程序，调试、编译，实现词法分析的功能，识别各单词或字符所属类别，并显示在屏幕上。
词法分析器：逐个读入源程序字符并按照构词规则切分成一系列单词。
单词是语言中具有独立意义的最小单位，包括保留字、标识符、运算符、标点符号和常量等。
词法分析是编译过程中的一个阶段，在语法分析前进行。
也可以和语法分析结合在一起作为一遍，由语法分析程序调用词法分析程序来获得当前单词供语法分析使用。
要求：通过词法分析器能够实现以下五种类型如单词等的识别。
(1)关键字"begin","end","if","then","else","while","write","read"等,"do", "call","const","char","until","procedure","repeat"等(2)运算符："+","-","*","/","="等(3)界符："{","}","[","]",";",",",".","(",")",":"等(4)标识符(5)常量四．操作要求首先建立一个或多个文档，此处新建了两个文档，例：07196133.txt文本文档和zhaoxiaodong.txt文本文档，以供选择，各文本文档中都输入有不同的内容，运行程序，出现提示，输入文本文档的名称，即可对文本文档中的内容进行分析，并把分析结果输出显示在屏幕上。
编译原理课程设计-词法分析器(附含源代码).doc
编译原理 -词法分析器的设计一．设计说明及设计要求一般来说，编译程序的整个过程可以划分为五个阶段：词法分析、语法分析、中间代码生成、优化和目标代码生成。
本课程设计即为词法分析阶段。
词法分析阶段是编译过程的第一个阶段。
这个阶段的任务是从左到右一个字符一个字符地读入源程序，对构成源程序的字符流进行扫描和分解，从而识别出一个个单词（也称单词符号或符号）。
如保留字（关键字或基本字）、标志符、常数、算符和界符等等。
二．设计中相关关键字说明1．基本字：也称关键字，如 C 语言中的 if , else , while , do ,for,case,break, return 等。
2．标志符：用来表示各种名字，如常量名、变量名和过程名等。
3．常数：各种类型的常数，如12，，和“ ABC”等。
4．运算符：如+ ，- , * , / ,%, < , > ,<= , >=等。
5．界符，如逗点，冒号，分号，括号，# ，〈〈，〉〉等。
三、程序分析词法分析是编译的第一个阶段，它的主要任务是从左到右逐个字符地对源程序进行扫描，产生一个个单词序列，用以语法分析。
词法分析工作可以是独立的一遍，把字符流的源程序变为单词序列，输出在一个中间文件上，这个文件做为语法分析程序的输入而继续编译过程。
然而，更一般的情况，常将词法分析程序设计成一个子程序，每当语法分析程序需要一个单词时，则调用该子程序。
词法分析程序每得到一次调用，便从源程序文件中读入一些字符，直到识别出一个单词，或说直到下一个单词的第一个字符为止。
四、模块设计下面是程序的流程图五、程序介绍在程序当前目录里建立一个文本文档，取名为 ,所有需要分析的程序都写在此文本文档里，程序的结尾必须以“@”标志符结束。
程序结果输出在同一个目录下，文件名为，此文件为自动生成。
本程序所输出的单词符号采用以下二元式表示：（单词种别，单词自身的值）如程序输出结果(57,"#")(33,"include")(52,"<")(33,"iostream") 等。
编译原理课程设计报告 (语法分析)
对于语义分析，我们给给出的输出文本是在语义分析时候所依次使用的产生式。
八、课程设计小结
成员分工
毛凌霄：词法分析；
王冲：语法分析；
周潇：语义分析；
心得体会
在不到一个星期的时间里，我们从查阅资料、互相讨论，到综合想法、征求老师意见，过得十分充实和紧张，虽然课程设计比我们想象的要困难得多，但是我们也拿出耐心和毅力，获得了最终方案。如今我明白课程设计对我来说的意义，它不仅仅是让我们把所学的理论知识与实践相结合起来，提高自己的实际动手能力和独立思考的能力，也让我学会从各方意见和想法中提取精华，这次设计中的很多地方都是源于和同学的大量讨论获得的，这种讨论对思维的激发和创新让我收获颇多。
char右部符号[MaxRightLenth]；
int右部长度；
}; //声明结构体类型
文法采用上述的结构体数组进行存储。
First集合和Follow集合
因为在SLR(1)中我们要用到非终结符的Follow集合，而求Follow集合的我们又需要非终结符的First集合，所以，我们要先求他的First集合。
(1)、若Ａ->ε，则将ε并入First(A)。
(2)、若Ａ->a，则将a并入First(A)。
(3)、若Ａ->B…..，则将First(B)并入First(A)。
(4)、若Ａ->XB…..或Ａ->Xa…..，且X->ε，则类似于(2)、(3)处理。
Follow
扫描所有右部包含A的产生式，
(1)、若B->xAy，则将First(y)中的非ε终极符并入Follow(A)。
循环IK中的每一项；
循环C中的每一项。
句子识别
FLAG：=TRUE；
编译原理课程设计报告C-语言词法与语法分析器的实现
编译原理课程设计报告课题名称：编译原理课程设计C-语言词法与语法分析器的实现提交文档学生姓名：提交文档学生学号：同组成员名单：指导教师姓名：指导教师评阅成绩：指导教师评阅意见：..提交报告时间：年月日C-词法与语法分析器的实现1.课程设计目标（1）题目实用性C-语言拥有一个完整语言的基本属性，通过编写C-语言的词法分析和语法分析，对于理解编译原理的相关理论和知识有很大的作用。
通过编写C-语言词法和语法分析程序，能够对编译原理的相关知识：正则表达式、有限自动机、语法分析等有一个比较清晰的了解和掌握。
（2）C-语言的词法说明①语言的关键字：else if int return void while所有的关键字都是保留字，并且必须是小写。
②专用符号：+ - * / < <= > >= == != = ; , ( ) [ ] { } /* */③其他标记是ID和NUM，通过下列正则表达式定义：ID = letter letter*NUM = digit digit*letter = a|..|z|A|..|Zdigit = 0|..|9注：ID表示标识符，NUM表示数字，letter表示一个字母，digit表示一个数字。
小写和大写字母是有区别的。
④空格由空白、换行符和制表符组成。
空格通常被忽略。
⑤注释用通常的c语言符号/ * . . . * /围起来。
注释可以放在任何空白出现的位置(即注释不能放在标记内)上，且可以超过一行。
注释不能嵌套。
（3）程序设计目标能够对一个程序正确的进行词法及语法分析。
2.分析与设计（1）设计思想a.词法分析词法分析的实现主要利用有穷自动机理论。
有穷自动机可用作描述在输入串中识别模式的过程，因此也能用作构造扫描程序。
通过有穷自动机理论能够容易的设计出词法分析器。
b.语法分析语法分析采用递归下降分析。
递归下降法是语法分析中最易懂的一种方法。
它的主要原理是，对每个非终结符按其产生式结构构造相应语法分析子程序，其中终结符产生匹配命令，而非终结符则产生过程调用命令。
(完整)编译原理实验报告(词法分析器 语法分析器)
编译原理实验报告实验一一、实验名称：词法分析器的设计二、实验目的：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）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《编译原理词法分析器语法分析课程设计-《编译原理》课程设计院系信息科学与技术学院专业软件工程年级级学号 2723姓名林苾湲西南交通大学信息科学与技术学院12月目录课程设计1 词法分析器 (2)设计题目 (2)设计内容 (2)设计目的 (2)设计环境 (2)需求分析 (2)概要设计 (2)详细设计 (4)编程调试 (5)测试 (11)结束语 (13)课程设计2 赋值语句的解释程序设计 (14)设计题目 (14)设计内容 (14)设计目的 (14)设计环境 (14)需求分析 (15)概要设计 (16)详细设计 (16)编程调试 (24)测试 (24)结束语 (25)课程设计一词法分析器设计一、设计题目手工设计c语言的词法分析器（能够是c语言的子集）。
二、设计内容处理c语言源程序，过滤掉无用符号，判断源程序中单词的合法性，并分解出正确的单词，以二元组形式存放在文件中。
三、设计目的了解高级语言单词的分类，了解状态图以及如何表示并识别单词规则，掌握状态图到识别程序的编程。
四、设计环境该课程设计包括的硬件和软件条件如下：.硬件（1）Intel Core Duo CPU P8700（2）内存4G.软件（1）Window 7 32位操作系统（2）Microsoft Visual Studio c#开发平台.编程语言C#语言五、需求分析.源程序的预处理：源程序中，存在许多编辑用的符号，她们对程序逻辑功能无任何影响。
例如：回车，换行，多余空白符，注释行等。
在词法分析之前，首先要先剔除掉这些符号，使得词法分析更为简单。
.单词符号的识别并判断单词的合法性：将每个单词符号进行不同类别的划分。
单词符号能够划分成5中。
(1)标识符：用户自己定义的名字，常量名，变量名和过程名。
(2)常数：各种类型的常数。
(3) 保留字（关键字）：如if、else、while、int、float 等。
(4) 运算符：如+、-、*、<、>、=等。
(5)界符：如逗号、分号、括号等。
.将所有合法的单词符号转化为便于计算机处理的二元组形式：（单词分类号，单词自身值）；以图形化界面显示出来。
.可选择性地将结果保存到文件中。
六、概要设计．数据类型6.1.1.单词的分类：本词法分析器演示的是C语言的一个子集，故字符集如下：(1)标识符：以字母开头的字母数字串。
(2)整数或浮点型(3)保留字：auto, break, case, char, const, continue,default, do, double, else, enum, extern, float, for,goto, if, int, long, register, return, short, signed, sizeof, static, struct, switch, typedef, union,unsigned, void, volatile, while(4)运算符：+、-、*、/、%、>、<、=、!=、==、<=、>=、++、--、!、&、&&、||；(5)界符：[ ] { } ( ) : ; ‘“ # ,6.1.2.单词二元组：（单词分类号，单词自身值）表单词分类表．词法分析器的结构图词法分析器的结构．部分单词的正规式与状态转换图图部分单词的状态转换图．功能模块表词法分析器的C#程序过程或函数功能表过程或函数名简要功能说明GetTokens()分析源程序得到单个单词并大致区分其类型，并生成二元组GetInput( string get )输入源程序NoWs( string aCopy, intcp )去除源程序中的空格符GetTokenType最终确定标识符和保留字OutPut输出二元组到指定的.txt文件中GetResult输出二元组七、详细设计源程输入缓预处理子扫描缓冲扫描缓冲词法分析子调数返回—．总体流程图图程序总体流程图．主要分支选择算法介绍7.2.1case0情况算法图部分分支流程图八、编程调试主要源代码Normal && ( aCopy[ cp + 1 ] ) ) ) ) {cp++;}tempToken = ( lp, cp - lp );tempType = "2";= tempToken;= tempType;lp = cp = NoWs( aCopy, cp );}xt";if( ( () ) == ) {if( != null ) {FileInfo outFile = new FileInfo( );StreamWriter fw = ();foreach( string tkString in ) {( tkString );}();}}}private void btnsave_Click(object sender, EventArgs e){= "保存分析结果";= "文本文件|*.txt";if (()) =={if != null){FileInfo outFile = new FileInfo;StreamWriter fw = ();foreach (string tkString in{(tkString);}();}}}}}调试调试过程中存在保存不了输出结果的问题。
最后调试发现是由于绝对路径与相对路径的区分。
最后上网搜索解决方法，经过调用C#中提供的文件保存接口来解决保存的问题九、测试1.运行的主界面图运行的主界面2.输入想要分析的c语言源程序图输入源程序3.点击分析的按钮，显示分析后的结果，以二元组形式展示。
图分析结果4.点击保存按钮，弹出选择保存文件的路径和名称图保存过程5.保存后的.txt文档图保存后的文档十、结束语经过这次的课程设计，我学会了很多。
让我学会了如何设计、编制并调试词法分析程序，加深对词法分析原理的理解；熟悉了构造词法分析器的手工方式的相关原理，也对状态图以及如何表示并识别单词规则有了更进一步的了解。
而且在掌握状态图对识别程序的编程上有了更深层次的进步。
除此之外，还复习了高级语言单词的分类，总之，经过这次的实验，从各方面提高了我的编程能力以及解决问题和bug的能力。
但此次的课程设计还存在一定的缺陷，如只实现了c语言子集的词法分析器以及，对于错误的单词无法识别出其错误原因。
因此，我在今后的学习中还需要再接再厉，争取编出更完美的程序。
课程设计二赋值语句的解释程序设计一、设计题目手工设计c语言的赋值语句解释程序（能够是c语言的子集）二、设计内容.要求用算符优先分析方法设计一个分析程序，对输入的赋值语句，输出语句，清除语句进行词法分析、语法分析、表示求值并存储于指定变量中；若存在错误，提示错误相关信息。
.给定文法S->V=E|E|clearE->E+T|E-T|TT->T*F|T/F|FF->(E)|V|cV->i.给定单词种别码表1 单词种别码表.测试数据a=5b=a+10bb+a*aa=a+10三、设计目的1.了解掌握算符优先分析的基本方法；2.理解并处理语法分析中的异常和错误3学会科学思考并解决问题，提高程序设计能力四、设计环境该课程设计包括的硬件和软件条件如下：.硬件（1）Intel Core Duo CPU P8700（2）内存4G.软件（1）Window 7 32位操作系统（2）Microsoft Visual Studio c#开发平台.编程语言C#语言五、需求分析数据分析5.1.1数据输入(1)文法，即定义的语法单位，在进行语法分析时语句的规约必须遵循该文法定义。
(2)算数表示式，如a=5、b=a+10、b5.1.2数据输出(1)四元式语法分析器所输出的分析结果用如下的四元式表示：（操作符，操作数1，操作数2，结果）其中，操作符为文法定义中的=，，+，-，*，/，（，）中的一个。
(2)算符优先关系表。
表2 算符优先关系表(3)变量表，包括变量的名称以及属性值。
(4)赋值表示式的结果输出。
(5)错误提示若语法分析失败，则提示相应的错误信息。
包括：输入错误；变量不存在或已清除；输入非法字符等。
功能分析本课程设计的赋值语句解释器能实现的功能如下(1)从外部输入或导入文法规则和测试的赋值语句、输出语句，清除语句(2)对文法规则、赋值语句、输出语句以及清除语句进行词法分析(3)计算每个非终结符的FIRSTVT和LASTVT，以及她们的算符优先关系表。
(4)在内存中申请一段空间，称为变量表，用于存放变量及其赋值，并按照声明次序给变量添加索引。
(5)把输入的符号一个一个地移进栈里，当栈顶形成某个产生式的一个候选式时，把栈顶的这一部分归约为该产生式的左部符号，重复这一过程直到归约栈中只剩下文法开始的符号。
其中，可归约串包括变量归约、常量归约、运算归约、括号归约、赋值语句、输出语句、清除语句六、概要设计本程序主要分为四个模块，由主函数模块来调用输入串模块，归约栈模块，变量表模块。
其中，各模块的功能说明如下表所示表3 语法分析器的C#程序过程和函数功能表七、详细设计输入控制模块static int in_index;inuct *temp_ip;char instr[40];void in_init(char *in){in_index = 0;strcpy(instr, in);}inuct* in_get_uct(){int in_length = 0;char *input = (char *)malloc(sizeof(char));while(is_space()) {in_index++;}if(is_end()) {return NULL;}if(is_error_char()) {temp_ip = (inuct *)malloc(sizeof(inuct));temp_ip->type = INPUT_ERROR;temp_ip-> = (char *)malloc(sizeof(char) * 11);memcpy(temp_ip->, &instr[in_index], sizeof(char));return temp_ip;}if(is_char()) {while(is_char() || is_num()) {input[in_length++] = instr[in_index];in_index ++;input = (char *)realloc(input, sizeof(char) * (in_length + 1));input[in_length] = '\0';}}if(in_length) {temp_ip = (inuct *)malloc(sizeof(inuct));if(strcmp(input, "clear\0") == 0) {temp_ip->type = CLEAR;return temp_ip;}else if(strcmp(input, "quit") == 0) {temp_ip->type = QUIT;return temp_ip;}else {temp_ip->type = VAR;temp_ip-> = (char *)malloc(sizeof(char) * (in_length + 1));strcpy(temp_ip->, input);return temp_ip;}}while(is_num()) {input[in_length++] = instr[in_index];in_index ++;input = (char *)realloc(input, sizeof(char) * (in_length + 1));input[in_length] = '\0';}if(in_length) {temp_ip = (inuct *)malloc(sizeof(inuct));temp_ip->type = CONST;temp_ip-> = atoi(input);return temp_ip;}if(is_leftbra()) {temp_ip = (inuct *)malloc(sizeof(inuct));temp_ip->type = LEFTBRA;temp_ip-> = (char *)malloc(sizeof(char));strcpy(temp_ip->, "(");in_index++;return temp_ip;}if(is_rightbra()) {temp_ip = (inuct *)malloc(sizeof(inuct));temp_ip->type = RIGHTBRA;temp_ip-> = (char *)malloc(sizeof(char));strcpy(temp_ip->, ")");in_index++;return temp_ip;}if(is_oper() || is_printsign()) {temp_ip = (inuct *)malloc(sizeof(inuct)); if(instr[in_index] == '+') {temp_ip->type = ADD_OPER;} else if(instr[in_index] == '-') {temp_ip->type = SUB_OPER;} else if(instr[in_index] == '*') {temp_ip->type = MULT_OPER;} else if(instr[in_index] == '/') {temp_ip->type = DIV_OPER;} else if(instr[in_index] == '=') {temp_ip->type = ASSIGN_OPER;} else {temp_ip->type = PRINTSIGN;}temp_ip-> = (char *)malloc(sizeof(char)); temp_ip->[0] = instr[in_index++];return temp_ip;}}status is_error_char(){return !(is_num() || is_char() || is_oper() || is_end() || is_leftbra() || is_rightbra() || is_printsign());}status is_num(){if(instr[in_index] >= '0' && instr[in_index] <= '9') {return YES;}return NO;}status is_char(){if(instr[in_index] >= 65 && instr[in_index] <= 90 || instr[in_index] >= 97 && instr[in_index] <= 122 || instr[in_index] == '_'){return YES;}return NO;}ame) == 0) {return i;}}return -1;}int vt_delete(char name[]) {int i, j;for(i = 0; i < length; i++) {if(strcmp(name, vartable[i].name) == 0) { for(j = i; j < length; j++) {vartable[j] = vartable[j+1];}length--;return i;}}return -1;}int vt_clear(){length = 0;return 1;}int vt_get_value(int index){if(index >= length) {return -1;}else {return vartable[index].value; }}int vt_length() {return length;}void vt_print() {int i = 0;printf("name \tvalue\n");for(i = 0; i < length; i++) {printf("%4s\t%5d\n", vartable[i].name, vartable[i].value);}}int vt_delete_by_index(int index){int i;if(index >= length) {return 0;}for(i = index; i < length; i++) {vartable[i] = vartable[i+1];}length--;return 1;}void vt_assign(int index, int value){vartable[index].value = value;}主函数模块int main(){inuct *ip;int error_flag = 0;int quit_flag = 0;int clear_flag = 0;char inputstr[40];int c, i = 0, valid;printf("myshell begin\n");while(1) {error_flag = 0;clear_flag = 0;printf(">");valid = 1;while(c = getchar(), c != '\n') {inputstr[i] = c;i++;}inputstr[i] = '\0';i = 0;in_init(inputstr);instack_init();while(ip = in_get_uct(), ip != NULL) {switch(ip->type) {case VAR:valid = input_stack_push(ip);break;case CONST:valid = input_stack_push(ip);break;case ADD_OPER:case SUB_OPER:case MULT_OPER:case DIV_OPER:case ASSIGN_OPER:case PRINTSIGN:case LEFTBRA:case RIGHTBRA:valid = input_stack_push(ip);break;case CLEAR:if(input_stack_is_empty() && is_end()) { vt_clear();printf("%s\n", "vars are cleared");clear_flag = 1;}else {printf("%s!!!\n", "INPUT ERROR");error_flag = 1;}break;case QUIT:printf("bye bye\n");exit(0);break;case INPUT_ERROR:printf("illegal character:%5s\n", ip->; error_flag = 1;break;default:break;}if(error_flag == 1) {break;}if(valid == 0) {break;}}if(error_flag == 0 && valid == 1 && clear_flag == 0){valid = add_endoper();if(valid == 1) {get_final_res();}}}}八、调试在完成程序之后，发现一个重大问题，没有考虑到除数为零的情况，导致除数为零时程序崩溃。