编译原理：语义分析实验
编译原理语法分析实验报告
编译原理语法分析实验报告编译原理语法分析实验报告引言编译原理是计算机科学中的重要课程，它研究的是如何将高级语言转化为机器语言的过程。
语法分析是编译过程中的一个关键步骤，它负责将输入的源代码转化为抽象语法树，为后续的语义分析和代码生成提供便利。
本实验旨在通过实践，加深对语法分析的理解，并掌握常见的语法分析算法。
实验环境本次实验使用的是Python编程语言，因为Python具有简洁的语法和强大的库支持，非常适合用于编译原理的实验。
实验步骤1. 词法分析在进行语法分析之前，需要先进行词法分析，将源代码划分为一个个的词法单元。
词法分析器的实现可以使用正则表达式或有限自动机等方式。
在本实验中，我们选择使用正则表达式来进行词法分析。
2. 文法定义在进行语法分析之前，需要先定义源代码的文法。
文法是一种形式化的表示，它描述了源代码中各个语法成分之间的关系。
常见的文法表示方法有巴科斯范式（BNF）和扩展巴科斯范式（EBNF）。
在本实验中，我们选择使用BNF来表示文法。
3. 自顶向下语法分析自顶向下语法分析是一种基于产生式的语法分析方法，它从文法的起始符号开始，逐步展开产生式，直到生成目标字符串。
自顶向下语法分析的关键是选择合适的产生式进行展开。
在本实验中，我们选择使用递归下降分析法进行自顶向下语法分析。
4. 自底向上语法分析自底向上语法分析是一种基于移进-归约的语法分析方法，它从输入串的左端开始，逐步将输入符号移入分析栈，并根据产生式进行归约。
自底向上语法分析的关键是选择合适的归约规则。
在本实验中，我们选择使用LR(1)分析法进行自底向上语法分析。
实验结果经过实验，我们成功实现了自顶向下和自底向上两种语法分析算法，并对比了它们的优缺点。
自顶向下语法分析的优点是易于理解和实现，可以直接根据产生式进行展开，但缺点是对左递归和回溯的处理比较困难，而且效率较低。
自底向上语法分析的优点是可以处理任意文法，对左递归和回溯的处理较为方便，而且效率较高，但缺点是实现相对复杂，需要构建分析表和使用分析栈。
北邮 编译原理 语义分析实验报告
编译原理第六章语义分析目录1. 实验题目和要求 (2)2. 实验分析和思考 (3)3. 翻译方案 (4)4. LR实现自底向上分析（摘自语法分析实验） (5)4.1.构造识别所有活前缀的DFA (5)5.1. 扩充分析栈 ................................................................................................................ 7 5.2. 改造分析程序 ............................................................................................................ 7 5.3. 编程实现 .................................................................................................................... 76.运行结果截图： (13)1. 实验题目和要求题目：语义分析程序的设计与实现。
实验内容：编写语义分析程序，实现对算术表达式的类型检查和求值。
要求所分析算术表达式由如下的文法产生。
numE idF F F T F T T T T E T E E |)(||/|*||→→-+→ 实验要求：用自底向上的语法制导翻译技术实现对表达式的分析和翻译。
(1) 写出满足要求的语法制导定义或翻译方案。
(2) 编写分析程序，实现对表达式的类型进行检查和求值，并输出： ① 分析过程中所有产生式。
② 识别出的表达式的类型。
③ 识别出的表达式的值。
(3) 实验方法：可以选用以下两种方法之一。
① 自己编写分析程序。
② 利用YACC 自动生成工具。
2.实验分析和思考由于要求进行类型检查和求值，所以可以定义两个综合属性，一个记录值一个记录类型，存放在结构中，一并传入传出。
编译原理实验报告 语义分析
.编译原理课程实验报告实验3：语义分析. .. ...要求：对如下工作进行展开描核心数据结构的设(1Nod本程序使用了两个新的实体类，分别I的属性I是标识符里面也包含了该标识符在本程序中存储的地址和长度等信息I下/privat String name;/基本类privat String type/起始地privatin offset/长in length privat/该数组各维的长publi List<Integer> arr_length得/变量的维度可以根arr_length.size(的属性如下Nod是语法生成树的节点Nod节点/privat String nam父节/privat Node fathe/子节publi List<Node>son/属Map<String,String>attribut publi使用哈希表这是因为各个节点的属性不是统一的的类型是哈Ma其atrribut以方便地创建、使用属性主要功能函数说(2因为语义分析过程与语法分析同步进此次试验的语义分析部分并没有新的功能函数文法符号匹配的过程中，插入语义的，代码都是在第二次第二次实验的基础上，LL(l的功能发作代码。
所以，只有句法分析函analysis(List<Token> token_list了变化，添加了语义分析的功能，其他函数功能基本与实验二相同(3程序核心部分的程序流程图..是否否是否是3-1图四、实验结果及分析得分..要求：对实验结果进行描述和分析，基本内容包括针对一测试程序输出其语义分析结果输出针对此测试程序对应的语义错误报告输出针对此测试程序经过语义分析后的符号表对实验结果进行分析注：其中的测试样例需先用已编写的词法分析程序进行处理测试程序void main () {double d;int a[2][3];d = 0;a[0][1] = 2;if (d == 0) {a[0][1] = d;}else {a[1][1] = 0;}while (a[0][1]<3) {++a[0][1];}}分析结果以及错误报告：. .4-1 图标识符表：4-2图实验结果分析：. ..。
编译原理_ 语义分析_实验报告
编译原理实验三语义分析实验报告◆学院：数学与计算机科学技术学院◆专业：计算机科学与技术◆班级：级计算机班◆小组组员：姓名：学号：姓名：学号：姓名：学号：姓名：学号：实验题目一、实验目的要求学生用与实验2相同的语言，编制语义分析程序。
二、实验准备微机CPU主频1.3G以上，128M内存，安装好C语言，PASCAL语言，或C++。
三、实验时间13学时四、实验内容要求学生用与实验2相同的语言，编制语义分析程序。
定义该语言的语义成分，将语义分析程序编制成子程序，在实验2分析出各语法单位后，分析其含义，并将可执行语句或表达式翻译为四元式输出，并将错误信息输出。
实验报告必须包括设计的思路，以及测试报告（输入测试例子，输出结果）。
五、上交文档1．实验报告（书面）；2．程序文件（通过网络提交）。
<program> ::= <block> .<block> ::= <const-decl> <var-decl> <proc-decl> <statement><const-decl> ::= const <const-assignment-list> ; | ε<const-assignment-list> ::= <ident> = <number>| <const-assignment-list> , <ident> = <number><var-decl> ::= var <ident-list> ; |ε<ident-list> ::= <ident> | <ident-list> , <ident><proc-decl> ::= <proc-decl> procedure <ident> ; <block> ; |ε<statement> ::= <ident> := <expression>| call <ident>| begin <statement-list> end| if <condition> then <statement>| while <condition> do <statement>|ε<statement-list> ::= <statement> | <statement-list> ; <statement><condition> ::= odd <expression> | <expression> <relation> <expression><relation> ::= = | <> | < | > | <= | >=<expression> ::= <term> | <adding-operator> <term>| <expression> <adding-operator> <term><adding-operator> ::= + | -<term> ::= <factor> | <term> <multiplying-operator> <factor><multiplying-operator> ::= * | /<factor> ::= <ident> | <number> | ( <expression> )注意：(1) "ε" 表示空串。
编译原理实验三-自下而上语法分析及语义分析.docx
电力学院编译原理课程实验报告实验名称：实验三自下而上语法分析及语义分析院系：计算机科学与技术学院专业年级：学生：学号：指导教师：实验日期：实验三自上而下的语法分析一、实验目的：通过本实验掌握LR分析器的构造过程，并根据语法制导翻译，掌握属性文法的自下而上计算的过程。
二、实验学时：4学时。
三、实验容根据给出的简单表达式的语法构成规那么〔见五〕，编制LR分析程序，要求能对用给定的语法规那么书写的源程序进展语法分析和语义分析。
对于正确的表达式，给出表达式的值。
对于错误的表达式，给出出错位置。
四、实验方法采用LR分析法。
首先给出S-属性文法的定义〔为简便起见，每个文法符号只设置一个综合属性，即该文法符号所代表的表达式的值。
属性文法的定义可参照书137页表6.1〕，并将其改造成用LR分析实现时的语义分析动作〔可参照书145页表6.5〕。
接下来给出LR分析表。
然后程序的具体实现：●LR分析表可用二维数组〔或其他〕实现。
●添加一个val栈作为语义分析实现的工具。
编写总控程序，实现语法分析和语义分析的过程。
注：对于整数的识别可以借助实验1。
五、文法定义简单的表达式文法如下：(1)E->E+T(2)E->E-T(3)E->T(4)T->T*F(5)T->T/F(6)T->F(7)F->(E)(8)F->i五、处理程序例和处理结果例例如1：20213191*(20213191+3191)+ 3191#六、源代码【cifa.h】//cifa.h#include<string>using namespace std;//单词构造定义struct WordType{int code;string pro;};//函数声明WordType get_w();void getch();void getBC();bool isLetter();bool isDigit();void retract();int Reserve(string str); string concat(string str); 【Table.action.h】//table_action.hclass Table_action{int row_num,line_num;int lineName[8];string tableData[16][8]; public:Table_action(){row_num=16;line_num=8;lineName[0]=30;lineName[1]=7;lineName[2]=13;lineName[3]=8;lineName[4]=14;lineName[5]=1;lineName[6]=2;lineName[7]=15;lineName[8]=0;for(int m=0;m<row_num;m++)for(int n=0;n<line_num;n++)tableData[m][n]="";tableData[0][0]="S5";tableData[0][5]="S4";tableData[1][1]="S6";tableData[1][2]="S12";tableData[1][7]="acc";tableData[2][1]="R3";tableData[2][3]="S7"; tableData[2][4]="S13"; tableData[2][6]="R3"; tableData[2][7]="R3"; tableData[3][1]="R6"; tableData[3][2]="R6"; tableData[3][3]="R6"; tableData[3][4]="R6"; tableData[3][6]="R6"; tableData[3][7]="R6"; tableData[4][0]="S5"; tableData[4][5]="S4"; tableData[5][1]="R8"; tableData[5][2]="R8"; tableData[5][3]="R8"; tableData[5][4]="R8"; tableData[5][6]="R8"; tableData[5][7]="R8"; tableData[6][0]="S5"; tableData[6][5]="S4"; tableData[7][0]="S5";tableData[8][1]="S6"; tableData[8][2]="S12"; tableData[8][6]="S11"; tableData[9][1]="R1"; tableData[9][2]="R1"; tableData[9][3]="S7"; tableData[9][4]="S13"; tableData[9][6]="R1"; tableData[9][7]="R1"; tableData[10][1]="R4"; tableData[10][2]="R4"; tableData[10][3]="R4"; tableData[10][4]="R4"; tableData[10][6]="R4"; tableData[10][7]="R4"; tableData[11][1]="R7"; tableData[11][2]="R7"; tableData[11][3]="R7"; tableData[11][4]="R7"; tableData[11][6]="R7"; tableData[11][7]="R7";tableData[12][5]="S4";tableData[13][0]="S5";tableData[13][5]="S4";tableData[14][1]="R2";tableData[14][2]="R2";tableData[14][3]="S7";tableData[14][4]="S13";tableData[14][6]="R2";tableData[14][7]="R2";tableData[15][1]="R5";tableData[15][2]="R5";tableData[15][3]="R5";tableData[15][4]="R5";tableData[15][5]="R5";tableData[15][6]="R5";tableData[15][7]="R5";}string getCell(int rowN,int lineN) {int row=rowN;int line=getLineNumber(lineN);if(row>=0&&row<row_num&&line>=0&&line<=line_num) return tableData[row][line];elsereturn"";}int getLineNumber(int lineN){for(int i=0;i<line_num;i++)if(lineName[i]==lineN)return i;return -1;}};【Table_go.h】//table_go.hclass Table_go{int row_num,line_num;//行数、列数string lineName[3];int tableData[16][3];public:Table_go(){row_num=16;line_num=3;lineName[0]="E";lineName[1]="T";lineName[2]="F";for(int m=0;m<row_num;m++)for(int n=0;n<line_num;n++)tableData[m][n]=0;tableData[0][0]=1;tableData[0][1]=2;tableData[0][2]=3;tableData[4][0]=8;tableData[4][1]=2;tableData[4][2]=3;tableData[6][1]=9;tableData[6][2]=3;tableData[7][2]=10;tableData[12][1]=14;tableData[12][2]=3;tableData[13][2]=15;}int getCell(int rowN,string lineNa){int row=rowN;int line=getLineNumber(lineNa);if(row>=0&&row<row_num&&line<=line_num) return tableData[row][line];elsereturn -1;}int getLineNumber(string lineNa){for(int i=0;i<line_num;i++)if(lineName[i]==lineNa)return i;return -1;}};【Stack_num.h】class Stack_num{int i; //栈顶标记int *data; //栈构造public:Stack_num() //构造函数{data=new int[100];i=-1;}int push(int m) //进栈操作{i++;data[i]=m;return i;}int pop() //出栈操作{i--;return data[i+1];}int getTop() //返回栈顶{return data[i];}~Stack_num() //析构函数{delete []data;}int topNumber(){return i;}void outStack(){for(int m=0;m<=i;m++)cout<<data[m];}};【Stack_str.h】class Stack_str{int i; //栈顶标记string *data; //栈构造public:Stack_str() //构造函数{data=new string[50];i=-1;}int push(string m) //进栈操作{i++;data[i]=m;return i;}int pop() //出栈操作{data[i]="";i--;return i;}string getTop() //返回栈顶{return data[i];}~Stack_str() //析构函数{delete []data;}int topNumber(){return i;}void outStack(){for(int m=0;m<=i;m++)cout<<data[m];}};【cifa.cpp】//cifa.cpp#include<iostream>#include<string>#include"cifa.h"using namespace std;//关键字表和对应的编码string codestring[10]={"main","int","if","then","else","return","void","cout","endl"}; int codebook[10]={26,21,22,23,24,25,27,28,29};//全局变量char ch;int flag=0;/*//主函数int main(){WordType word;cout<<"请输入源程序序列:";word=get_w();while(word.pro!="#")//#为自己设置的完毕标志{cout<<"("<<word.code<<"，"<<"“"<<word.pro<<"〞"<<")"<<endl;word=get_w();};return 0;}*/WordType get_w(){string str="";int code;WordType wordtmp;getch();//读一个字符getBC();//去掉空白符if(isLetter()){ //以字母开头while(isLetter()||isDigit()){str=concat(str);getch();}retract();code=Reserve(str);if(code==-1){wordtmp.code=0;wordtmp.pro=str;}//不是关键字else{wordtmp.code=code;wordtmp.pro=str;}//是关键字}else if(isDigit()){ //以数字开头while(isDigit()){str=concat(str);getch();}retract();wordtmp.code=30;wordtmp.pro=str;}else if(ch=='(') {wordtmp.code=1;wordtmp.pro="(";} else if(ch==')') {wordtmp.code=2;wordtmp.pro=")";}else if(ch=='{') {wordtmp.code=3;wordtmp.pro="{";} else if(ch=='}') {wordtmp.code=4;wordtmp.pro="}";} else if(ch==';') {wordtmp.code=5;wordtmp.pro=";";}else if(ch=='=') {wordtmp.code=6;wordtmp.pro="=";} else if(ch=='+') {wordtmp.code=7;wordtmp.pro="+";} else if(ch=='*') {wordtmp.code=8;wordtmp.pro="*";} else if(ch=='>') {wordtmp.code=9;wordtmp.pro=">";} else if(ch=='<') {wordtmp.code=10;wordtmp.pro="<";} else if(ch==',') {wordtmp.code=11;wordtmp.pro=",";} else if(ch=='\'') {wordtmp.code=12;wordtmp.pro="\'";} else if(ch=='-') {wordtmp.code=13;wordtmp.pro="-";} else if(ch=='/') {wordtmp.code=14;wordtmp.pro="/";} else if(ch=='#') {wordtmp.code=15;wordtmp.pro="#";} else if(ch=='|') {wordtmp.code=16;wordtmp.pro="|";}else {wordtmp.code=100;wordtmp.pro=ch;}return wordtmp;}void getch(){if(flag==0) //没有回退的字符ch=getchar();else //有回退字符，用回退字符，并设置标志flag=0;}void getBC(){while(ch==' '||ch=='\t'||ch=='\n')ch=getchar();}bool isLetter(){if(ch>='a'&&ch<='z'||ch>='A'&&ch<='Z')return true;elsereturn false;}bool isDigit(){if(ch>='0'&&ch<='9')return true;elsereturn false;}string concat(string str){return str+ch;}void retract(){flag=1;}int Reserve(string str){int i;for(i=0;i<=8;i++){if(codestring[i]==str) //是某个关键字，返回对应的编码return codebook[i];}if(i==9) //不是关键字return -1;}【LR.cpp】#include<iostream>#include<string>#include<cstdlib>#include"cifa.h"#include"stack_num.h"#include"stack_str.h"#include"table_action.h"#include"table_go.h"using namespace std;void process(){int stepNum=1;int topStat;Stack_num statusSTK; //状态栈Stack_str symbolSTK; //符号栈Stack_num valueSTK; //值栈WordType word;Table_action actionTAB; //行为表Table_go goTAB; //转向表cout<<"请输入源程序，以#完毕：";word=get_w();//总控程序初始化操作symbolSTK.push("#");statusSTK.push(0);valueSTK.push(0);cout<<"步骤\t状态栈\t符号栈\t值栈\t当前词\t动作\t转向"<<endl;//分析while(1){topStat=statusSTK.getTop(); //当前状态栈顶string act=actionTAB.getCell(topStat,word.code);//根据状态栈顶和当前单词查到的动作//输出cout<<stepNum++<<"\t";statusSTK.outStack(); cout<<"\t";symbolSTK.outStack(); cout<<"\t";valueSTK.outStack(); cout<<"\t";cout<<word.pro<<"\t";//行为为“acc〞，且当前处理的单词为#，且状态栈里就两个状态//说明正常分析完毕if(act=="acc"&&word.pro=="#"&&statusSTK.topNumber()==1){cout<<act<<endl;cout<<"分析成功！"<<endl;cout<<"结果为："<<valueSTK.getTop()<<endl;return;}//读到act表里标记为错误的单元格else if(act==""){cout<<endl<<"不是文法的句子！"<<endl;cout<<"错误的位置为单词"<<word.pro<<"附近。
编译原理实验报告语义分析
编译原理实验报告语义分析实验名称：语义分析实验目的：1.掌握词法分析器生成的词法单元序列的构造；2.学会设计语法分析器，实现对程序的基本语法结构检查，并生成抽象语法树；3.学习语义规约的实现，实现对程序的语义分析和错误检查；4.熟悉语义分析向语法分析的接口。
实验原理：语义分析是编译过程的一个重要环节，它的主要任务是对生成的抽象语法树进行遍历，并验证程序的类型一致性、语义规则的正确性、错误的检查和恢复等。
语义分析的输入是由语法分析生成的抽象语法树，输出是继续优化的抽象语法树或中间代码，以供后续的中间代码生成等工作使用。
实验步骤：1.设计语法分析器，包括语法规则、优先级关系等；2.生成词法单元序列；3.构建语法分析器，进行语法分析，并生成抽象语法树；4.针对不同的语义规约，设计语义动作，实现对程序的语义分析和错误检查；5.完成语义分析器的构建和测试。
实验设备：1.计算机；2. 编程语言：C++/Java/Python等；3. 开发环境：Visual Studio/ Eclipse/PyCharm等。
实验结果：通过对语法分析生成的抽象语法树进行遍历，实现了对程序的语义分析和错误检查。
具体实现包括：1.类型检查：根据语义规约，对程序中的类型进行检查，包括变量的声明及使用、函数的调用、赋值语句的一致性等；2.作用域检查：检查变量的作用域和可见性等；3.错误检查：检测语义错误，如变量未声明、函数重复定义等；4.错误恢复：当检测到错误时，采取适当的错误恢复措施，如跳过错误的部分继续分析、提示错误信息等。
实验心得：本次实验主要学习了语义分析的原理和实现方法，深入了解了编译过程中各个环节的作用和关系。
通过实践操作，加深了对语法分析和语义分析的理解，提高了编程能力和解决问题的能力。
同时，实验过程中也遇到了一些挑战和困难，例如语义规约的设计和实现、错误检查和恢复等，但通过查阅资料和与同学讨论，最终解决了这些问题。
通过本次实验，我对编译原理和语义分析有了更深入的了解，并且对以后的学习和工作有了更好的准备。
编译原理语义分析实验报告
action[5][LE].i=5; action[6][RI].ch='R'; action[6][RI].i=1; action[6][EMY].ch='R'; action[6][EMY].i=1; action[7][Z].ch='S'; action[7][Z].i=4; action[7][LE].ch='S'; action[7][LE].i=5; action[8][X].ch='R'; action[8][X].i=4; action[8][RI].ch='R'; action[8][RI].i=4; action[8][EMY].ch='R'; action[8][EMY].i=4; action[9][Z].ch='S'; action[9][Z].i=4; action[9][LE].ch='S'; action[9][LE].i=5; action[10][RI].ch='S'; action[10][RI].i=13; action[11][X].ch='S'; action[11][X].i=7; action[11][RI].ch='R'; action[11][RI].i=3; action[11][EMY].ch='R';//R！ ！ action[11][EMY].i=3; action[12][Y].ch='S'; action[12][Y].i=9; action[12][X].ch='R'; action[12][X].i=6; action[12][RI].ch='R'; action[12][RI].i=6; action[12][EMY].ch='R'; action[12][EMY].i=6; action[13][X].ch='R';
编译原理实验四语义分析及中间代码生成
编译原理实验四语义分析及中间代码⽣成⼀、实验⽬的（1）通过上机实验，加深对语法制导翻译原理的理解，掌握将语法分析所识别的语法范畴变换为某种中间代码的语义翻译⽅法。
（2）掌握⽬前普遍采⽤的语义分析⽅法─语法制导翻译技术。
（3）给出 PL/0 ⽂法规范，要求在语法分析程序中添加语义处理，对于语法正确的表达式，输出其中间代码；对于语法正确的算术表达式，输出其计算值。
⼆、实验内容（1）语义分析对象重点考虑经过语法分析后已是正确的语法范畴，本实验重点是语义⼦程序。
已给 PL/0 语⾔⽂法，在实验⼆或实验三的表达式语法分析程序⾥，添加语义处理部分，输出表达式的中间代码，⽤四元式序列表⽰。
（2） PL/0 算术表达式的语义计算：PL/0 算术表达式，例如:2+35 作为输⼊。
输出： 17PL/0 表达式的中间代码表⽰：PL/0 表达式，例如: a（b+c）。
输出： (+,b,c,t1)(,a,t1,t2)三、设计思想1.原理属性⽂法：是在上下⽂⽆关⽂法的基础上为每个⽂法符号（终结符或⾮终结符）配备若⼲个相关的“值”（称为属性）。
属性:代表与⽂法符号相关的信息，和变量⼀样，可以进⾏计算和传递。
综合属性：⽤于“⾃下⽽上”传递信息。
在语法树中，⼀个结点的综合属性的值，由其⼦结点的属性值确定。
S—属性⽂法：仅仅使⽤综合属性的属性⽂法。
语义规则： 属性计算的过程即是语义处理的过程。
对于⽂法的每⼀个产⽣式配备⼀组属性的计算规则，则称为语义规则。
（1）终结符只有综合属性，它由词法分析器提供。
（2）⾮终结符既可以有综合属性也可以有继承属性，⽂法开始符号的所有继承属性作为属性计算前的初始值。
（3）产⽣式右边符号的继承属性和产⽣式左边符号的综合属性都必须提供⼀个计算规则。
（4）产⽣式左边符号的继承属性和产⽣式右边符号的综合属性由其它产⽣式的属性规则计算。
⼀遍扫描的处理⽅法： 与树遍历的属性计算⽅法不同，⼀遍扫描的处理⽅法是在语法分析的同时计算属性值，⽽不是语法分析构造语法树之后进⾏属性的计算，⽽且⽆需构造实际的语法树。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include "stdio.h"#include "string.h"#include "stdlib.h"char prog[100],token[8],ch;char *rwtab[6]={"begin","if","then","while","do","end"};int syn,p,m,n,sum,q;int kk;struct { char result1[8];char ag11[8];char op1[8];char ag21[8];} quad[20];char *factor();char *expression();int yucu();char *term();int statement();int lrparser();char *newtemp();scaner();emit(char *result,char *ag1,char *op,char *ag2);main(){ int j;q=p=kk=0;printf("\nplease input a string (end with '#'): ");do{ scanf("%c",&ch);prog[p++]=ch;}while(ch!='#');p=0;scaner();lrparser();if(q>19)printf(" to long sentense!\n");else for (j=0;j<q;j++)printf(" %s = %s %s %s \n\n",quad[j].result1,quad[j].ag11,quad[j].op1,quad[j].ag21);//getch();system("pause");}int lrparser(){ int schain=0;kk=0;if (syn==1){ scaner();schain=yucu();if(syn==6){ scaner();if((syn==0)&&(kk==0)) printf("Success!\n"); }else { if(kk!=1)printf("short of 'end' !\n");kk=1;// getch();exit(0);}}else { printf("short of 'begin' !\n");kk=1;// getch();exit(0);}return (schain);}int yucu(){ int schain=0;schain=statement();while(syn==26){ scaner();schain=statement();}return (schain);}int statement(){ char tt[8],eplace[8];int schain=0;if (syn==10){ strcpy(tt,token);scaner();if(syn==18){ scaner();strcpy(eplace,expression());emit(tt,eplace,"","");schain=0;}else { printf("short of sign ':=' !\n");kk=1;// getch();exit(0);}return (schain);}}char *expression(){ char *tp,*ep2,*eplace,*tt;tp=(char *)malloc(12);ep2=(char *)malloc(12); eplace=(char *)malloc(12);tt=(char *)malloc(12);strcpy(eplace,term());while((syn==13)||(syn==14)) { if (syn==13)strcpy(tt,"+");else strcpy(tt,"-");scaner();strcpy(ep2,term());strcpy(tp,newtemp());emit(tp,eplace,tt,ep2);strcpy(eplace,tp);}return (eplace);}char *term(){ char *tp,*ep2,*eplace,*tt;tp=(char *)malloc(12);ep2=(char *)malloc(12); eplace=(char *)malloc(12);tt=(char *)malloc(12);strcpy(eplace,factor());while((syn==15)||(syn==16)) { if (syn==15)strcpy(tt,"*");else strcpy(tt,"/");scaner();strcpy(ep2,factor());strcpy(tp,newtemp());emit(tp,eplace,tt,ep2);strcpy(eplace,tp);}return (eplace);}char *factor(){ char *fplace;fplace=(char *)malloc(12); strcpy(fplace,"");if(syn==10){ strcpy(fplace,token);scaner();}else if(syn==11){ itoa(sum,fplace,10);scaner();}else if(syn==27){ scaner();fplace=expression();if(syn==28) scaner();else { printf("error on ')' !\n");kk=1;// getch();exit(0);}}else { printf("error on '(' !\n");kk=1;// getch();exit(0);}return (fplace);}char *newtemp(){ char *p;char m[8];p=(char *)malloc(8);kk++;itoa(kk,m,10);strcpy(p+1,m);p[0]='t';return(p);}scaner(){ sum=0;for(m=0;m<8;m++)token[m++]=NULL;m=0;ch=prog[p++];while(ch==' ')ch=prog[p++];if(((ch<='z')&&(ch>='a'))||((ch<='Z')&&(ch>='A'))){ while(((ch<='z')&&(ch>='a'))||((ch<='Z')&&(ch>='A'))||((ch>='0')&&(ch<='9'))) {token[m++]=ch;ch=prog[p++];}p--;syn=10;token[m++]='\0';for(n=0;n<6;n++)if(strcmp(token,rwtab[n])==0){ syn=n+1;break;}}else if((ch>='0')&&(ch<='9')){ while((ch>='0')&&(ch<='9')) { sum=sum*10+ch-'0';ch=prog[p++];}p--;syn=11;}else switch(ch){ case '<':m=0;ch=prog[p++];if(ch=='>'){ syn=21;}else if(ch=='='){ syn=22;}else{ syn=20;p--;}break;case '>':m=0;ch=prog[p++];if(ch=='='){ syn=24;}else{ syn=23;p--;}break;case ':':m=0;ch=prog[p++];if(ch=='='){ syn=18;}else{ syn=17;p--;}break;case '+': syn=13; break;case '-': syn=14; break;case '*': syn=15;break;case '/': syn=16;break;case '(': syn=27;break;case ')': syn=28;break;case '=': syn=25;break;case ';': syn=26;break;case '#': syn=0;break;default: syn=-1;break;}}emit(char *result,char *ag1,char *op,char *ag2) {strcpy(quad[q].result1,result);strcpy(quad[q].ag11,ag1);strcpy(quad[q].op1,op);strcpy(quad[q].ag21,ag2);q++;}。