【8A版】编译原理实验报告FIRST集和FOLLOW集
编译原理中first集合的定义
编译原理中的first集合是指在文法中，一个非终结符号的所有可能的开始终结符号的集合。
在编译过程中，求解文法的first集合有着重要的意义。
下面将从定义、性质、求解方法和应用四个方面来详细介绍first集合。
一、定义在上下文无关文法中，对于一个非终结符号X，它的first集合定义为：1. 如果X可以直接推导出终结符号a，则将a加入X的first集合中；2. 如果X可以通过若干步推导出ε（空串），则将ε加入X的first集合中；3. 如果X可以通过若干步推导出Y1Y2...Yk，其中Y1,Y2,...,Yk是终结符号或者非终结符号，并且Y1不可为空，则将Y1的first集合中的所有元素（除去ε）加入X的first集合中。
二、性质1. first集合是关于文法的。
即不同的文法可能得到不同的first集合。
2. first集合可以为空。
即某些非终结符号的first集合可能为空集。
3. first集合的求解不一定唯一。
即针对同一个文法，可能有多种不同的求解方式。
三、求解方法在对文法的first集合进行求解时，常用的方法有两种：直接法和间接法。
1. 直接法：直接根据first集合的定义，对每个非终结符号进行推导，找出所有可能的开始终结符号。
2. 间接法：先求解终结符号的first集合，然后根据非终结符号的产生式和已经求解出的非终结符号和终结符号的first集合，来逐步求解非终结符号的first集合。
四、应用1. 在LL(1)文法的构造中，first集合的求解是至关重要的步骤。
通过求解文法符号的first集合，可以帮助我们构造出LL(1)文法，从而用于自顶向下的语法分析。
2. 在语法制导翻译中，通过利用first集合，可以帮助我们优化翻译过程，提高翻译的效率和准确性。
3. 在编译器的错误处理中，通过利用文法符号的first集合，可以帮助我们更好地定位并处理语法错误，提高编译器的鲁棒性和容错性。
first集合在编译原理中具有重要的地位和作用，它的求解对于文法分析、语法制导翻译和编译器的错误处理都具有重要意义。
求first集和follow集
{
cout<<s1[i]<<" "<<follow(s1[i])<<endl;
}
return 0;
}
四．实验截图
}
}
}
}
}
return s;
}
//******************************
int main()
{
int i;
string s1,s2;
char b;
cout<<"\t************求First集和Follow集**************"<<endl;
cout<<"请输入产生式的数目：";
}
else
{
rights=p[pos.front()].right;
for(i=0;i<rights.size();i++)
{
if(find(rights[i]))
{
s+=first(rights[i]);
index= s.find_last_of('@');
s=s.erase(index,1);
}
编译原理实验
实验名称：求first集和follow集
姓名：
学号：
教师签字：
成绩：
一．实验目的：
.掌握和了解first集和follow集的求解过程。
二．实验原理：
1.first集的求解：（1）若X∈Vt,则FIRST(X)={X};
(2)若X∈Vn,且有产生式X->a……,a∈Vt，则a∈FIRST(X);
【编译原理】语法分析LL（1）分析法的FIRST和FOLLOW集
【编译原理】语法分析LL（1）分析法的FIRST和FOLLOW集 近来复习编译原理，语法分析中的⾃上⽽下LL(1)分析法，需要构造求出⼀个⽂法的FIRST和FOLLOW集，然后构造分析表，利⽤分析表+⼀个栈来做⾃上⽽下的语法分析（递归下降/预测分析），可是这个FIRST集合FOLLOW集看得我头⼤。
教课书上的规则如下，⽤我理解的语⾔描述的：任意符号α的FIRST集求法：1. α为终结符，则把它⾃⾝加⼊FIRSRT(α)2. α为⾮终结符，则：（1）若存在产⽣式α->a...，则把a加⼊FIRST(α),其中a可以为ε（2）若存在⼀串⾮终结符Y1,Y2, ..., Yk-1，且它们的FIRST集都含空串，且有产⽣式α->Y1Y2...Yk...，那么把FIRST(Yk)-{ε}加⼊FIRST(α)。
如果k-1抵达产⽣式末尾，那么把ε加⼊FIRST(α) 注意（2）要连续进⾏，通俗地描述就是：沿途的Yi都能推出空串，则把这⼀路遇到的Yi的FIRST集都加进来，直到遇到第⼀个不能推出空串的Yk为⽌。
重复1,2步骤直⾄每个FIRST集都不再增⼤为⽌。
任意⾮终结符A的FOLLOW集求法：1. A为开始符号，则把#加⼊FOLLOW(A)2. 对于产⽣式A-->αBβ： （1）把FIRST(β)-{ε}加到FOLLOW(B) （2）若β为ε或者ε属于FIRST(β)，则把FOLLOW(A)加到FOLLOW(B)重复1,2步骤直⾄每个FOLLOW集都不再增⼤为⽌。
⽼师和同学能很敏锐地求出来，⽽我只能按照规则，像程序⼀样⼀条条执⾏。
于是我把这个过程写成了程序，如下：数据元素的定义：1const int MAX_N = 20;//产⽣式体的最⼤长度2const char nullStr = '$';//空串的字⾯值3 typedef int Type;//符号类型45const Type NON = -1;//⾮法类型6const Type T = 0;//终结符7const Type N = 1;//⾮终结符8const Type NUL = 2;//空串910struct Production//产⽣式11 {12char head;13char* body;14 Production(){}15 Production(char h, char b[]){16 head = h;17 body = (char*)malloc(strlen(b)*sizeof(char));18 strcpy(body, b);19 }20bool operator<(const Production& p)const{//内部const则外部也为const21if(head == p.head) return body[0] < p.body[0];//注意此处只适⽤于LL(1)⽂法，即同⼀VN各候选的⾸符不能有相同的，否则这⾥的⼩于符号还要向前多看⼏个字符，就不是LL(1)⽂法了22return head < p.head;23 }24void print() const{//要加const25 printf("%c -- > %s\n", head, body);26 }27 };2829//以下⼏个集合可以再封装为⼀个⼤结构体--⽂法30set<Production> P;//产⽣式集31set<char> VN, VT;//⾮终结符号集，终结符号集32char S;//开始符号33 map<char, set<char> > FIRST;//FIRST集34 map<char, set<char> > FOLLOW;//FOLLOW集3536set<char>::iterator first;//全局共享的迭代器，其实觉得应该⽤局部变量37set<char>::iterator follow;38set<char>::iterator vn;39set<char>::iterator vt;40set<Production>::iterator p;4142 Type get_type(char alpha){//判读符号类型43if(alpha == '$') return NUL;//空串44else if(VT.find(alpha) != VT.end()) return T;//终结符45else if(VN.find(alpha) != VN.end()) return N;//⾮终结符46else return NON;//⾮法字符47 }主函数的流程很简单，从⽂件读⼊指定格式的⽂法，然后依次求⽂法的FIRST集、FOLLOW集1int main()2 {3 FREAD("grammar2.txt");//从⽂件读取⽂法4int numN = 0;5int numT = 0;6char c = '';7 S = getchar();//开始符号8 printf("%c", S);9 VN.insert(S);10 numN++;11while((c=getchar()) != '\n'){//读⼊⾮终结符12 printf("%c", c);13 VN.insert(c);14 numN++;15 }16 pn();17while((c=getchar()) != '\n'){//读⼊终结符18 printf("%c", c);19 VT.insert(c);20 numT++;21 }22 pn();23 REP(numN){//读⼊产⽣式24 c = getchar();25int n; RINT(n);26while(n--){27char body[MAX_N];28 scanf("%s", body);29 printf("%c --> %s\n", c, body);30 P.insert(Production(c, body));31 }32 getchar();33 }3435 get_first();//⽣成FIRST集36for(vn = VN.begin(); vn != VN.end(); vn++){//打印⾮终结符的FIRST集37 printf("FIRST(%c) = { ", *vn);38for(first = FIRST[*vn].begin(); first != FIRST[*vn].end(); first++){39 printf("%c, ", *first);40 }41 printf("}\n");42 }4344 get_follow();//⽣成⾮终结符的FOLLOW集45for(vn = VN.begin(); vn != VN.end(); vn++){//打印⾮终结符的FOLLOW集46 printf("FOLLOW(%c) = { ", *vn);47for(follow = FOLLOW[*vn].begin(); follow != FOLLOW[*vn].end(); follow++){48 printf("%c, ", *follow);49 }50 printf("}\n");51 }52return0;53 }主函数其中⽂法⽂件的数据格式为（按照平时做题的输⼊格式设计的）：第⼀⾏：所有⾮终结符，⽆空格，第⼀个为开始符号；第⼆⾏：所有终结符，⽆空格；剩余⾏：每⾏描述了⼀个⾮终结符的所有产⽣式，第⼀个字符为产⽣式头（⾮终结符），后跟⼀个整数位候选式的个数n，之后是n个以空格分隔的字符串为产⽣式体。
编译原理词法分析,语法分析实验报告
char left[50];
/* 左部 */
char right[50][50];
/* 右部 */
char first[50][50],follow[50][50];
/* 各产生式右部的 FIRST 和左部的 FOLLOW 集合 */
char first1[50][50];
/* 所有单个符号的 FIRST 集合 */
int i,j,k,result=1,mark=0;
char temp[20];
temp[0]=c;
temp[1]='\0';
merge(empt,temp,1);
if(in(c,empty)==1)
return(1);
for(i=0;;i++)
{
if(i==count)
return(0);
if(left[i]==c)
}
/*******************************************
将单个符号或符号串并入另一符号串 ********************************************/
void merge(char *d,char *s,int type)
{
/*d 是目标符号串， s 是源串， type＝1，源串中的‘ ^ ’一并并入目串；
int count=0;
/* 分解的产生式的个数 */
int number;
/* 所有终结符和非终结符的总数 */
char start;
/* 开始符号 */
char termin[50];
/* 终结符号 */
char non_ter[50];
正规文法的First集合Follow集求解过程动态模拟-实验报告
华东交通大学课程设计（论文）任务书软件学院专业项目管理班级2005－4一、课程设计（论文）题目正规文法的First集合Follow集求解过程动态模拟二、课程设计（论文）工作：自2008年6月23 日起至2008年 6 月27 日止。
三、课程设计（论文）的内容要求：1、基本要求：进一步培养学生编译器设计的思想，加深对编译原理和应用程序的理解，针对编译过程的重点和难点内容进行编程，独立完成有一定工作量的程序设计任务，同时强调好的程序设计风格，并综合使用程序设计语言、数据结构和编译原理的知识，熟悉使用开发工具VC 6.0 或其它软件编程工具。
为了使学生从课程设计中尽可能取得比较大的收获，对课程设计题目可根据自己的兴趣选题（须经老师审核），或从老师给定题目中选择完成（具体见编译原理课程设计题目要求）。
通过程序实现、总结报告和学习态度综合考评，并结合学生的动手能力，独立分析解决问题的能力和创新精神。
成绩分优、良、中、及格和不及格五等。
2、具体要求设计一个由正规文法生成Fisrt集Follow集的动态过程模拟动态模拟算法的基本功能是：●输入一个正规文法；●输出由文法构造的First集的算法；●输出First集；●输出由文法构造的Follow集的算法；●输出Follow集；学生签名：2008 年 6 月 27 日课程设计（论文）评阅意见评阅人职称副教授2008 年 6 月 27 日目录一、需求分析 (3)二、总体设计 (4)三、详细设计 (9)四、课设小结 (12)五、谢辞 (13)六、参考文献 (14)一、 需求分析问题描述设计一个由正规文法生成First 集和Follow 集并进行简化的算法动态模拟。
(算法参见教材) 【基本要求】动态模拟算法的基本功能是： （1） 输入一个文法G ；（2） 输出由文法G 构造FIRST 集的算法； （3） 输出First 集；（4） 输出由文法G 构造FOLLOW 集的算法； （5） 输出FOLLOW 集。
计算first集合和follow集合--编译原理教案资料
计算f i r s t集合和f o l l o w集合--编译原理计算first 集合和follow 集合姓名：彦清 学号：E10914127一、实验目的输入：任意的上下文无关文法。
输出：所输入的上下文无关文法一切非终结符的first 集合和follow 集合。
二、实验原理设文法G[S]＝（V N ，V T ，P ，S ），则首字符集为：FIRST （α）＝{a | α⇒*a β，a ∈V T ，α,β∈V *}。
若α⇒*ε，ε∈FIRST （α）。
由定义可以看出，FIRST （α）是指符号串α能够推导出的所有符号串中处于串首的终结符号组成的集合。
所以FIRST 集也称为首符号集。
设α＝x 1x 2…x n ，FIRST （α）可按下列方法求得：令FIRST （α）＝Φ，i ＝1；（1）若x i ∈V T ，则x i ∈FIRST （α）； （2） 若x i ∈V N ；① 若ε∉FIRST （x i ），则FIRST （x i ）∈FIRST （α）；② 若ε∈FIRST （x i ），则FIRST （x i ）－{ε}∈FIRST （α）；（3） i ＝i+1，重复（1）、（2），直到x i ∈V T ，（i ＝2，3，…，n ）或x i ∈V N 且若ε∉FIRST （x i ）或i>n 为止。
当一个文法中存在ε产生式时，例如，存在A →ε，只有知道哪些符号可以合法地出现在非终结符A 之后，才能知道是否选择A →ε产生式。
这些合法地出现在非终结符A 之后的符号组成的集合被称为FOLLOW 集合。
下面我们给出文法的FOLLOW 集的定义。
设文法G[S]＝（V N ，V T ，P ，S ），则FOLLOW （A ）＝{a | S ⇒… Aa …，a ∈V T }。
若S ⇒*…A ，#∈FOLLOW （A ）。
由定义可以看出，FOLLOW （A ）是指在文法G[S]的所有句型中，紧跟在非终结符A 后的终结符号的集合。
first集合和follow集合的求法
first集合和follow集合的求法
FIRST集合和FOLLOW集合的求法如下：
1、FIRST集合的求法：
直接收取：如果X是终结符或为空，则First(X) = {X}。
反复传送：如果X是非终结符，则First集合一直传送下去，直到遇到终结符。
第一个状态减去ε（即空字符串）后加入到First集合中。
注意传送时非终结符是否可以为空，如果可以为空，则看下一个字符。
对于形如“…UP…”（P是非终结符）的组合，把First(P)直接收入到First集合中。
遇到形如E →TE’这样的产生式时，先把First(T)放入First(E)，然后查看T是否能推导出ε（即空字符串）。
如果能，则把First(E’)放入First(E)，以此类推。
若T不能推出ε，则First(E)求完。
2、FOLLOW集合的求法：
对于文法的开始符号S，将识别符号“#”置于FOLLOW(S)中。
若存在产生式A →αBβ，则将First(β) - {ε}加至FOLLOW(B)中。
这里，First(β)表示β能推导出的第一个终结符或非终结符的集合，但要去掉ε。
如果β可以推导出ε，则将FOLLOW(A)加至FOLLOW(B)中。
这意味着，如果B有可能是最后一个符号，那么A的FOLLOW集合应该加入到B的FOLLOW集合中。
反复使用上述规则，直到所求FOLLOW集合不再增大为止。
以上是对FIRST集合和FOLLOW集合求法的简要概述。
在实际应用中，需要根据具体的文法和产生式进行具体的分析和计算。
编译原理实验+求first集和follow集+代码
编译原理实验+求first集和follow集+代码/*说明：输入格式：每行输入一个产生式，左部右部中间的→用空格代替。
非终结符等价于大写字母^ 表示空输入到文件结束，或用 0 0 结尾。
Sample Input：(习题5·3):S MHS aH LSoH ^K dMLK ^L eHfM KM bLM0 0*/#include#include#include#include#includeusing namespace std;char l;string r;multimap sentence; //存储产生式multimap senRever; //产生式逆转set ter; //非终结符集合map toEmpty; //非终结符能否推出空bool flag;set fir; // 保存单个元素的first集set follow; //保存单个元素的follow集vector rightSide; //右部char Begin;bool capL(char c) //字母是否大写{if(c<='Z' && c>='A')return true;return false;}/*bool lowerL(char c) //小写字母{if(c<='z' && c>='a')return true;return false;}*/bool CapLString(string s) // 大写字符串{for(int i=0; iif(!capL(s[i])) {return false;}}return true;}bool isToEmpty(char ch) // 判断终结符能否推出空{bool flag;// for(set::iterator sIter = ter.begin(); sIter!=ter.end(); ++sIter) {flag = false;multimap::iterator mIter = sentence.find(ch);int cnt = sentence.count(ch);for(int i=0; iif(mIter->second=="^") {return true;// toEmpty[ch] = true;}else if(CapLString(mIter->second)){string s(mIter->second);bool flag2 = true;for(int j=0; jif(!isToEmpty(s[j]) || s[j]==ch) {flag2 = false;break;}}if(flag2) { // 右部全为终结符，全能推出空return true;}}}// }return false;}void getFirst(char ch, set &First) //求单个元素的 FIRST集{// if(flag)// return;multimap::iterator imul = sentence.find(ch);if(imul==sentence.end())return;int sum = sentence.count(imul->first);// cout<first<<endl;for(int i=0; i// cout<second<<endl;string s(imul->second);for(int j=0; jif(!capL(s[j])) {// cout<<" "<<s[j]<<endl;First.insert(s[j]);// flag = true;break;}else if(capL(s[j])) {if(s[j]==ch) { //有左递归,跳出循环break;;}getFirst(s[j], First);if(toEmpty[s[j] ]==false) {break;}}}}flag = true;}bool isLast(string s, char ch) //ch 是否是 s 的直接或间接的最后一个非终结符{if(!capL(ch))return false;for(int i=s.size()-1; i>=0; i--) {if(ch==s[i])return true;if(!capL(s[i]) || toEmpty[s[i] ]==false) {return false;}}return false;}void getFollow(char ch, set<cha</cha</s[j]<<endl;</endl;</endl;r> &follow) //求单个元素的 FOLLOW集{if(!capL(ch))return;for(vector::iterator iter=rightSide.begin(); iter!=rightSide.end(); ++iter) {for(int i=0; i<(*iter).size(); i++) {if(ch==(*iter)[i] && i!=(*iter).size()-1) {if(!capL((*iter)[i+1])) {follow.insert((*iter)[i+1]);}else {getFirst((*iter)[i+1], follow);}}if(ch==(*iter)[i] && i==(*iter).size()-1) { //判断是否是右部的最后一个非终结符 follow +#follow.insert('#');}else if(ch==(*iter)[i] && i<(*iter).size()-1){ //不是最后一个但之后全是非终结符且都能推出空 follow +#bool flag1=true;for(int j=i+1;j<(*iter).size(); j++) {if(!capL((*iter)[j]) || toEmpty[(*iter)[j]]==false) {flag1 = false;if(!capL((*iter)[j])) {follow.insert((*iter)[j]);}break;}}if(flag1 == true) {follow.insert('#');}}}if(isLast(*iter, ch)) { //ch是*iter的最后一个符号（直接或间接）int n = senRever.count(*iter);multimap::iterator mIter = senRever.find(*iter);for(int i=0 ;iif(mIter->second!=ch )getFollow(mIter->second, follow);}}}}int main(){int cnt=0;while(cin>>l>>r) {if(cnt==0) {Begin = l;cnt++;}if(l=='0')break;sentence.insert(make_pair(l, r)); //产生式senRever.insert(make_pair(r,l));ter.insert(l); //非终结符集合(左部)rightSide.push_back(r); //右部的集合/* if(r=="^") { // 判断是否有非终结符->^toEmpty[l] = true;}else {if(toEmpty.find(l)==toEmpty.end()) {toEmpty[l] = false;}} */}for(set::iterator sIter = ter.begin(); sIter!=ter.end(); ++sIter) { // 判断是否有非终结符->^if(isToEmpty(*sIter) ) {toEmpty[*sIter] = true;}else {toEmpty[*sIter] = false;}}for(set::iterator iter=ter.begin(); iter!=ter.end(); iter++) {flag = false;cout<<*iter<<" FIRST集 :";fir.clear();getFirst(*iter, fir);for(set::iterator iterF=fir.begin(); iterF!=fir.end(); iterF++) {cout<<" "<<*iterF;}cout<<endl;follow.clear();getFollow(*iter, follow);cout<<" FOLLOW集:";if(*iter==Begin) {cout<<" #";}for(set::iterator iterF=follow.begin(); iterF!=follow.end(); ++iterF) {if(*iterF!='^')cout<<" "<<*iterF;}cout<<endl<<endl;}system("pause");return 0;}</endl<<endl; </endl;。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
{
sort(TT.begin(),TT.end());
stringtt;
for(intt=1;t<TT.length();t++)
{
tt+=TT[t];
}
TT=tt;
tt="";
for(t=0;t<TT.length();t++)
{
intt,k;
NONE[Vn.find(ch)]++;
if(NONE[Vn.find(ch)]==2)
{
NONE[Vn.find(ch)]=0;
returnFollow[Vn.find(ch)];
}
for(inti=0;i<N;i++)
{
for(intj=0;j<p[i].right.length();j++)
{
if(Follow[Vn.find(ch)].find(gg[k])>100)
{
Follow[Vn.find(ch)]+=gg[k];
}
}
}
else
{
stringFF;
for(intjj=j+1;jj<p[i].right.length();jj++)
{
stringTT;
TT=Letter_First(p,p[i].right[jj]);
{
Follow[Vn.find(ch)]+=dd[k];
}
}
}
}
}
}
}
returnFollow[Vn.find(ch)];
}
voidresult()
{
cout<<"\n该文法不是LL(1)型文法"<<endl;
}
//主函数
intmain()
{
inti,j,k;
cout<<"请输入产生式总数:";
cin>>N;
{
if(Follow[Vn.find(ch)].find(FF[k])>100)
{
Follow[Vn.find(ch)]+=FF[k];
}
}
}
else
{
for(k=0;k<FF.length();k++)
{
if((Follow[Vn.find(ch)].find(FF[k])>100)&&FF[k]!='G')
stringFollow[MAGS];//用于存放每个非终结符的follow集
intN;//产生式个数
structSTR
{
stringleft;
stringright;
};
//求VN和VT
voidVNVT(STRGp)
{
inti,j;
for(i=0;i<N;i++)
{
for(j=0;j<(int)p[i].left.length();j++)
编译原理实验报告
实验名称计算first集合和follow集合
实验时间
院系计算机科学与技术
班级软件工程1班
学号
姓名
1.
实验目的
输入：任意的上下文无关文法。
输出：所输入的上下文无关文法一切非终结符的first集合和follow集合。
2.实验原理
设文法G[S]＝（VN，VT，P，S），则首字符集为：
FIRST（α）＝{a|α aβ，a∈VT，α,β∈VG}。
{
if(p[i].right[j]==ch)
{
if(j+1==p[i].right.length())
{
stringgg;
gg=Letter_Follow(p,p[i].left[0]);
NONE[Vn.find(p[i].left[0])]=0;
for(intk=0;k<gg.length();k++)
{
for(inti=0;i<N;i++)
{
if(p[i].left[0]==ch)
{
if(!(Vt.find(p[i].right[0])>100))
{
if(First[Vn.find(ch)].find(p[i].right[0])>100)
{
First[Vn.find(ch)]+=p[i].right[0];
①若ε FIRST（Gi），则FIRST（Gi）∈FIRST（α）；
②若ε∈FIRST（Gi），则FIRST（Gi）－{ε}∈FIRST（α）；
（3）i＝i+1，重复（1）、（2），直到Gi∈VT，（i＝2，3，…，n）或Gi∈VN且若ε FIRST（Gi）或i>n为止。
当一个文法中存在ε产生式时，例如，存在A→ε，只有知道哪些符号可以合法地出现在非终结符A之后，才能知道是否选择A→ε产生式。这些合法地出现在非终结符A之后的符号组成的集合被称为FOLLOW集合。下面我们给出文法的FOLLOW集的定义。
4.实验心得
通过上机实验我对文法符号的FIRST集和FOLLOW集有了更深刻的理解，已经熟练的掌握了求解的思想和方法，同时也锻炼了自己的动手解决问题的能力，对编程能力也有所提高。
5.实验代码与结果
#include<iostream>
#include<string>
#include<algorithm>
{
if(First[Vn.find(ch)].find(TT[t])>100)
{
First[Vn.find(ch)]+=TT[t];
}
}
break;
}
}
}
}
}
}
returnFirst[Vn.find(ch)];
}
}
//求每个非终结符的Follow集
stringLetter_Follow(STRGp,charch)
usingnamespacestd;
#defineMAGS50
intNONE[MAGS]={0};
stringstrings;//产生式
stringVn;//非终结符
stringVt;//终结符
stringfirst[MAGS];//用于存放每个终结符的first集
stringFirst[MAGS];//用于存放每个非终结符的first集
ff=Letter_First(p,p[i].right[0]);
for(inti_i=0;i_i<ff.length();i_i++)
{
if(First[Vn.find(ch)].find(ff[i_i])>100)
{
First[Vn.find(ch)]+=ff[i_i];
}
}
}
else
{
for(intj=0;j<p[i].right.length();j++)
}
}
}
//对每个文法符号求first集
stringLetter_First(STRGp,charch)
{
intt;
if(!(Vt.find(ch)>100))
{
first[Vt.find(ch)]="ch";
returnfirst[Vt.find(ch)-1];
}
if(!(Vn.find(ch)>100))
{
Follow[Vn.find(ch)]+=FF[k];
}
}
stringdd;
dd=Letter_Follow(p,p[i].left[0]);
NONE[Vn.find(p[i].left[0])]=0;
for(k=0;k<dd.length();k++)
{
if(Follow[Vn.find(ch)].find(dd[k])>100)
{
stringTT;
TT=Letter_First(p,p[i].right[j]);
if(!(TT.find('G')>100)&&(j+1)<p[i].right.length())
{
sort(TT.begin(),TT.end());
stringtt;
for(intt=1;t<TT.length();t++)
{
tt+=TT[t];
}
TT=tt;
tt="";
for(t=0;t<TT.length();t++)
{
if(First[Vn.find(ch)].find(TT[t])>100)
{
First[Vn.find(ch)]+=TT[t];
}
}
}
else
{
for(t=0;t<TT.length();t++)
{
if(!(p[i].right[j]>='A'&&p[i].right[j]<='Z'))
{
if(Vt.find(p[i].right[j])>100)