编译原理实验报告3-LL(1)文法构造
编译原理上机实验-LL(1)语法分析-C#
编译原理上机实验报告小组成员：王金名、周攀、汪国辉、澎湃、王帅、齐娟娟、刘鸳鸳一、实验目的：了解LL（1）文法分析的基本原理；提高上机实践能力；增强团队协作能力。
二、实验内容：通过LL1文法分析表分析任意一个符号串是否为某文法的句子；显示具体分析过程；打开、新建、保存分析表；保存分析结果三、实验原理：1.C#字符串处理及数组处理，这是本实验最强有力的工具；2.LL（1）文法分析的基本原理，详见教材P80 LL（1）分析器的总控算法；3.C#文件操作，C#常用控件使用。
四、实验步骤：1.构造应用程序框架，利用内置分析表实现分析符号串的最基础功能（1）使用Visual Studio 2005 新建C#语言环境的windows应用程序LL1GAnalysis；（2）将窗体的名称改成From_Main，相应的代码名称会随之更改；（3）添加texbox控件ID为textBox_input，添加listView控件，ID为listView_Result；（4）public partial class Form_Main : Form里面编写相应代码：//全局变量const int Max = 100;public string[,] staticmTable ={{"","i","+","*","(",")","#"},{"S","<error>","<error>","<error>","S::=A","S::=A","<error>"},{"A","<error>","<error>","<error>","A::=BA\'","A::=BA\'","<error>"},{"A\'","A\'::=iBA\'","<error>","A\'::=ε","<error>","<error>","A\'::=ε"},{"B","<error>","<error>","<error>","B::=CB\'","B::=CB\'","<error>"},{"B\'","B\'::=ε","B\'::=+CB\'","B\'::=ε","<error>","<error>","B\'::=ε"},{"C","<error>","<error>","<error>","C::=(","C::=)A*","<error>"} };string[] VN = new string[Max]; int VNLength;string[] VT = new string[Max]; int VTLength;//以下是分析过程中要用到的公共函数public void addTolistView_Result(string step, string stack, string input, stringproduction)//分析步骤及结果显示（向listView中添加条目，并保存到string类型变量（analysisResult）作最终保存分析结果时使用{string strResultbuf = "";strResultbuf += step.PadRight(20, ' ');strResultbuf += stack.PadRight(20, ' ');strResultbuf += input.PadRight(20, ' ');strResultbuf += production.PadRight(20, ' ') + "\r\n";analysisResult += strResultbuf;ListViewItem li = new ListViewItem();li.Text = step;ListViewItem.ListViewSubItem ls = new ListViewItem.ListViewSubItem();ls.Text = stack;li.SubItems.Add(ls);ls = new ListViewItem.ListViewSubItem();ls.Text = input;li.SubItems.Add(ls);ls = new ListViewItem.ListViewSubItem();ls.Text = production;li.SubItems.Add(ls);listView_Result.Items.Add(li);}public void GetVN(string[,] table)//从分析表中获取非终结符{int i;for ( i = 1; i < table.GetLength(0);i++ ){VN[i-1] = table[i,0];}VNLength = i;}public void GetVT(string[,] table)//从分析表中获取终结符{int i;for (i = 1; i < table.GetLength(1); i++){VT[i-1] = table[0,i];}VTLength = i;}public int isVT(string str)//判断str是不是VT中的符号{int mark = 0;for (int i = 0; i < VTLength; i++){if (VT[i] == str){mark = 1;}}return mark;}public int isVN(string str)//判断str是不是VN中的符号{int mark = 0;for (int i = 0; i < VNLength; i++){if (VN[i] == str){mark = 1;}}return mark;}public string outStack(string[] Stack, int top)//栈内符号合并输出的时候用 {string str = "";for (int i = 0; i <= top; i++){str += Stack[i];}return str;}public void removeAllItems(ListView list)//清空listview Items{int itemcount = list.Items.Count;for (int i = itemcount; i > 0 ;i-- ){list.Items.RemoveAt(0);}}public string matchInTable(string[,] mt,string stacktop, string nowstr)//查表栈顶与ch 交叉处的标志并返回{int i,j;for (i = 0; i < mt.GetLength(0); i++ ){if (mt[i,0] == stacktop){break;}}for (j = 0; j < mt.GetLength(1);j++ ){if (mt[0,j] == nowstr){break;}}if (i < mt.GetLength(0)&&j<mt.GetLongLength(1)){return mt[i,j];}else{return"error! ";}}//以下是分析过程public void Start_Analysis(string[,] mTable)//开始分析并显示分析过程{tabControl_mTable.SelectTab(tabPage_Show);ShowmTable(mTable);removeAllItems(listView_Result);listView_Result.BeginUpdate();int top = -1; int step = 0;string[] Stack = new string[Max];string str = textBox_input.Text.Trim();//初始化GetVN(mTable); GetVT(mTable);top++; Stack[top] = "#";top++; Stack[top] = VN[0];str += "#";//分析while (true){if (isVT(Stack[top]) == 1)//Stack[top]是终结符，则比较栈顶符与当前符号{if (Stack[top] == str[0].ToString())//匹配当前符号{if (Stack[top] == "#")//ok{step++;addTolistView_Result(step.ToString(), outStack(Stack, top), str, "OK!");step = 0;break;}else//同时退栈{step++;addTolistView_Result(step.ToString(), outStack(Stack, top), str, ""); top--;str = str.Remove(0, 1);}}else//错误{step++;addTolistView_Result(step.ToString(), outStack(Stack, top), str,"Error!");break;}}else if (isVN(Stack[top]) == 1)//Stack[top]是非终结符，则查表{string production = matchInTable(mTable, Stack[top], str[0].ToString());if (production != "<error>"){step++;addTolistView_Result(step.ToString(), outStack(Stack, top), str, production);string probuf = "";if (production[1] == '\''){probuf = production.Remove(0, 5);}else{probuf = production.Remove(0, 4);}char[] chbuf = probuf.ToCharArray();int i = chbuf.Length - 1;string strbuf = "";Stack[top] = null;top--;while (i >= 0){if (chbuf[i] != 'ε'){if (chbuf[i] != '\''){top++;Stack[top] = strbuf.Insert(0, chbuf[i].ToString());strbuf = "";}else if (chbuf[i] == '\''){strbuf += strbuf.Insert(0, chbuf[i].ToString());}}else { break; }i--;}}else//错误production.Length != 0不在分析表中{step++;addTolistView_Result(step.ToString(), outStack(Stack, top), str, "Error!");break;}}else//错误非法字符{step++;addTolistView_Result(step.ToString(), "错误", str, "非法字符:" +str[0].ToString());break;}}//分析结束listView_Result.EndUpdate();}private void button_Start_Click(object sender, EventArgs e)//菜单及按钮开始分析(菜单项及开始按钮公用函数){string[,] mTable;if (radioButton_Staticmt.Checked){mTable = staticmTable;ShowmTable(mTable);Start_Analysis(mTable);}else if (radioButton_Createmt.Checked){if (created == 1){mTable = creamTable;ShowmTable(mTable);Start_Analysis(mTable);}else{MessageBox.Show("你还没有创建分析表，请先创建！", "错误提示",MessageBoxButtons.OK, MessageBoxIcon.Exclamation);}}else if (radioButton_Openmt.Checked){if (opened == 1){mTable = openmTable;ShowmTable(mTable);Start_Analysis(mTable);}else{MessageBox.Show("你还没有打开分析表，请先打开或创建！", "错误提示",MessageBoxButtons.OK, MessageBoxIcon.Exclamation);}}}2.实现显示分析表及新建分析表并利用该表分析句子的功能（1）添加tabControl控件ID为tabControl_mTable建立3个页面tabPage_Show显示当前分析表、tabPage_Edit新建分析表、tabPage_Open打开分析表（2）tabPage_Show中添加listView控件ID为listView_mtableshow用于显示分析表（3）tabPage_Edit中添加两个Button 控件ID分别为button_StartAdd开始添加、button_FilishAdd 完成添加；两个textBox控件ID分别为textBox_VT 、textBox_VN、分别用于获取要添加的终结符及非终结符个数；一个tableLayoutPanel控件ID为tableLayoutPanel_mTable用于根据用户输入的VT及VN的个数建立输入表（4）编辑相应代码：private void button_StartAdd_Click(object sender, EventArgs e)//新建分析表并开始输入{try{int conwidth,conheight,col, row;TextBox txb;tableLayoutPanel_mTable.Controls.Clear();conwidth = 50; conheight = 20;col = Convert.ToInt32(textBox_VT.Text)+1;row = Convert.ToInt32(textBox_VN.Text)+1;tableLayoutPanel_mTable.ColumnCount =col;tableLayoutPanel_mTable.RowCount = row;for (int i = 0; i < col;i++ ){for (int j = 0; j < row;j++ ){if (i == 0&&j==0){Label lb = new Label();lb.Text = "VN\\VT";lb.Width = conwidth;lb.ForeColor = Color.Red;tableLayoutPanel_mTable.Controls.Add(lb,i,j);}else{txb = new TextBox();txb.Width = conwidth;txb.Height = conheight;tableLayoutPanel_mTable.Controls.Add(txb,i,j);}}}}catch{MessageBox.Show("终结符或非终结符格式不对！\n请输入数字！","错误提示",MessageBoxButtons.OK, MessageBoxIcon.Exclamation);}}private void button_FilishAdd_Click(object sender, EventArgs e)//完成添加,更新分析表 {int col = tableLayoutPanel_mTable.ColumnCount;int row = tableLayoutPanel_mTable.RowCount;if (col > 1&&row>1){creamTable = new string[row, col];for (int i = 0; i < row; i++){for (int j = 0; j < row; j++){if (i == 0 && j == 0){creamTable[i, j] = "";}else{creamTable[i, j] =((TextBox)tableLayoutPanel_mTable.GetControlFromPosition(j, i)).Text.Trim();if (creamTable[i,j].Length == 0){creamTable[i, j] = "<error>";}}}}MessageBox.Show("成功更新分析表!");tabControl_mTable.SelectTab(tabPage_Show);radioButton_Createmt.Checked = true;created = 1;ShowmTable(creamTable);}else{MessageBox.Show("请先点击“开始添加”创建表格！","错误提示",MessageBoxButtons.OK, MessageBoxIcon.Exclamation);}}public void ShowmTable(string[,] mTable)//显示分析表{listView_mtableshow.Clear();ColumnHeader colHeader;ListViewItem lvi;ListViewItem.ListViewSubItem lvsi;for (int i = 1; i <= mTable.GetLength(1); i++){colHeader = new ColumnHeader();colHeader.Text = i.ToString();listView_mtableshow.Columns.Add(colHeader);}for (int i = 0; i < mTable.GetLength(0); i++){lvi = new ListViewItem();lvi.Text = mTable[i, 0];for (int j = 1; j < mTable.GetLength(1); j++){lvsi = new ListViewItem.ListViewSubItem();lvsi.Text = mTable[i, j];lvi.SubItems.Add(lvsi);}listView_mtableshow.Items.Add(lvi);}}private void miFileNew_Click(object sender, EventArgs e)//菜单新建分析表{tabControl_mTable.SelectTab(tabPage_Edit);}3.实现打开、保存分析表、保存分析结果的功能（1）添加主菜单menuStrip_Main两个Item：miFile文件、miGraAnylysis语法分析。
编译原理实验报告材料LL(1)分析报告法84481
课程编译原理实验名称实验二 LL(1)分析法实验目的1．掌握LL(1)分析法的基本原理；2．掌握LL(1)分析表的构造方法；3．掌握LL(1)驱动程序的构造方法。
一.实验内容及要求根据某一文法编制调试LL（1）分析程序，以便对任意输入的符号串进行分析。
本次实验的目的主要是加深对预测分析LL（1）分析法的理解。
对下列文法，用LL（1）分析法对任意输入的符号串进行分析：（1）E->TG（2）G->+TG（3）G->ε（4）T->FS（5）S->*FS（6）S->ε（7）F->(E)（8）F->i程序输入一以#结束的符号串(包括+*（）i#)，如：i+i*i#。
输出过程如下：步骤分析栈剩余输入串所用产生式1 E i+i*i# E->TG... ... ... ...二.实验过程及结果代码如下：#include<iostream>#include "edge.h"using namespace std;edge::edge(){cin>>left>>right;rlen=right.length();if(NODE.find(left)>NODE.length())NODE+=left;}string edge::getlf(){return left;}string edge::getrg(){return right;}string edge::getfirst(){return first;}string edge::getfollow(){return follow;}string edge::getselect(){return select;}string edge::getro(){string str;str+=right[0];return str;}int edge::getrlen(){return right.length();}void edge::newfirst(string w){int i;for(i=0;i<w.length();i++)if(first.find(w[i])>first.length())first+=w[i];}void edge::newfollow(string w){int i;for(i=0;i<w.length();i++)if(follow.find(w[i])>follow.length()&&w[i]!='@')follow+=w[i];}void edge::newselect(string w){int i;for(i=0;i<w.length();i++)if(select.find(w[i])>select.length()&&w[i]!='@') select+=w[i];}void edge::delfirst(){int i=first.find('@');first.erase(i,1);}int SUM;string NODE,ENODE;//计算firstvoid first(edge ni,edge *n,int x){int i,j;for(j=0;j<SUM;j++){if(ni.getlf()==n[j].getlf()){if(NODE.find(n[j].getro())<NODE.length()){for(i=0;i<SUM;i++)if(n[i].getlf()==n[j].getro())first(n[i],n,x);}elsen[x].newfirst(n[j].getro());}}}//计算followvoid follow(edge ni,edge *n,int x){int i,j,k,s;string str;for(i=0;i<ni.getrlen();i++){s=NODE.find(ni.getrg()[i]);if(s<NODE.length()&&s>-1) //是非终结符if(i<ni.getrlen()-1) //不在最右for(j=0;j<SUM;j++)if(n[j].getlf().find(ni.getrg()[i])==0){if(NODE.find(ni.getrg()[i+1])<NODE.length()){for(k=0;k<SUM;k++)if(n[k].getlf().find(ni.getrg()[i+1])==0){n[j].newfollow(n[k].getfirst());if(n[k].getfirst().find("@")<n[k].getfirst().length())n[j].newfollow(ni.getfollow());}}else{str.erase();str+=ni.getrg()[i+1];n[j].newfollow(str);}}}}//计算selectvoid select(edge &ni,edge *n){int i,j;if(ENODE.find(ni.getro())<ENODE.length()){ni.newselect(ni.getro());if(ni.getro()=="@")ni.newselect(ni.getfollow());}elsefor(i=0;i<ni.getrlen();i++){for(j=0;j<SUM;j++)if(ni.getrg()[i]==n[j].getlf()[0]){ni.newselect(n[j].getfirst());if(n[j].getfirst().find('@')>n[j].getfirst().length())return;}}}//输出集合void out(string p){int i;if(p.length()==0)return;cout<<"{";for(i=0;i<p.length()-1;i++){cout<<p[i]<<",";}cout<<p[i]<<"}";}//连续输出符号void outfu(int a,string c){int i;for(i=0;i<a;i++)cout<<c;}//输出预测分析表void outgraph(edge *n,string (*yc)[50]){int i,j,k;bool flag;for(i=0;i<ENODE.length();i++){if(ENODE[i]!='@'){outfu(10," ");cout<<ENODE[i];}}outfu(10," ");cout<<"#"<<endl;int x;for(i=0;i<NODE.length();i++){outfu(4," ");cout<<NODE[i];outfu(5," ");for(k=0;k<ENODE.length();k++){flag=1;for(j=0;j<SUM;j++){if(NODE[i]==n[j].getlf()[0]){x=n[j].getselect().find(ENODE[k]);if(x<n[j].getselect().length()&&x>-1){cout<<"->"<<n[j].getrg();yc[i][k]=n[j].getrg();outfu(9-n[j].getrlen()," ");flag=0;}x=n[j].getselect().find('#');if(k==ENODE.length()-1&&x<n[j].getselect().length()&&x>-1){cout<<"->"<<n[j].getrg();yc[i][j]=n[j].getrg();}}}if(flag&&ENODE[k]!='@')outfu(11," ");}cout<<endl;}}//分析符号串int pipei(string &chuan,string &fenxi,string (*yc)[50],int &b) {char ch,a;int x,i,j,k;b++;cout<<endl<<" "<<b;if(b>9)outfu(8," ");elseoutfu(9," ");cout<<fenxi;outfu(26-chuan.length()-fenxi.length()," "); cout<<chuan;outfu(10," ");a=chuan[0];ch=fenxi[fenxi.length()-1];x=ENODE.find(ch);if(x<ENODE.length()&&x>-1){if(ch==a){fenxi.erase(fenxi.length()-1,1);chuan.erase(0,1);cout<<"'"<<a<<"'匹配";if(pipei(chuan,fenxi,yc,b))return 1;elsereturn 0;}elsereturn 0;}else{if(ch=='#'){if(ch==a){cout<<"分析成功"<<endl;return 1;}elsereturn 0;}elseif(ch=='@'){fenxi.erase(fenxi.length()-1,1);if(pipei(chuan,fenxi,yc,b))return 1;elsereturn 0;}else{i=NODE.find(ch);if(a=='#'){x=ENODE.find('@');if(x<ENODE.length()&&x>-1)j=ENODE.length()-1;elsej=ENODE.length();}elsej=ENODE.find(a);if(yc[i][j].length()){cout<<NODE[i]<<"->"<<yc[i][j];fenxi.erase(fenxi.length()-1,1);for(k=yc[i][j].length()-1;k>-1;k--)if(yc[i][j][k]!='@')fenxi+=yc[i][j][k];if(pipei(chuan,fenxi,yc,b))return 1;elsereturn 0;}elsereturn 0;}}}void main(){edge *n;string str,(*yc)[50];int i,j,k;bool flag=0;cout<<"请输入上下文无关文法的总规则数："<<endl;cin>>SUM;cout<<"请输入具体规则（格式：左部右部，@为空）："<<endl;n=new edge[SUM];for(i=0;i<SUM;i++)for(j=0;j<n[i].getrlen();j++){str=n[i].getrg();if(NODE.find(str[j])>NODE.length()&&ENODE.find(str[j])>ENODE.length()) ENODE+=str[j];}//计算first集合for(i=0;i<SUM;i++){first(n[i],n,i);}//outfu(10,"~*~");cout<<endl;for(i=0;i<SUM;i++)if(n[i].getfirst().find("@")<n[i].getfirst().length()){if(NODE.find(n[i].getro())<NODE.length()){for(k=1;k<n[i].getrlen();k++){if(NODE.find(n[i].getrg()[k])<NODE.length()){for(j=0;j<SUM;j++){if(n[i].getrg()[k]==n[j].getlf()[0]){n[i].newfirst(n[j].getfirst());break;}}if(n[j].getfirst().find("@")>n[j].getfirst().length()){n[i].delfirst();break;}}}}}//计算follow集合for(k=0;k<SUM;k++){for(i=0;i<SUM;i++){if(n[i].getlf()==n[0].getlf())n[i].newfollow("#");follow(n[i],n,i);}for(i=0;i<SUM;i++){for(j=0;j<SUM;j++)if(n[j].getrg().find(n[i].getlf())==n[j].getrlen()-1)n[i].newfollow(n[j].getfollow());}}//计算select集合for(i=0;i<SUM;i++){select(n[i],n);}for(i=0;i<NODE.length();i++){str.erase();for(j=0;j<SUM;j++)if(n[j].getlf()[0]==NODE[i]){if(!str.length())str=n[j].getselect();else{for(k=0;k<n[j].getselect().length();k++)if(str.find(n[j].getselect()[k])<str.length()){flag=1;break;}}}}//输出cout<<endl<<"非终结符";outfu(SUM," ");cout<<"First";outfu(SUM," ");cout<<"Follow"<<endl;outfu(5+SUM,"-*-");cout<<endl;for(i=0;i<NODE.length();i++){for(j=0;j<SUM;j++)if(NODE[i]==n[j].getlf()[0]){outfu(3," ");cout<<NODE[i];outfu(SUM+4," ");out(n[j].getfirst());outfu(SUM+4-2*n[j].getfirst().length()," ");out(n[j].getfollow());cout<<endl;break;}}outfu(5+SUM,"-*-");cout<<endl<<"判定结论： ";if(flag){cout<<"该文法不是LL(1)文法!"<<endl;return;}else{cout<<"该文法是LL(1)文法!"<<endl;}//输出预测分析表cout<<endl<<"预测分析表如下："<<endl;yc=new string[NODE.length()][50];outgraph(n,yc);string chuan,fenxi,fchuan;cout<<endl<<"请输入符号串：";cin>>chuan;fchuan=chuan;fenxi="#";fenxi+=NODE[0];i=0;cout<<endl<<"预测分析过程如下："<<endl;cout<<"步骤";outfu(7," ");cout<<"分析栈";outfu(10," ");cout<<"剩余输入串";outfu(8," ");cout<<"推导所用产生式或匹配";if(pipei(chuan,fenxi,yc,i))cout<<endl<<"输入串"<<fchuan<<"是该文法的句子！"<<endl;elsecout<<endl<<"输入串"<<fchuan<<"不是该文法的句子！"<<endl;}截屏如下：三.实验中的问题及心得这次实验让我更加熟悉了LL（1）的工作流程以及LL(1)分析表的构造方法。
编译原理LL(1)语法分析实验报告
学号 20102798 专业软件工程姓名薛建东实验日期2013.04.08 教师签字成绩实验报告【实验名称】LL（1）语法分析【实验目的】通过完成预测分析法的语法分析程序，了解预测分析法和递归子程序法的区别和联系。
使了解语法分析的功能，掌握语法分析程序设计的原理和构造方法，训练掌握开发应用程序的基本方法。
【实验内容】◆根据某一文法编制调试LL （1 ）分析程序，以便对任意输入的符号串进行分析。
◆构造预测分析表，并利用分析表和一个栈来实现对上述程序设计语言的分析程序。
◆分析法的功能是利用LL（1）控制程序根据显示栈栈顶内容、向前看符号以及LL（1）分析表，对输入符号串自上而下的分析过程。
【设计思想】（1）、LL（1）文法的定义LL(1)分析法属于确定的自顶向下分析方法。
LL(1)的含义是：第一个L表明自顶向下分析是从左向右扫描输入串，第2个L表明分析过程中将使用最左推导，1表明只需向右看一个符号便可决定如何推导，即选择哪个产生式(规则)进行推导。
LL(1)文法的判别需要依次计算FIRST集、FOLLOW集和SELLECT集,然后判断是否为LL(1)文法,最后再进行句子分析。
需要预测分析器对所给句型进行识别。
即在LL(1)分析法中，每当在符号栈的栈顶出现非终极符时，要预测用哪个产生式的右部去替换该非终极符；当出现终结符时，判断其与剩余输入串的第一个字符是否匹配，如果匹配，则继续分析，否则报错。
LL(1)分析方法要求文法满足如下条件：对于任一非终极符A的两个不同产生式A→α,A→β，都要满足下面条件：SELECT(A→α)∩SELECT(A→β)=∅（2）、预测分析表构造LL(1)分析表的作用是对当前非终极符和输入符号确定应该选择用哪个产生式进行推导。
它的行对应文法的非终极符，列对应终极符，表中的值有两种：一是产生式的右部的字符串，一是null。
若用M表示LL(1)分析表，则M可表示如下：M: VN×VT→P∪{Error}M(A, t) = A→α，当t∈select(A→α) ，否则M(A, t) = Error其中P表示所有产生式的集合。
实验三 LR(1)分析表语法分析报告
学生实验报告（理工类）课程名称：编译原理专业班级：08计算机科学与技术(单)本所属院部：信息技术学院指导教师：洪蕾20 10 ——20 11 学年第二学期金陵科技学院教务处制实验报告书写要求实验报告原则上要求学生手写，要求书写工整。
若因课程特点需打印的，要遵照以下字体、字号、间距等的具体要求。
纸张一律采用A4的纸张。
实验报告书写说明实验报告中一至四项内容为必填项，包括实验目的和要求；实验仪器和设备；实验内容与过程；实验结果与分析。
各院部可根据学科特点和实验具体要求增加项目。
填写注意事项（1）细致观察，及时、准确、如实记录。
（2）准确说明，层次清晰。
（3）尽量采用专用术语来说明事物。
（4）外文、符号、公式要准确，应使用统一规定的名词和符号。
（5）应独立完成实验报告的书写，严禁抄袭、复印，一经发现，以零分论处。
实验报告批改说明实验报告的批改要及时、认真、仔细，一律用红色笔批改。
实验报告的批改成绩采用百分制，具体评分标准由各院部自行制定。
实验报告装订要求实验批改完毕后，任课老师将每门课程的每个实验项目的实验报告以自然班为单位、按学号升序排列，装订成册，并附上一份该门课程的实验大纲。
实验项目名称： LR(1)分析表语法分析实验学时： 6 同组学生姓名：无实验地点： B513 实验日期： 2011.4.7/4.21 实验成绩：批改教师：批改时间：一、实验目的和要求语法分析主要目的是按照程序语言的语法规则,从由词法分析输出的源程序符号串中识别出各类语法成分,同时进行语法检查,为语义分析和代码生成作准备.语法分析程序在分析过程中检查符号串是否为该程序的句子.若是则输出该句子的分析树,否则就表示源程序存在语法错误,并报告错误的性质与位置.二、实验仪器和设备主机一台：有Visual Studio 2005工具三、实验过程说明：此程序共有两个类，Lexical进行词法分析，Syntax进行语法分析.对于语法分析，采用LR(1)分析法，判断程序是否满足规定的结构.1：LR-table.txt：存放分析表，其中正数表示移进，负数表示归约，100表示接受状态，0表示不操作。
编译原理词法分析和ll(1)文法判定
struct SYMINFO//词法分析信息结构体
{
int num;
struct SYM sym[MAX_SYM];
struct FORM form;
};
//取词函数(返回读字符数量,如果是0则表示结束,lin表示当前行数)
int __stdcall getsym(const char *in,struct SYM *out,int *ln,struct FORM *form);
#include <stdlib.h>//For memset()
#include <string.h>//For strcpy()
#define ISLETTER(c)((c)>='A'&&(c)<='Z'||(c)>='a'&&(c)<='z')
#define ISNUMBER(c)((c)>='0'&&(c)<='9')
#define IDC_INPUT 1001
#define IDC_OUTPUT 1003
#define IDC_ERRPUT 1004
#define IDC_BUTTON1 1005
#define ID_START 40001
#define ID_ABOUT 40003
#define ID_OPEN 40005
out->id=ERR_OVERNUMFORM;
return m+n;
}
form->numf[form->numnum].id=form->numnum;
编译原理-实验3-LL(1)分析文法构造
集美大学计算机工程学院实验报告课程名称：编译原理指导教师：付永钢实验成绩：实验编号：实验三实验名称：LL(1)语法分析器的构造班级：计算14姓名：学号上机实践日期：2017.6上机实践时间：6学时一、实验目的1、掌握LL(1)分析法的基本原理；2、掌握LL(1)分析表的构造方法；3、掌握LL(1)驱动程序的构造方法。
二、实验环境Ubuntu三、实验原理1、对文法要求LL(1)分析法属于自顶向下分析方法，因此需要预测匹配的产生式。
即在LL(1)分析法中，每当在符号栈的栈顶出现非终结符时，要预测用哪个产生式的右部去替换该非终结符。
LL(1)分析方法要求文法满足如下条件：对于任一非终结符A，其任意两个产生式A→α,A→β，都要满足下面条件：First(A→α)∩First(A→β)=∅2、分析表构造LL(1)分析表的作用是对当前非终结符和输入符号确定应该选择用哪个产生式进行推导。
它的行对应文法的非终结符，列对应终结符，表中的值有两种：一是产生式的编号，一是错误编号。
若用T表示LL(1)分析表，则T可表示如下：T: V N×V T→P∪{Error}T(A, t) = A→α，当t∈First(A→α)T(A, t) = Error，否则其中P表示所有产生式的集合。
显然，一个文法G是LL(1)文法，当且仅当T的元素包含唯一的一个产生式或Error。
3、驱动程序构造LL(1)分析主要包括以下四个动作，其中X为符号栈栈顶元素，a为输入流当前字符。
●替换：当X∈V N时选相应产生式的右部β去替换X。
●匹配：当X∈V T时它与a进行匹配，其结果可能成功，也可能失败，如果成功则符号栈中将X退栈并将输入流指针向前移动一位，否则报错。
●成功：当格局为（空，空）时报告分析成功。
●报错：出错后，停止分析。
四、实验内容已知文法G[E]:E→E+T|TT→T*F|FF→(E)|i说明：终结符号i为用户定义的简单变量, 即标识符的定义。
编译原理-LL(1)文法源代码(实验三)
一、实验目的及要求1．掌握LL(1)分析法的基本原理；2．掌握LL(1)分析表的构造方法；3．用LL（1）分析法分析高级语言表达式。
4、了解LL（1）分析器的工作过程。
文法：无二义性的算术表达式的文法（1）把词法分析作为语法分析的子程序实现（5分）（2）独立的语法分析程序（4分）（3）对表达式文法消除左递归、构造LL（1）分析表（4）LL（1）分析表可以直接输入（4分），也可以用程序实现（5分）（5）给一个表达式，给出分析过程（分析栈、输入串、所用规则）（4分）（6）生成一个棵语法树（5分）用二叉树的形式表示出来二、实验内容及原理1、实验原理（1）、LL（1）文法的定义LL(1)分析法属于确定的自顶向下分析方法。
LL(1)的含义是：第一个L表明自顶向下分析是从左向右扫描输入串，第2个L表明分析过程中将使用最左推导，1表明只需向右看一个符号便可决定如何推导，即选择哪个产生式(规则)进行推导。
LL(1)文法的判别需要依次计算FIRST集、FOLLOW集和SELLECT集,然后判断是否为LL(1)文法,最后再进行句子分析。
需要预测分析器对所给句型进行识别。
即在LL(1)分析法中，每当在符号栈的栈顶出现非终极符时，要预测用哪个产生式的右部去替换该非终极符；当出现终结符时，判断其与剩余输入串的第一个字符是否匹配，如果匹配，则继续分析，否则报错。
LL(1)分析方法要求文法满足如下条件：对于任一非终极符A的两个不同产生式A→α,A→β，都要满足下面条件：SELECT(A→α)∩SELECT(A→β)=∅（2）、预测分析表构造LL(1)分析表的作用是对当前非终极符和输入符号确定应该选择用哪个产生式进行推导。
它的行对应文法的非终极符，列对应终极符，表中的值有两种：一是产生式的右部的字符串，一是null。
若用M表示LL(1)分析表，则M可表示如下：M: VN×VT→P∪{Error}M(A, t) = A→α，当t∈select(A→α) ，否则M(A, t) = Error其中P表示所有产生式的集合。
LL（1）文法分析表的构造和分析过程示例
LL（1）⽂法分析表的构造和分析过程⽰例在考完编译原理之后才弄懂，悲哀啊。
不过懂了就好，知识吗，不能局限于考试。
⽂法：E→TE'E'→+TE'|εT→FT 'T'→*FT'|εF→id| (E)⼀、⾸先判断是不是 LL(1)⽂法--------------------------------------------------------------------------------------------------------⽂法G的任意两个具有相同左部的产⽣式 A --> α|β满⾜下列条件：1、如果α和β不能同时推导出ε，则 FIRST（α）∩FIRST(β) = 空2、α和β⾄多有⼀个能推导出ε3、如果β --*--> ε ,则 FIRST（α)∩ FOLLOW（A）＝空--------------------------------------------------------------------------------------------------------对于 E'→+TE'|ε，显然ε --> ε， First(+TE') = {+} ，Follow(E') = {{),#} 显然⼆者交集为空满⾜。
对于 F→id|(E) ，First(id) = {id} First((E)) = {(} 显然⼆者交集为空满⾜。
所以该⽂法是LL(1)⽂法。
⼆、计算出First集和Follow集参考：三、构建LL(1)分析表输⼊：⽂法G输出：分析表M步骤：1、对G中任意⼀个产⽣式 A --> α执⾏第2步和第3步2、for 任意a ∈ First(α)，将 A --> α填⼊M[A,a]3、if ε∈ First(α) then 任意a ∈ Follow(A)，将 A --> α填⼊M[A,a]if ε∈ First(α) & # ∈Follow(A)， then 将 A --> α填⼊M[A,#] （觉得这步没⽤）4、将所有没有定义的M[A,b] 标上出错标志（留空也可以）--------------------------------------------------------------------------------------------------------过程就不赘述了，结果：四、分析过程步骤：1、如果 X = a = # 则分析成功并停机2、如果 X = a != # 则弹出栈顶符号X, 并将输⼊指针移到下⼀个符号上3、如果 X != a，查询分析表M[X,a] , 如果 M[X,a] = {X --> UVW}，则⽤UVW (U在栈顶) 替换栈顶符号 X。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验3 ＬL(1）文法构造一、实验目的熟悉ＬL（１）文法的分析条件,了解LL(1)文法的构造方法。
二、实验内容1、编制一个能够将一个非LＬ(1)文法转换为ＬL（1）文法；２、消除左递归;3、消除回溯。
三、实验要求1、将一个可转换非ＬL(1）文法转换为LＬ（1）文法,要经过两个阶段，1）消除文法左递归，2）提取左因子，消除回溯。
2、提取文法左因子算法:１）对文法G的所有非终结符进行排序２)按上述顺序对每一个非终结符Pi依次执行:foｒ( j=1; j＜ i-１；j++）将Pj代入Pi的产生式(若可代入的话）;消除关于Pi的直接左递归:Pi －＞ Pｉα|β ,其中β不以Ｐi开头,则修改产生式为：Pi —> βPi′Pｉ′—＞αPi′｜ε3)化简上述所得文法。
3、提取左因子的算法:Ａ—＞δβ1｜δβ2|…|δβn|γ１｜γ2|…|γｍ(其中,每个γ不以δ开头) 那么,可以把这些产生式改写成A —＞δA′｜γ1| γ２…|γｍA′—>β１|β2|…|βn4、利用上述算法,实现构造一个LL（1）文法:1）从文本文件ｇ．ｔｘｔ中读入文法,利用实验1的结果，存入实验１设计的数据结构；2）设计函数remove_left_ｒeｃｕrｓioｎ(）和remoｖｅ_left＿gｅne()实现消除左递归和提取左因子算法，分别对文法进行操作,消除文法中的左递归和提出左因子；3）整理得到的新文法;4）在一个新的文本文件neｗg．txt输出文法，文法输出按照一个非终结符号一行,开始符号引出的产生式写在第一行,同一个非终结符号的候选式用“｜”分隔的方式输出。
四、实验环境ＰC微机DOS操作系统或Wiｎdoｗｓ操作系统Turbo Ｃ程序集成环境或ViｓuａｌC＋+ 程序集成环境五、实验步骤１、学习LＬ（1）文法的分析条件;２、学习构造LL(1）文法的算法;3、结合实验１给出的数据结构，编程实现构造ＬＬ（1）文法的算法;4、结合实验1编程和调试实现对一个具体文法运用上述算法,构造它的LＬ（１）文法形式;5、把实验结果写入一个新建立的文本文件。
六、测试数据输入数据：编辑一个文本文文件g.txt,在文件中输入如下内容：ﻩ正确结果：本实验的输出结果是不唯一的，根据消除左递归是选择非终结符号的顺序不同,或选择新的非终结符号的不同,可能会得到不同的结果,下面只是可能的一个结果:1、P-＞P之类的）,也不含以ε为右部的产生式。
一个文法要能进行ＬL（1）分析，那么这个文法应该满足:无二义性,无左递归，无左公因子。
首先需要定义一些规则：1.在程序运行前文法就必须输入进文本文件中,输入的文法只包含其中的所有产生式，并且默认其为可转换的非ＬＬ（1）文法，即通过消除左递归和反复提取公共左因子,就转换成了LL（１)文法。
2.输入的产生式为原实验1的结果，即一个非终结符只有一条产生式，候选之间用“｜”隔开。
3.产生式与产生式之间只能以换行符或分号隔开。
4.开始符号对应的产生式必须第一个输入,即默认输入的第一个产生式的左部的大写字母是开始符号。
5.输入与输出都会保存在文本文件中文件名分别是g.txt和newg.ｔxｔ,本实验测试数据时，将两个文本放在了桌面。
6.ε用@代替,输入与输出都使用@。
7.新产生的非终结符统一使用没有在非终结符集合中出现的大写字母。
8.规定产生式最多只有20个。
2、构造LL(１)文法的算法；算法:1)从文本文件g．txt中读入文法，存入结构体中。
将第一个读到的大写字母记为开始符号S，将读到的包括开始符号在内的所有大写字母判定为非终结符,并将第一次出现的存入文法的非终结符集合中,终结符小写字母也一样。
将以换行符或分号隔开的字符串判断为一条产生式存入文法中。
实现函数是sｃａnP()。
2)对文法中的产生式消除左递归。
实现函数是ｒemovｅ_ｌeft_ｒeｃｕｒsｉoｎ()。
3)对文法中的产生式反复提取公共左因子。
实现函数是remoｖe_lｅfｔ_ｇｅne()。
4)向newg.txｔ中输出文法的所有产生式。
3、消除左递归文法和提取左因子算法实现方法；消除左递归文法（包括其中用到其它的子函数):/*字符串分割函数，将产生式右部的候选返回,识别‘|’,从ｐoｓ位开始分割*/sｔring strsplｉt（ｓｔｒiｎg ｓtrTok,intｐos) ｛ﻩﻩﻩstring ｓｔｒ；size＿t position;posｉtion = strTok．find("|＂,pｏｓ);ｉf（pｏｓition != strinｇ:：ｎpos） {ﻩ//找到了‘|’ﻩｓｔr ＝ strTok.ｓuｂｓtr（ｐos,pｏｓitiｏn - ｐｏs);}eｌsｅ { ﻩﻩﻩﻩﻩ／/没找到ﻩﻩstr=sｔrＴｏｋ．ｓuｂstｒ（pｏs, strＴｏｋ.siｚe()-ｐos);ﻩ}ﻩreturn str;}/*获得一个文法中尚未定义的非终结符，即特定的大写字母*/chａｒ GetＷorｄ(ｃｈar*p) {ﻩｃｈar ch,wｏrd[] = ｛'A', 'B', 'C','D','E＇, ＇F＇，＇Ｇ', 'Ｈ', ＇I'，'J', 'K'，＇L', 'Ｍ＇，'N'，'O',＇Ｐ', 'Q',ﻩ'R'，'S＇，'Ｔ', 'U', 'V', 'W', 'X','Y'，＇Z＇｝；ﻩint w,x;for（w = ０; w < 26；ｗ++){ﻩｃh =wｏrd[ｗ］;ﻩｆor (x = 0； x< ｍ; x+＋) {ﻩif（cｈ == p[x]) {ﻩｂreaｋ;ﻩﻩ}ﻩ}ﻩｉf（x =＝ m）break;}ﻩｒetｕrn ch;｝/＊判断非终结符是否已存在*/ｂｏoｌ checkWord(char cｈ, string Vn）｛intｉ；ﻩbool fｌａg= ｔrue;ﻩfor（i = 0; i < Vｎ.size(); i＋＋) {ﻩif(cｈ == Vn[i])ﻩflａg =ｆalｓe;ﻩ}ﻩｒeturn flag;}/＊化简无用产生式*/void simplｉfy(ｓtｒuctｇraｍmar＊gp) {stringｓtr; ﻩ//存储从开始符号可以到达的非终结符的序列iｎt sVn[２０]; ﻩﻩ//标记在哪个产生式ﻩsVn［0] ＝0;ﻩstｒ．iｎsert(0, １，ｇp->Vn[0]);ﻩﻩﻩ//初始化设置开始符号ﻩbool flaｇ[2０];flａg[0] = fａlse;ﻩﻩﻩ//标记哪个产生式需要删除chａｒch；int i,j,k,l,o;fｏr(i = 0; i < str.sｉzｅ(）; i＋+) {fｏr (j＝ 3; j < gp->P［sVn［ｉ]］．size();j++) {ﻩﻩfor(k =0;ｋ< m;k+＋） {ﻩif(gｐ－＞Ｐ［ｓVn[ｉ]][j］＜'Ａ'｜| ｇp->Ｐ[sVn［i]]［ｊ] > 'Z＇)ｂrｅａk; //不是非终结符无需判断ﻩif(ｇp->P［sVn[i]］［j］＝= gp->Vn[ｋ]) { ﻩﻩﻩ//判断从开始符号可以到达的非终结符在Vn的哪个位置ﻩｆlag[k] = false;ｉｆ（cｈｅckWord（gp－>Vn[k],ｓtr)) { ﻩﻩ//将在str中没有的有用非终结符插入strﻩint e =sｔr.size();ﻩﻩﻩﻩｓＶn[ｅ] =ｋ;ﻩｓtr.ｉnsert(str.size(), 1,gp－>Vn［k］);ﻩﻩﻩﻩﻩ}ﻩﻩﻩﻩbrｅａｋ;ﻩﻩﻩ}ﻩﻩ｝ﻩ}｝ｆor（ｌ = 0; l <m； l++） {ﻩ/／删除无用的产生式和相应的非终结符ﻩcharｃh;ﻩﻩif (flaｇ[ｌ］) ｛ﻩｇp－>Ｖn[l]＝''；ﻩﻩfor（ｏ = l + 1；ｏ＜ｍ; o+＋) {ﻩﻩch =gp->Vｎ[ｏ -1］;ﻩgｐ-＞Vn[o －1] ＝ gｐ－>Vn[o];ﻩﻩgp->Ｖn[ｏ] = ch;ﻩﻩﻩgp－＞P[ｏ - 1］.clｅar（）;ﻩgｐ－>Ｐ[ｏ - 1].swａp(gp->P[o］);ﻩﻩ｝m－-;ﻩ}}}ｖoｉdｒemｏve_ｌeft_reｃursion(struｃt gｒammaｒ*gp) { ／/子函数，消除文法左递归ﻩｉnt i, j,num_i,ｎum_j,ipoｓ,jpoｓ;chａr ch_i,ch_j；ﻩfｏｒ (i =1; i < m + １；ｉ＋+) {ﻩｂooｌ rｅpeat = ｔrue；ﻩﻩﻩ／/标记相对于本轮循环上轮过程产生式是否有过变化，有则需要重新分割得到候选num_i=0，ipｏs＝ 3;ﻩｓtrｉng str＿ｉ［2０]，rｅｓｔr_i[２0］， ex ＝"ａ";ﻩﻩcｈ＿i = gｐ->Vn[ｉ-1］; ﻩﻩ／／获取当前要被处理的非终结符,即Ｐi ﻩ//分割产生式，得到右部的所有候选while (ipos !=ｇp->P[ｉ - 1].sｉｚe()+ 1） {ﻩﻩstｒ_i[num_i] = strｓpｌit(gp-＞Ｐ[i －1],ipos)；ﻩﻩrestｒ_ｉ[nuｍ_ｉ]=str_ｉ［num_i];ﻩﻩipos = ipｏs＋ sｔｒ＿i[nuｍ＿i]．ｓize（) + 1；ﻩnum_i++;}ﻩfoｒ(j = 1;j <= i - 1；j+＋) {ﻩiｆ (!repeaｔ）｛ﻩﻩｎum_ｉ =０, iｐos = 3;ﻩﻩcｈ_i= gp->Vn[i - 1];ﻩﻩﻩﻩ/／重新获取当前要被处理的非终结符，即Piﻩﻩﻩ/／分割产生式,得到右部的所有候选ﻩwhile（ipos！＝ gp->Ｐ[i －1].ｓizｅ（) + 1) ｛ﻩﻩﻩstr_i[num_i]= stｒsｐｌｉt(gp->P[i -1], ipｏs);ﻩﻩﻩﻩｒeｓｔr_i[num_i］ = stｒ_i[ｎｕｍ_i］;ﻩipoｓ =ipｏs + str_i[num_ｉ].siｚe()+1;ﻩﻩﻩnum_ｉ++;ﻩﻩﻩ｝ﻩﻩ}ﻩrｅpeat= ｔｒue;ﻩstring str_j[20];ﻩﻩｉntｌ；ﻩﻩjpos = 3;ﻩﻩnum_j＝ 0;ﻩch＿j = gp-＞Vn［j - 1］；ﻩﻩﻩﻩ/／获取当前要替换的非终结符,即Pj /／分割产生式,得到右部的所有候选ﻩﻩwhile (jpｏs！= gp－>P[j - 1].size（) + 1）｛ﻩﻩsｔr_j[ｎum_ｊ］ = sｔrspliｔ(gp－＞P［ｊ－1], jpos);ﻩﻩﻩjpｏs = ｊpｏs ＋ｓtr_j［num_j].sｉze() +1；ﻩﻩｎum_j＋+;ﻩ}ﻩﻩｆor（l = 0; l ＜ nuｍ_i; l＋+) { //逐个判断Pi的候选中是否含有Ｐj，有则进行替换ﻩﻩstrｉｎg change;ﻩﻩｅｘ[0]= ch_j;ﻩsize_t pos=reｓtr_ｉ［ｌ].fiｎd(ex)；ﻩﻩﻩﻩﻩﻩｉf(poｓ=＝ strinｇ:：nｐos) {coｎｔiｎue;} ﻩ／/无需替换ﻩﻩﻩelse iｆ (poｓ ==0）｛ﻩﻩﻩﻩﻩ/／Pj在该候选的第一个字符ﻩﻩﻩﻩﻩreｐeat = false;//ﻩﻩﻩstriｎg ｓ= stｒ_i[ｌ].sｕbsｔｒ(1,sｔr＿i[l].ｓizｅ()- 1);ﻩﻩ/／得到候选中除Pｊ外的剩余部分ﻩﻩﻩﻩstr＿ｉ[l］．sｗａp(ｃｈange）;ﻩﻩﻩ//清空字符串ﻩﻩﻩiｎtｌink=0;ﻩﻩｗhiｌe（1){ ﻩﻩﻩﻩ//将Pj的所有候选与Pi中匹配的候选的剩余部分连接,中间还添加“｜”ﻩﻩﻩif（link ＝= nｕm＿j) bｒeak;ﻩﻩstｒ＿j[link]+= s; ﻩﻩﻩﻩﻩﻩﻩﻩﻩｉf (link =＝ nuｍ_ｊ -1)ﻩﻩｓtr_i[ｌ] ＋=stｒ＿j[ｌink］;ﻩﻩﻩｅｌse sｔr_i[l] =str_i［ｌ] +str_j[lｉｎk］ + ＂｜";ﻩﻩﻩﻩlink++;ﻩﻩﻩﻩ}ﻩ}ﻩﻩelse if (pos ＝=stｒ_ｉ[l].siｚe()-１）｛//Pj在该候选的最后一个字符ﻩﻩreｐeａt =false；//ﻩﻩsｔrinｇ s ＝stｒ_ｉ[l].sｕbstｒ(0, str_i［ｌ].sｉzｅ（) -1);ﻩstｒ_i[l].swap(change）;ﻩﻩｉｎt link = 0;ﻩwhile(1）{ﻩﻩﻩﻩﻩﻩiｆ (link ＝= num_j)ﻩbreak;ﻩﻩstｒ_j[link] ＝ s +str_j［liｎｋ];ﻩﻩﻩﻩﻩif (ｌink == ｎum_ｊ－ 1) ﻩstr_i[l] +＝ｓtr_j[link];ﻩﻩﻩﻩelseﻩﻩstr_i[l]＝ str_i［ｌ]+ str_j[lｉnk］ + ＂|";ﻩﻩﻩﻩlink++;}ﻩﻩ}ﻩelｓe｛ﻩﻩﻩﻩ/／Pj在该候选的中间ﻩﻩﻩrｅpｅａｔ = fａｌsｅ;/／ﻩﻩﻩｓｔring s１ = str_i［l]．suｂstr(0,pos - １)；//得到该候选中Pj前的字符串ﻩﻩstring s2 = ｓtｒ＿i[l].ｓｕｂｓｔｒ（pos + １, str_i[l].sｉｚe()- pos- 1）;//得到该候选中Pj后的字符串ﻩﻩstr_i[ｌ]．ｓwａp(change);ﻩﻩintｌink ＝０;ﻩﻩwhｉle (1) {ﻩﻩﻩﻩﻩﻩﻩif（lｉnk == num_j) brｅａk;ﻩﻩsｔｒ_j［link］＝ｓ1 + ｓtr＿j[lｉnk] ＋ｓ2;ﻩif (ｌiｎk == num_ｊ－ 1) str_i［ｌ］+＝ｓtr_j［lｉnk］;ﻩﻩﻩeｌseﻩﻩｓtr_i[l] ＝ stｒ_i[l] + ｓｔr_ｊ[link]＋"|＂；ﻩﻩﻩlink+＋;ﻩﻩﻩﻩﻩ｝ﻩﻩﻩ｝ﻩﻩ}ﻩstｒｉｎｇ stｒi ="->";ｓtri.inserｔ(0，１,ch＿i);ﻩint indｅx = 0;ﻩﻩｗhiｌe (１) {ﻩﻩ/／将替换后的Pi的所有候选进行重组并存进文法中ﻩﻩﻩif (index ==ｎｕm＿i) ｂreak；ﻩif (index== ｎum＿i - １) ｓtri = stri+ ｓtr_i[inｄex］；ﻩﻩelｓeｓtｒi= sｔri ＋ str_i[index］ + "｜";ﻩﻩﻩindｅｘ++;ﻩ}ﻩﻩgp->P［ｉ－1] = stｒi;ﻩ}ﻩ／/消除直接左递归striｎg splｉtstr[30], reｓpliｔｓtr[30];ﻩﻩint s =0,ps = ３,h= 0；ﻩwhiｌe（1) ｛ﻩﻩﻩﻩ//分割替换后的产生式ﻩﻩﻩspliｔstr［ｓ] = ｓｔrsplit(gp->Ｐ[i －１], ps);ﻩﻩﻩresplitstr[s] = ｓplitstr[s]；ｐs= ｐs＋ sｐlｉtｓｔr[s］.sizｅ（）＋ 1;ﻩﻩﻩｉｆ（ps ==ｇp-＞Ｐ[ｉ－１].siｚe() + 1）ﻩﻩbreaｋ；ﻩﻩｓ++；ﻩ}strｉng Ｐｉ="->",Ｐｉｃhaｎｇe = "->＂;ﻩPｉ = ch_i ＋Ｐi;ﻩiｎtｌiｎk ＝０,flag = -1；ﻩboｏｌ flaｇｐoｓ[30];ﻩﻩｃｈar neｗＷoｒd;fｏr(;ｌｉｎk <= s; ｌｉnk++) {//遍历所有候选,校验其中是否有左递归ﻩﻩsｉze＿ｔpoｓｉ；poｓi = resplitｓｔr[lｉｎk].fｉnｄ(ｃh_i)；ﻩｉf (posｉ =＝ 0）{ﻩﻩﻩﻩ//存在直接左递归ﻩﻩfｌag++; ﻩ//对候选标记左递归ﻩﻩif (flａｇ == ０）{ﻩﻩﻩ／/处理出现左递归的第一个候选ﻩﻩﻩneｗＷｏrｄ =GetWoｒd（gp->Vn）；ﻩﻩ//获取一个新的非终结符ﻩﻩﻩﻩｇp－>Vn[m] ＝ nｅwＷｏrd;ﻩPｉchａngｅ＝ｎewWｏrd+ Ｐichange;ﻩﻩﻩｍ+＋;ﻩﻩﻩﻩｓplitｓtr[lｉnk] ＝sｐｌｉｔsｔr[link].ｓｕｂｓｔr（1) +nｅwＷord;ﻩｆｌａgpos[liｎk] = false;ﻩﻩﻩgp->P[ｍ - 1］ = Pｉchａnｇｅ + ｓplｉtstr[ｌiｎk] + ＂|";}ﻩﻩﻩiｆ(ｆｌag > 0){ﻩﻩsplitstr[link］＝ sｐlｉtｓｔr[liｎk］.substr（1) + neｗＷｏrd;ﻩfｌaｇｐos［ｌink］= falｓｅ;ﻩﻩﻩﻩgp->Ｐ［m- １] = gｐ->P[m -1] +splitsｔr[link］ +＂|";ﻩﻩ｝ﻩ}ﻩ}ﻩ//对消除了直接左递归的候选进行重组成为产生式并存入文法ﻩif (ｆlaｇ＞ -1）｛ﻩﻩﻩgｐ->Ｐ［i- 1］ = ＂->＂;gp->P[i- 1].inserｔ(0, １, cｈ＿ｉ);for (;h ＜＝s; h++） {ﻩﻩﻩﻩif(ｆlａgpｏs[ｈ]){splｉｔstｒ［h]+= ｎewWoｒｄ;ﻩﻩgp->P［i - １]= ｇｐ->Ｐ［i- 1]+splitstr［h]+ "｜";ﻩ}ﻩ｝ﻩﻩgp-＞Ｐ[ｍ - １] +＝＂@＂;ﻩﻩgp->Ｐ［ｉ - 1］.eｒａse(ｇp->P[ｉ- 1］.size() -1, 1);ﻩ}}simplｉfy（gｐ); ﻩ//化简无用的产生式}提取左因子(包括辅助函数)://对字符串数组排序vｏｉd stｒ_sｏrｔ(ｓｔriｎg *ｓtr, iｎｔ nuｍ） {ﻩint i, j；for（i = 0; i < num;i++）｛for（ｊ = i+ 1; j < num; j++） {ﻩﻩif (ｓtr[ｉ］ > str[ｊ］)ﻩstr[i］.ｓwap(str[j]）;}}｝/*子函数,提取左因子*/vｏidｒemｏve_ｌｅft_ｇene（strucｔgrammar *ｇｐ) ｛ﻩint ruｌe_a, i， j，k, l，maｔcｈnuｍ,oldｍａtｃｈnum, resize,sizｅ;ﻩｃhaｒ ch， nｅwＷord;ﻩfor (ruｌｅ_a = 0； rｕle_a < m; rule_a++) ｛ﻩﻩ//遍历所有产生式ﻩint bre ＝－1;ﻩﻩﻩ//标记已对产生式进行过左因子的提取ﻩｉnt oldｐo＝ 0；int num =0, ps = 3；sｔring ｓtr[３0],restr[３０];ﻩﻩﻩﻩ／/前者用于判断，需要保持原样，后者用于对有公共左因子的候选进行提取,可变whiｌｅ (ps != gp-＞P[rulｅ_a].size（) + 1) {ﻩﻩ/／分割替换后的产生式ﻩﻩﻩｓtr［num]= strspｌｉt(ｇp-＞Ｐ[ｒulｅ＿a], ｐs）;ﻩﻩｒestｒ[nuｍ] =str[nｕm］;ﻩﻩps=ps + ｓtr[nuｍ]．sｉｚe（) + １；ﻩnｕm++;ﻩﻩ}ｓtｒ_sort(stｒ, num);ﻩﻩﻩﻩﻩﻩ//对所有候选按ASCII码进行排序，以便于简化对公共左因子的判断，只需先对前面候选判断ﻩsｔr＿ｓort(ｒｅstr, num);ﻩiｎt ca_ｉ;striｎｇPa ＝"->";ﻩﻩPa.ｉnseｒt(0,1, gp->Vn［rｕｌe＿ａ])；ﻩfoｒ (ca＿i = 0; cａ_i<nｕｍ; ca_i+＋) ｛//对排序后的候选进行重组并存入文法ﻩｉｆ (ca＿i ＝＝ num - 1)ﻩﻩPa+＝ｓtｒ［ca_ｉ］；ﻩelseﻩPa +＝ str［ca_i]+ ＂|＂;ﻩ}ｇｐ-＞P[ruｌe_a] ＝Ｐa;ﻩﻩintｉpo ＝ 0；ﻩ//辅助免除对已判断过有左因子的候选的遍历ﻩﻩｆor（ｉ = 0; ｉ <num; i++,i += ipo） {ﻩ//遍历候选ﻩﻩiｐｏ = 0;sizｅ＝ 0;ﻩﻩresize ＝0；ﻩolｄmaｔchnuｍ＝０；ﻩﻩint i_s = str[ｉ］.ｓｉze();ﻩﻩfoｒ(j=0;j< i_ｓ; j++） {ﻩ//对候选的逐个字符遍历ﻩmatcｈnum = 0; ﻩ//标记除了本身，有几个候选有公共左因子ﻩﻩﻩch ＝ stｒ[ｉ][j];ﻩﻩﻩｉntｋf = num;ﻩﻩﻩﻩfor(ｋ＝ｉ + 1; k <num＆＆ k ＜ kf； k＋+) { /／对i之后的候选进行判断，是否有与i对应的公共左因子ﻩﻩﻩﻩｉf (str[ｋ］[j]== ch){ﻩ／/有公共左因子ﻩﻩﻩｍatｃhnum++;ﻩ｝ﻩelse{ﻩﻩﻩﻩbreak;ﻩﻩﻩ}ﻩﻩ}ﻩif(ｊ =＝ 0) { ﻩﻩﻩ//判断是否有公共左因子是i的第一个字符的情况,有则特别处理ﻩﻩﻩif（maｔcｈnum ＝= ０)ﻩbｒeak;ﻩﻩelse{ oｌｄmａｔcｈｎｕm =matcｈｎuｍ；ｋf = ｉ+ １ +oｌdmａｔchｎuｍ; }ﻩﻩ}ﻩﻩﻩelsｅ {ﻩﻩﻩﻩif(olｄｍatchnｕm ！=matchnｕm)ﻩｂrｅak;ﻩﻩﻩﻩ}ﻩ}ﻩ/*有公共左因子的处理过程＊/ﻩﻩiｆ (maｔcｈnum ！＝ oldmaｔｃhｎum || j== i_s) {ﻩbｒe ＋+；ﻩﻩstrinｇmatch, repstr， can, newP;ﻩﻩmatcｈ= ｓtr[i]．subｓｔr(0, j)；ﻩﻩ//获取公共左因子ﻩﻩｎｅwWoｒｄ＝ＧetＷoｒd（gｐ-＞Vn); ﻩ//得到新的非终结符ﻩﻩgp->Vｎ［m]= newWord;ﻩ//将新非终结符存入文法ﻩﻩｍ++;ﻩnｅwP = "->";ﻩﻩﻩnewP．inseｒt(0，１, nｅwWord）;ﻩrepstｒ＝ｍaｔch+nｅwＷord；ﻩ／／得到要被替换的有公共左因子的所有候选ﻩﻩﻩiｎt reｎum＝ num；ﻩif (bｒe> 0){ﻩﻩ／/若对同一产生式还存在另一个公共左因子(之前提取过一次左因子），需进行特别处理ﻩﻩsｉzｅ= ｒesize = 0;ﻩﻩrenum= 0;ﻩﻩﻩﻩ ps= 3；ﻩwhile（ｐｓ != gp->P[rulｅ_a].size（) +1）｛／/分割变化后的产生式ﻩﻩresｔr[renｕm］ = ｓtrsplit（gp－>Ｐ[ruｌe_a],pｓ）；ﻩﻩﻩｐs ＝ pｓ + rｅｓtr[rｅnｕm]．sizｅ(） + 1;ﻩﻩﻩﻩreｎｕｍ+＋;ﻩﻩ}ﻩﻩ}ﻩﻩﻩ/*将已经提取过左因子的以候选为单位的字符串重新组合成产生式（包括新产生式)＊/ﻩﻩfｏr（l ＝０; ｌ <=ｉ - oldpo + oｌdmatchｎｕm;l++) {ﻩﻩﻩﻩﻩif (l>＝ i － oｌdｐｏ) ｛ﻩﻩﻩﻩsizｅ +＝ reｓtr[l].siｚe(）;ﻩﻩﻩﻩｃan= resｔr[l].subｓｔr(ｊ）;ﻩﻩｉf (ｃａｎ == "")ﻩﻩｃan="@＂;ﻩﻩﻩﻩiｆ (l ＝= i - olｄｐo + oldｍatcｈnｕm) newＰ＋=can；ﻩﻩﻩﻩｅlｓeﻩnｅwＰ＝ｎewP ＋ can + ＂｜";ﻩﻩgp-＞P[m-1] = nｅwP;ﻩ}ﻩﻩeｌsｅ{ﻩﻩresiｚe += rｅstr[l]．siｚｅ(）;ﻩﻩﻩrｅｓｉｚe+＋；ﻩﻩﻩ}ﻩﻩ}ﻩﻩﻩgp->P［rｕlｅ＿a].reｐｌacｅ(ｒｅsize+ 3，size+ oｌdmatｃhnuｍ, ｒepstr); /／原产生式以替换的方式进行改变ﻩif（ｉ+１ + oldｍaｔcｈnｕm > nｕm）｛break; ｝ﻩﻩﻩﻩｅｌseｏｌｄpo ＝ ipo = oｌdmaｔchnｕm；ﻩ}ﻩﻩ}ﻩ}｝4、主程序代码；#include<iostream>#iｎclude＜ｓtring>usｉnｇｎamespace std；ｓｔructｇrammar｛ﻩﻩﻩ//使用结构体定义文法ｃｈar Vｎ[20];ﻩﻩﻩﻩ//非终结符cｈａr Vt[2０];ﻩﻩﻩﻩﻩ／／终结符ﻩcｈar S; ﻩ//开始符号ﻩstriｎgＰ[2０];ﻩﻩﻩﻩ//产生式}；ｉnｔm＝０, n=0; ﻩﻩﻩ/／全局变量，分别表示最近存入结构体的非终结符与终结符是字符数组的第几个位置char GetＢＣ（FILE* ｆpi) { ﻩﻩ//子函数，用于读取一个非空格字符ｃharｃｈ；do {ｃh= ｆgetｃ（fｐｉ);}wｈile(ｃh ＝= ' '）;ﻩreturn ch;}ﻩ/* 整型函数，读入一行产生式分析出文法成员，参数分别是输入文本的文件指针、文法结构体的指针ﻩﻩ第几行的产生式ﻩﻩ*/voiｄ scanP(FILE＊fｐｉ,strucｔgrａmmar＊ｇp){ﻩﻩﻩﻩﻩﻩｃhａr ch;ﻩsｔrinｇ str; ﻩﻩﻩﻩﻩ／／存入一条产生式ﻩif(feof(ｆpi）) ﻩｒｅtuｒn;ﻩﻩ//到达文件尾则返回cｈ = GetBＣ（fpi);ﻩif(ｃｈ＞= 'Ａ'&＆cｈ <= 'Z'){ﻩ//读入产生式左部的非终结符str+= cｈ;ﻩｇp->Ｖn［m］ = ｃh; ﻩﻩﻩﻩ／/将非终结符存入结构体m++；ﻩcｈ = GetBＣ(fpi)；ﻩif (cｈ== '－') {ﻩｓtr += ch;ﻩch =ＧｅtBC（fpi);ﻩﻩif (ch ＝＝'>'）｛ﻩｓtr ＋=ch;ﻩｗhile (1）｛ﻩﻩﻩch = GｅtBＣ(fpi);ﻩﻩiｆ (ｃh == '\ｎ' |｜ch =＝＇;'）ﻩbreak; ﻩ//读入换行符或分号，退出循环ﻩﻩstｒ＋＝ cｈ；ﻩﻩﻩﻩﻩｉｆ（cｈ>= 'a＇ && ch <= 'z'）{ //读入终结符ﻩﻩﻩﻩﻩintｎum;ﻩﻩﻩfｏr(num = 0;nｕm < n;ｎum++) { /／判断该终结符在当前结构体中是否已存在ﻩﻩﻩiｆ (gp－＞Ｖt［num]== ch）ﻩﻩﻩﻩﻩﻩﻩｂreak;ﻩﻩ}ﻩﻩﻩﻩｉｆ (num == n)｛ﻩﻩﻩ//存入结构体中未出现的终结符ﻩgp->Vt[n]=ｃｈ;ﻩﻩn++;ﻩﻩﻩ}ﻩﻩ}ﻩ}ﻩ｝ﻩ}ﻩgp->P［m - 1] += str;ﻩﻩ/／将产生式存入结构体ﻩ}}intｍain() {ﻩFILE* fpi;ﻩﻩﻩﻩ//定义输入文本指针FＩLE* fpo；ﻩﻩﻩ／／定义输出文本指针eｒrno_t erｒ;ｉf(（ｅrr= fｏpen_s(&fpi,＂Ｃ:＼\Users\＼Administraｔｏｒ＼\Desktｏp\＼ｇ．tx ｔ", "r")) ！= 0）｛ﻩ//只读方式打开文件ﻩﻩprintｆ（"fｉｌe ｃａｎ not open!\n＂);ﻩﻩﻩﻩﻩ//打开文件出错提示ﻩｅｘit（0); ﻩﻩﻩ//安全退出程序ﻩ}struｃtｇrammarｇ, *gｐ;ﻩﻩgp =&g;ﻩﻩﻩﻩﻩ//定义结构体及其指针ﻩ//读取第一个大写字母作为开始符号chａｒ ch;ｄｏ {ﻩcｈ = ＧetBC(fpi);} ｗhiｌe (cｈ<= 'A'|| ch＞＝＇Ｚ＇);ﻩgｐ->S = ｃh;ﻩｆseek(fｐi, －1L, 1); ﻩﻩ//搜索指示器回调一个字符ﻩｗhiｌｅ (!ｆeof(fpi）) ｛ﻩﻩﻩ／／从文本文件中读入产生式得到文法四个部分，并存入结构体中scanＰ（ｆpｉ,ｇp);ﻩﻩﻩ}ﻩfclose(fｐi); ﻩ//关闭fｐi指向的文件ﻩfｐｉ = NUＬＬ;ﻩﻩﻩﻩﻩﻩ／/避免指向非法内存remove_lｅｆt_reｃursion(ｇp)；ﻩｒｅmoｖｅ_leｆt＿gｅnｅ(gp）;eｒｒ = ｆｏpeｎ_s(&fpo,"Ｃ:\＼Users\\Aｄmiｎｉstratoｒ\＼Deskｔｏp\\nｅwg.tx ｔ", ＂w"）; ／/只写方式打开文件,不存在则自动建立iｆ (err!＝０) {ﻩpriｎｔf("file caｎｎｏt open!\n");ﻩﻩﻩﻩﻩ//打开文件出错提示exｉt（0);ﻩﻩﻩﻩﻩ//安全退出程序ﻩ}ｉnt i; ﻩﻩﻩﻩfor (i＝ 0;ｉ < m;i＋＋) ｛ﻩﻩ/／输出处理后的文法到文本中ﻩfpuｔs(gp－>P[ｉ]．ｄata(),fpo)；ﻩｆputs("\n＂,fpｏ）;ﻩ}ｆｃlose(fpｏ); ﻩﻩﻩﻩﻩ//关闭fpｉ指向的文件fｐｏ = NULＬ; ﻩ//避免指向非法内存｝5、整个测试程序的流程；6、程序的测试结果和问题;实验源文法:其它文法:向g.txt中输入文法启动程序main()反复调用scanP()到达文件尾完成文法输入调用remove_left_recursion()调用remove_left_gene()将文法输出到newg.txt程序结束查看结果文法ﻩﻩ书上的文法,不过调换了顺序,且改变开始符号为R,结果会删除关于Q的无用产生式:ﻩﻩﻩﻩ实验中遇到的问题:1.开始设计程序的时候，并没有很好的运用数据结构来简化问题,只是使用了实验一的数据结构,构造了一个结构体。