实验一 词法分析设计
一、实验目的
通过本实验的编程实践，使学生了解词法分析的任务，掌握词法分析程序设计的原理和构造方法，使学生对编译的基本概念、原理和方法有完整的和清楚的理解，并能正确地、熟练地运用。
二、功能描述
1)输入文件名和地址读取文件。
2)获得文件内每个单词的二维坐标。
3)删除空格类字符，包括回车、制表符空格。
4)按拼写单词（关键字、标识符、常数、运算符、关系运算符、分界符号），并用（内码，属性）二元式表示
5)如果发现错误则报告出错
6)根据需要是否填写标识符表供以后各阶段使用
7)判别浮点数和整数
三、程序结构描述
函数名称及调用格式返回类型 参数含义 返回值描述 函数功能
void putinKNSL(void) 无 无 用于添加关键字、运算符、关系运算符、分界符，增强泛用性。
int main(void) 无 确定程序是否正常运行 用于输入文件地址和文件名称，并输出分析结果
int judgenum(char c) c为输入的单个字符 返回值为1是数字，为0则不是 判断输入的字符是否是数字
int judgeletter(char c) c为输入的单个字符 返回值为1是字母，为0则不是 判断该字符是否是字母
int judgeonly_havenum(string s) s为输入的字符串 返回值为1是只有数字，为0则含有别的字符 判断该字符串是否只有数字
int judgeonly_haveletter(string s) s为输入的字符串 返回值为1是只有字母，为0则含有别的字符 判断该字符串是否只有字母
string judgekeyword(string s) s为输入的字符串 返回关键字或空串 判断该字符串是否是关键字
int judgeS(char c) c为输入的单个字符 返回值为1是分界符，为0则不是 判断该字符是否是分界符
int judgeL(char c) c为输入的单个字符 返回值为1是关系运算符，为0则不是 判断该字符是否是关系运算符
int judgeN(char c) c为输入的单个字符 返回值为1是算术运算符，为0则不是 判断该字符是否是算术运算符
void getfile(FILE *f) f为输入的文件名 无 获得文件之中的内容，存储在数组之中
int judgehaveletter(string s) s为输入的字符串 返回值为1是有字母，为0则没有 判断该字符串是否有字母
int judgehavexsd(string s) s为输入的字符串 返回小数点的数码 判断字符串是否有小数点
void judge(void) 无 无 判断文件中每个单词的类型
void read(void) 无 无 输出储存的判断信息
#include<iostream>
#include<fstream>
#include<vector>
#include<string>
#include<sstream>
using namespace std;
void getfile(FILE *f);
void judge(void);
void read(void);
vector<string> K;
vector<char> S;
vector<char> N;
vector<string> L;
vector<string> instring;
vector<string> outtoken;
vector<int> t;
vector<string> id;
struct HL
{
int x;
int y;
};
vector<HL> hl;
void putinKNSL(void)
{
int i;
string FK[8]={"do","end","for","if","printf","scanf","then","while"};
char FS[6]={',',';','(',')','[',']'};
char FN[4]={'+','-','*','/'};
string FL[6]={"<","<=","=",">",">=","<>"};
for(i=0;i<8;i++)
{
K.push_back(FK[i]);
}
for(i=0;i<6;i++)
{
S.push_back(FS[i]);
}
for(i=0;i<4;i++)
{
N.push_back(FN[i]);
}
for(i=0;i<6;i++)
{
L.push_back(FL[i]);
}
}
int main(void)
{
char s1[30];
FILE *f;
cout<<"输入源文件的路径和文件名："<<endl;
while(1)
{
cin>>s1;
if((f=fopen(s1,"r"))!=NULL)
{
break;
}
else
{
cout<<"错误，重新输入源文件的路径和文件名："<<endl;
}
}
putinKNSL();
cout<<"单词\t"<<"二元序列\t"<<"类型\t"<<"位置"<<endl;
getfile(f);
fclose(f);
judge();
read();
return 0;
}
int judgenum(char c)
{
if(c>='0' && c<='9')
{
return 1;
}
else
{
return 0;
}
}
int judgeletter(char c)
{
if((c>='a' && c<='z')||(c>='A' && c<='Z'))
{
return 1;
}
else
{
return 0;
}
}
int judgeonly_havenum(string s)
{
for(int i=0;i<s.length();i++)
{
if(s[i]>='0' && s[i]<='9')
{
continue;
}
else
{
return 0;
}
}
return 1;
}
int judgeonly_haveletter(string s)
{
for(int i=0;i<s.length();i++)
{
if(s[i]>='a' && s[i]<='z')
{
continue;
}
else if(s[i]>='A' && s[i]<='Z')
{
continue;
}
else
{
return 0;
}
}
return 1;
}
string judgekeyword(string s)
{
vector<string>::iterator it;
for(it=K.begin();it!=K.end();it++)
{
if(s==*it)
{
return *it;
}
}
return "";
}
int judgeS(char c)
{
vector<char>::iterator it;
for(it=S.begin();it!=S.end();it++)
{
if(c==*it)
{
return 1;
}
}
return 0;
}
int judgeL(char c)
{
if(c=='<'||c=='>'||c=='=')
{
return 1;
}
return 0;
}
int judgeN(char c)
{
vector<char>::iterator it;
for(it=N.begin();it!=N.end();it++)
{
if(c==*it)
{
return 1;
}
}
return 0;
}
void getfile(FILE *f)
{
string arr;
char c;
int chse;
int row=1,line=0;
HL m;
c = fgetc(f);
while(c!=EOF)
{
arr = "";
if(c=='\n')
{
c = fgetc(f);
line = 0;
row = row+1;
continue;
}
else if(c=='\t'||c==' ')
{
c = fgetc(f);
continue;
}
else
{
line = line+1;
if(judgeletter(c))
{
while((judgeletter(c)||judgenum(c))&&c!=' ')
{
arr = arr+c;
c = fgetc(f);
}
}
else if(judgenum(c))
{
chse = 0;
while((judgeletter(c)||judgenum(c))&&c!=' ')
{
arr = arr+c;
c = fgetc(f);
if(judgeletter(c))
{
chse = 1;
}
if(chse==0 && c=='.')
{
arr = arr+c;
c = fgetc(f);
}
}
}
else if(judgeN(c))
{
while(judgeN(c)&&c!=' ')
{
arr = arr+c;
c = fgetc(f);
}
}
else if(judgeS(c))
{
arr = arr+c;
c = fgetc(f);
}
else if(judgeL(c))
{
while(judgeL(c)&&c!=' ')
{
arr = arr+c;
c = fgetc(f);
}
}
else
{
while(judgeN(c)==0&&judgeletter(c)==0&&judgenum(c)==0&&judgeL(c)==0&&judgeS(c)==0&&c!='\t'&&c!=' '&&c!='\n')
{
arr = arr+c;
c = fgetc(f);
}
}
m.x = row;
m.y = line;
instring.push_back(arr);
hl.push_back(m);
}
}
}
int judgehaveletter(string s)
{
for(int i=0;i<s.length();i++)
{
if(s[i]>='a' && s[i]<='z')
{
return 1;
}
else if(s[i]>='A' && s[i]<='Z')
{
return 1;
}
}
return 0;
}
int judgehavexsd(string s)
{
int m=0;
for(int i=0;i<s.length();i++)
{
if(s[i]=='.')
{
m = m+1;
}
}
return m;
}
void judge(void)
{
vector<string>::iterator mt;
vector<string>::iterator it;
string arr;
int m,n=0;
for(it=instring.begin();it!=instring.end();it++)
{
arr = "";
if(judgeletter((*it)[0]))//首字母为字母
{
if(judgeonly_haveletter(*it))//只有字母
{
arr = judgekeyword(*it);
if(arr=="")//不是关键字
{
m = 6;
arr = "标识符";
id.push_back((*it));
}
else
{
m = 1;
arr = "关键字";
}
}
else//不是只有字母
{
m = 6;
arr = "标识符";
id.push_back((*it));
}
}
else if(judgenum((*it)[0]))//首字母为数字
{
if(judgeonly_havenum(*it))//只有数字
{
m = 5;
arr = "无符号数";
}
else
{
if(judgehaveletter(*it)||(judgehavexsd(*it)>1))
{
m = 0;
arr = "Error";
}
else if(judgehavexsd(*it)==1)
{
m = 5;
arr = "无符号数";
}
else
{
m = 6;
arr = "标识符";
id.push_back((*it));
}
}
}
else if(judgeS((*it)[0]))
{
if((*it).length()>1)
{
m = 0;
arr = "Error";
}
else
{
m = 2;
arr = "分界符";
}
}
else if(judgeN((*it)[0]))
{
if((*it).length()>1)
{
m = 0;
arr = "Error";
}
else
{
m = 3;
arr = "算术运算符";
}
}
else if(judgeL((*it)[0]))
{
n = 0;
for(mt=L.begin();mt!=L.end();mt++)
{
if((*it)==(*mt))
{
n = 1;
break;
}
}
if(n==1)
{
m = 4;
arr = "关系运算符";
}
else
{
m = 0;
arr = "Error";
}
}
else
{
m = 0;
arr = "Error";
}
t.push_back(m);
outtoken.push_back(arr);
}
}
void read(void)
{
vector<string>::iterator it;
vector<string>::iterator mt;
vector<int>::iterator st;
vector<HL>::iterator sl;
st=t.begin();
mt=outtoken.begin();
sl=hl.begin();
for(it=instring.begin();it!=instring.end();it++)
{
cout<<(*it)<<"\t";
if((*st)>0)
{
cout<<"("<<(*st)<<","<<(*it)<<")"<<"\t\t"<<(*mt);
}
else
{
cout<<"Error\t\t"<<"Error";
}
cout<<"\t"<<"("<<(*sl).x<<","<<(*sl).y<<")"<<endl;
mt++;
st++;
sl++;
}
//cout<<"id中的标识符："<<endl;
//for(it=id.begin();it!=id.end();it++)
//{
//cout<<(*it)<<"\t";
//}
//cout<<endl;
}
实验二 LL(1)分析法
一、实验目的
通过完成预测分析法的语法分析程序，了解预测分析法和递归子程序法的区
别和联系。使学生了解语法分析的功能，掌握语法分析程序设计的原理和构造方
法，训练学生掌握开发应用程序的基本方法。有利于提高学生的专业素质，为培
养适应社会多方面需要的能力。
二、写出 LL（1）分析法的思想及写出符合 LL（1）分析法的文法
对文法G的句子进行确定的自顶向下语法分析的充分必要条件是，G的任意两个具有相同左部的产生式A—>α|β 满足下列条件：
（1）如果α、β均不能推导出ε，则 FIRST(α) ∩ FIRST(β) = ∅。
（2）α 和 β 至多有一个能推导出 ε。
（3）如果 β *═> ε，则 FIRST(α) ∩ FOLLOW(A) = ∅。
将满足上述条件的文法称为LL(1)文法。
First构造：
对每一文法符号XVT∪VN构造FIRST(X)，连续使用下面的规则，直至每个集合FIRST不再增大为止：
- 若XVT，则FIRST(X)＝{X}。
- 若XVN，且有产生式X→a…，则把a加入到FIRST(X)中；若X→也是一条产生式，则把也加到FIRST(X)中。
Follow构造：
对于文法G的每个非终结符A构造FOLLOW(A)的办法是，连续使用下面的规则，直至每个FOLLOW不再增大为止： - 对于文法的开始符号S，置＃于FOLLOW(S)中；
- 若A→B是一个产生式，则把FIRST(){}加至FOLLOW(B)中；
- 若A→B是一个产生式，或AB是一个产生式而→ (即FIRST())，则把FOLLOW(A)加至FOLLOW(B)中。
实验文法：
1)E->TG
2)G->+TG|—TG
3)G->ε
4)T->FS
5)S->*FS|/FS
6)S->ε
7)F->(E)
8)F->i
三、程序结构描述
函数名称及调用格式返回类型 参数含义 返回值描述 函数功能
public void putintotable(String one,String two)
字符串one是产生式的左半部分，two是右半部分 无 将输入串箭头左右的部分分开存储
public void splitin()
无 无 判断输入的产生式是否合法，如果合法，则将其分开
public boolean judgein(String s)
字符串s 若s是非终结符则返回true若是终结符则返回false 判断字符串s是终结符或非终结符
public void alonenext(String s)
字符串s 无 获得一个非终结符的first集，如果产生式右端第一个字符是非终结符，则递归，如果是终结符，则放入first集
public void getfirst()
无 无 依次获得非终结符的first集，并输出first集
public String retfirst(String s)
字符串s 存储除空字符以外的first集 获得一个非终结符first集中除了空字符以外的内容
public boolean judgeε(String s)
字符串s 有空字符则返回true，没有则返回false 判断一个非终结符的first集中是否有空字符
public String retfollow(String s) 字符串s 非终结符的follow集 获得一个非终结符的follow集的内容
public void getfollow()
无 无 依次获得所有非终结符的follow集，并输出follow集
public void gettheend()
无 无 存储所有的终结符
public void getthesta()
无 无 存储所有的非终结符
public String getfirstall(String sa)
字符串s 一个非终结符的first集 获得一个非终结符first集的全部内容
public String judgeahead(String sa,String col) Sa是非终结符，col是终结符 一个产生式的右半端 如果一个非终结符有多个产生式，判断产生式的优先度，并填入分析表中
public void getanalysistable() 无 无 获得分析表的内容，并输出
public String gettheana(String roww,String coll) Roww是存储行的字符串，coll是存储列的字符串 存储分析表内容的字符串 获得分析表内指定位置的内容
public boolean judgeinendf(String s) 字符串s True是合法，false是不合法 判断输入的需要分析的字符串是否合法
public void putout(Stack st,Stack ky,String usew,String act,int tim) 分别存储步骤、分析栈、剩余输入串、所用产生式、动作 无 逐步输出分析过程
public void run() 无 无 进行分析，分析输入的字符串
import java.util.*;
import java.lang.*;
public class Second {
public static void main(String[] args) {
LL one = new LL();
one.theway();
}
}
class table{
String left;
String right;
}
class First{//first集合
String Firstname;
String Firstinclude;
}
class Follow{
String followname;
String followinclude;
}
class LL{
Vector<table> first = new Vector<table>();//存储分开的关系式
Vector<First> allfirst = new Vector<First>();
Vector<String> fa = new Vector<String>();
Stack<String> ta = new Stack<String>();
String arr = "";
Vector<Follow> allfollow = new Vector<Follow>();
String endf = "";
String staf = "";
int rows,cols;
String[][] anatab;
public void putintotable(String one,String two){
table x = new table();
x.left = one;
x.right = two;
first.add(x);
}
Scanner Lone = new Scanner(System.in);
public void splitin(){//将输入的关系式分开
System.out.println("输入文法：");
String sl = Lone.next();
while(!sl.equals("#")){
if(sl.equals("test")){//测试用
String[] ss={"E->TG","G->+TG|-TG","G->ε","T->FS","S->*FS|/FS","S->ε","F->(E)","F->i"};
for(int i=0;i<8;i=i+1){
String[] ssa = ss[i].split("->");
if(ssa[1].contains("|")){
String[] ssb = ssa[1].split("\\|");
for(int j=0;j<ssb.length;j=j+1){
putintotable(ssa[0],ssb[j]);
}
}
else{
putintotable(ssa[0],ssa[1]);
}
}
}
else{//输入表达式获得分析表
String[] sa = sl.split("->");
if(sa.length==1){
System.out.println("输入不合法");
}
else{
if(sa[1].contains("|")){
String[] sab = sa[1].split("\\|");
for(int i=0;i<sab.length;i=i+1){
putintotable(sa[0],sab[i]);
}
}
else{
putintotable(sa[0],sa[1]);
}
}
}
sl = Lone.next();
}
}
public boolean judgein(String s){//判断该字符是否有后续，判断字符是否是非终结符
for(int i=0;i<first.size();i++){
if(first.get(i).left.equals(s)){
return true;
}
}
return false;
}
public void alonenext(String s){//获得first的内容
if(judgein(s)){
for(int i=0;i<first.size();i++){
if(first.get(i).left.equals(s)){
ta.push(first.get(i).right);
}
}
String sa = ta.pop();
String ssa = sa.substring(0,1);
alonenext(ssa);
}
else{
arr = arr+s+",";
if(!ta.empty()){
String ssb = ta.pop();
String sm = ssb.substring(0,1);
alonenext(sm);
}
}
}
public void getfirst(){//获得first集合
for(int i=0;i<first.size();i++){
String ha = first.get(i).left;
if(!fa.contains(ha)){
arr = "";
fa.add(ha);
alonenext(ha);
First one = new First();
one.Firstname = ha;
one.Firstinclude = arr.substring(0,arr.length()-1);
allfirst.add(one);
}
}
System.out.println("*********FIRST集*********");
for(int i=0;i<allfirst.size();i++){
System.out.println(allfirst.get(i).Firstname+"\t"+allfirst.get(i).Firstinclude);
}
}
public String retfirst(String s){//给出first集的内容
for(int i=0;i<allfirst.size();i++){
if(allfirst.get(i).Firstname.equals(s)){
String a = allfirst.get(i).Firstinclude;
if(a.indexOf("ε")==0){
String b = a.replace("ε,","");
return b;
}
else if(a.indexOf("ε")==a.length()-1){
String b = a.replace(",ε","");
return b;
}
else if(a.contains(",ε,")){
String b = a.replace(",ε,",",");
return b;
}
else{
return a;
}
}
}
return null;
}
public boolean judgeε(String s){//判断非终结符是否有ε
for(int i=0;i<first.size();i++){
String sa = first.get(i).left;
if(sa.equals(s)){
String sm = first.get(i).right;
if(sm.contains("ε")){
return true;
}
}
}
return false;
}
public String retfollow(String s){
for(int i=0;i<allfollow.size();i++){
String sa = allfollow.get(i).followname;
if(sa.equals(s)){
String h = allfollow.get(i).followinclude+",";
return h;
}
}
return "";
}
public void getfollow(){
for(int i=0;i<fa.size();i++){
String sa = fa.get(i);
arr = "";
if(i==0){
arr = arr+"#,";
}
for(int j=0;j<first.size();j++){
String ssa = first.get(j).right;
if(ssa.contains(sa)){
if(ssa.indexOf(sa)==ssa.length()-1){
String ssb = first.get(j).left;
String su = retfollow(ssb);
arr = arr+su;
}
else{
String ssb = ssa.substring(ssa.indexOf(sa),ssa.length());
String sd = ssb.replace(sa,"");
String sc = sd.substring(0,1);
if(judgein(sc) & !judgeε(sc)){
String sy = retfirst(sc);
arr = arr+sy+",";
}
else if(judgein(sc) & judgeε(sc)){
String sy = retfirst(sc);
String si = retfollow(sc);
arr = arr+sy+","+si;
}
else{
arr = arr+sc+",";
}
}
}
}
Follow one = new Follow();
one.followname = sa;
one.followinclude =arr.substring(0,arr.length()-1);
allfollow.add(one);
}
for(int i=0;i<allfollow.size();i++){
String sa = allfollow.get(i).followinclude;
String st = "";
for(int j=0;j<sa.length();j++){
String su = sa.substring(j,j+1);
if(!su.equals(",")){
if(!st.contains(su)){
st = st+su+",";
}
}
}
allfollow.get(i).followinclude = st.substring(0,st.length()-1);
}
System.out.println("*********FOLLOW集*********");
for(int i=0;i<allfollow.size();i++){
System.out.println(allfollow.get(i).followname+"\t"+allfollow.get(i).followinclude);
}
}
public void gettheend(){//获得终结符
for(int i=0;i<first.size();i++){
String a = first.get(i).right;
for(int j=0;j<a.length();j++){
String b = a.substring(j,j+1);
if(!judgein(b)){
if(!b.equals("ε")){
endf = endf+b+",";
}
}
}
}
endf=endf+"#,";
}
public void getthesta(){
for(int i=0;i<first.size();i++){
String s = first.get(i).left;
if(!staf.contains(s)){
staf = staf+s+",";
}
}
}
public String getfirstall(String sa){
for(int i=0;i<allfirst.size();i++){
String sh = allfirst.get(i).Firstname;
if(sh.equals(sa)){
return allfirst.get(i).Firstinclude;
}
}
return null;
}
public String judgeahead(String sa,String col){
for(int i=0;i<first.size();i++){
String e = first.get(i).left;
if(e.equals(sa)){
String sy = first.get(i).right;
String se = sy.substring(0,1);
if(judgein(se)){
String sm = getfirstall(se);
if(sm.contains(col)){
return sy;
}
}
else{
if(se.equals(col)){
return sy;
}
}
}
}
return null;
}
public void getanalysistable(){
rows = staf.length()/2+1;
cols = endf.length()/2+1;
anatab = new String[rows][cols];
anatab[0][0] = "";
String[] a = endf.split(",");
for(int i=1;i<cols;i++){
anatab[0][i] = a[i-1];
}
String[] b = staf.split(",");
for(int i=1;i<rows;i++){
anatab[i][0] = b[i-1];
}
for(int i=1;i<rows;i++){
String row = anatab[i][0];
int num=0;
for(int m=0;m<first.size();m++){
if(first.get(m).left.equals(row)){
num = num+1;
}
}
for(int k=0;k<allfirst.size();k++){
String sa = allfirst.get(k).Firstname;
String sh = allfirst.get(k).Firstinclude;
if(sa.equals(row)){
for(int j=1;j<cols;j++){
String col = anatab[0][j];
if(sh.contains(col)){
if(num==1){
for(int l=0;l<first.size();l++){
if(sa.equals(first.get(l).left)){
anatab[i][j] = first.get(l).right;
break;
}
}
}
else{
anatab[i][j] = judgeahead(row,col);
}
}
else{
if(sh.contains("ε")){
for(int h=0;h<allfollow.size();h++){
if(sa.equals(allfollow.get(h).followname)){
String sl = allfollow.get(h).followinclude;
if(sl.contains(col)){
anatab[i][j] = "ε";
}
}
}
}
}
}
break;
}
}
}
for(int i=1;i<rows;i++){
for(int j=1;j<cols;j++){
if(anatab[i][j]==null){
anatab[i][j] = "";
}
}
}
System.out.println("*********分析表*********");
for(int i=0;i<rows;i++){
for(int j=0;j<cols;j++){
System.out.print(anatab[i][j]+"\t");
}
System.out.print("\n");
}
}
public String gettheana(String roww,String coll){
for(int i=0;i<rows;i++){
if(anatab[i][0].equals(roww)){
for(int j=0;j<cols;j++){
if(anatab[0][j].equals(coll)){
return anatab[i][j];
}
}
}
}
return "";
}
public boolean judgeinendf(String s){
int num=0;
String[] sj = endf.split(",");
for(int i=0;i<s.length()-1;i++){
num = 0;
String h = s.substring(i,i+1);
for(int j=0;j<sj.length-1;j++){
if(h.equals(sj[j])){
num=1;
break;
}
}
if(num==0){
System.out.println("输入错误！重新输入");
return false;
}
}
if(s.substring(s.length()-1).equals("#")){
return true;
}
else{
System.out.println("输入错误！重新输入");
return false;
}
}
public void putout(Stack<String> st,Stack<String> ky,String usew,String act,int tim){
String syt= "";
for (String s : st) {
syt = syt+s;
}
System.out.print(tim+"\t\t#"+syt+"\t\t");
syt = "";
for(int i=ky.size()-1;i>=0;i--) {
syt = syt + ky.get(i);
}
System.out.print(syt+"\t");
if(!usew.equals("")){
System.out.print("\t"+usew+"\t\t");
}
else{
System.out.print("\t\t\t");
}
System.out.print(act+"\n");
}
public void run(){
System.out.println("输入字符串:");
String ss = "";
while(true){
ss = Lone.next();
if (ss.equals("test")) {
ss = "i+i*i#";
break;
}
else if(judgeinendf(ss)){
break;
}
}
String[] sa = ss.split("");
Stack<String> ky = new Stack<String>();//剩余输入串
Stack<String> st = new Stack<String>();//分析栈
for(int i = sa.length-1;i>=0;i--){
ky.push(sa[i]);
}
st.push(first.get(0).left);
int tim=0;
String act = "初始化";
String usew = "";
System.out.println("步骤\t分析栈\t剩余输入串\t所用产生式\t动作");
putout(st,ky,usew,act,tim);
tim++;
while(!ky.isEmpty()){
usew = "";
if(st.isEmpty()){
break;
}
String sta = st.pop();
String eda = ky.pop();
if(!sta.equals(eda)){
String geta = gettheana(sta,eda);
if(geta.equals("")){
usew = "ERROR";
act = "ERROR";
st.push(sta);
}
else{
usew = sta+"->"+geta;
ky.push(eda);
if(!geta.equals("ε")) {
String mk = "";
for(int i=geta.length()-1;i>=0;i--){
mk = mk+geta.substring(i,i+1);
}
act = "POP,PUSH("+mk+")";
String[] spl = geta.split("");
for(int i = spl.length-1;i>= 0;i--){
st.push(spl[i]);
}
}
else{
act = "POP";
}
}
}
else{
act = "GETNEXT(I)";
}
putout(st,ky,usew,act,tim);
tim++;
}
}
public void theway(){
splitin();
getfirst();
getfollow();
gettheend();
getthesta();
getanalysistable();
run();
Lone.close();
}
}
实验三 LR(1)分析法
一、实验目的
构造 LR(1)分析程序，利用它进行语法分析，判断给出的符号串是否为该文法识别的句子，了解 LR（K）分析方法是严格的从左向右扫描，和自底向上的语法分析方法。
二、描述 LR(1)语法分析程序的设计思想
1.提取所有有效识别活前缀的式子：
形式上我们说一个LR(1)项目[A→·, a]对于活前缀是有效的，如果存在规范推导其中，
- ＝；
- a是的 第一个符号，或者a为#而为。
[A→·B, a]对活前缀＝是有效的，则对于每个形如B的产生式， 对任何bFIRST(a)，[B→·, b]对也是有效的。
2.项目集I 的闭包CLOSURE(I)构造：
1)I的任何项目都属于CLOSURE(I)。
2)若项目[A→·B, a]属于CLOSURE(I)，B→ 是一个产生式，那么，对于FIRST(a) 中的每个终结符b，如果[B→·, b]原来不在CLOSURE(I)中，则把它加进去。
3)重复执行步骤2，直至CLOSURE(I)不再增大为止。
3.GO构造：
令I是一个项目集，X是一个文法符号，函数GO(I，X)定义为：GO(I，X)＝CLOSURE(J)其中J＝{任何形如[A→X·, a]的项目| [A→·X, a]I}
4.分析表构造：
令每个Ik的下标k为分析表的状态，令含有[S→·S, #]的Ik的k为分析器的初态。
1)若项目[A→·a, b]属于Ik且GO(Ik, a)＝Ij， a为终结符，则置ACTION[k, a]为 “sj”。
2)若项目[A→·，a]属于Ik，则置ACTION[k, a]为 “rj”；其中假定A→为文法G的第j个产生式。
3)若项目[S→S·, #]属于Ik，则置ACTION[k, #]为 “acc”。
4)若GO(Ik，A)＝Ij，则置GOTO[k, A]=j。
5)分析表中凡不能用规则1至4填入信息的空白栏均填上“出错标志”。
三、程序结构描述：
函数名称及调用格式返回类型 参数含义 返回值描述 函数功能
public void getgui()
无 无 获得实验的GUI界面
public boolean judgeright(String s)
s为输入框中输入的内容 若合法则返回true，不合法返回false 判断输入框中输入的内容是否合法
public void getST(String se) 字符串se为输入的文法 无 将输入的文法左右两端分开存储
public void putintoST(String sas) 字符串sas为输入的字符串 无 将输入的文法左右两端分开存储
public boolean judgein(String s)
s为输入的字符串 True为非终结符，false为终结符 判断字符是否是非终结符
public void alonenext(String s)
字符串s 无 获得一个非终结符的first集，如果产生式右端第一个字符是非终结符，则递归，如果是终结符，则放入first集
public void getfirst()
无 无 依次获得非终结符的first集
public void getTE()
无 无 读取输入的文法，取出其中的终结符，并存储
public void getseset()
无 无 获得项目集分析族，先输入第一个产生式，在使用相应的法则求闭包，再根据读取的规则求后续的闭包
public String putda(String a1)
字符串a1 移动字符串中的点以后的新字符串 将字符串中的点向后移动一位，获得新的字符串，并返回
public void Wayss()
无 无 将一个集合取出，将其中的所有产生式的点向后移一位，然后求闭包
public void waytoss(List one,int x)
One是存储产生式的集合，x是循环次数 无 判断点后的字符是否是非终结符，如果是，则将产生式放入闭包内，如果不是，则继续循环，直至集合不再增大
public void getSA(List ss)
ss是存储产生式的集合 无 判断一个状态后是否还有别的状态
public void getgototable()
无 无 获得分析表
public void analysisit(String s)
s为输入的要分析的输入串 无 分析输入的字符串
public String visittable(String a,String b)
a为行的字符串，b为列的字符串 分析表中指定位置的字符 根据输入的行列，获得下一步操作
public void addtov(int a,Stack b,String c,Stack d)
a为序号，b为状态，c为符号，d为剩余输入串 无 将现有的内容存储入相应的集合中
import javax.swing.*;
import java.awt.*;
import java.util.*;
import java.util.List;
public class Third {
public static void main(String[] args) {
LR one = new LR();
one.getgui();
}
}
class LR{
JFrame myframe = new JFrame();
JPanel onep = new JPanel();
JTextField onet = new JTextField(50);
JButton oneb = new JButton("输入");
JButton twob = new JButton("FIRST");
JLabel onel = new JLabel("输入框");
JButton thrb = new JButton("项目集");
JButton foub = new JButton("分析表");
GridLayout onegl = new GridLayout(1,5);
JPanel twop = new JPanel(onegl);
JTextArea oneta = new JTextArea(10,20);
JScrollPane onesp =new JScrollPane(oneta);
JTextArea twota = new JTextArea(10,20);
JScrollPane twosp =new JScrollPane(twota);
JTextArea thrta = new JTextArea(10,20);
JScrollPane thrsp =new JScrollPane(thrta);
JTextArea fouta = new JTextArea(10,20);
JScrollPane fousp =new JScrollPane(fouta);
JTextArea fivta = new JTextArea(10,20);
JScrollPane fivsp =new JScrollPane(fivta);
boolean judone = false;//用于判断文法是否输入完成
Vector<Splitsta> ST = new Vector<>();//用于储存分开的产生式
Vector<String> SLE = new Vector<>();//储存非终结符
Vector<String> TE = new Vector<>();//存储终结符
String arr;
Stack<String> ta = new Stack<>();//用于寻找FIRST集
Vector<first> vf = new Vector<>();//储存FIRST集
List<List> onelist = new ArrayList<>();//储存项目集规范族
List<String> into = new ArrayList<>();//储存输入的产生式
List<String> uin = new ArrayList<>();
int numjud;//判断到哪一个项目集
Vector<gotot> twoway = new Vector<>();//储存goto表
String[][] sstable;
int rows,cols;
public void getgui(){
myframe.setBounds(30,30,1300,700);
onep.add(onel);
onep.add(onet);
onep.add(oneb);
onep.add(twob);
onep.add(thrb);
onep.add(foub);
myframe.add(onep,BorderLayout.NORTH);
oneta.setBorder(BorderFactory.createTitledBorder("输入显示:"));
twop.add(onesp);
oneta.append("输入文法:\n");
twota.setBorder(BorderFactory.createTitledBorder("文法:"));
twop.add(twosp);
thrta.setBorder(BorderFactory.createTitledBorder("FIRST集:"));
twop.add(thrsp);
fouta.setBorder(BorderFactory.createTitledBorder("项目集规范族:"));
twop.add(fousp);
fivta.setBorder(BorderFactory.createTitledBorder("分析表:"));
twop.add(fivsp);
myframe.add(twop,BorderLayout.CENTER);
oneb.addActionListener(e->{
String sget = onet.getText();
onet.setText("");
if(!judgeright(sget)){
oneta.append("ERROR：输入不合法\n");
}
else{
if(sget.equals("#") & !judone){
oneta.append(sget+"\n");
oneta.append("文法输入结束\n");
judone = true;
}
if(!judone){
oneta.append(sget+"\n");
getST(sget);
}
else{
if(!sget.equals("#")){
if(onelist.size()==0){
oneta.append("ERROR：没有获得项目集规范族\n");
}
else{
oneta.append(sget+"\n");
if(sget.equals("test")){
String s1 = "i+i*i#";
analysisit(s1);
}
else{
analysisit(sget);
}
}
}
}
}
});
twob.addActionListener(e->{
if(!judone){
oneta.append("ERROR：文法输入没有结束\n");
}
else{
getfirst();
for (first first : vf) {
String s1 = "FIRST("+first.name+")={"+first.include+"}";
thrta.append(s1+"\n");
}
}
});
thrb.addActionListener(e->{
getTE();
if(!judone){
oneta.append("ERROR：文法输入没有结束\n");
}
else if(vf.size()==0){
oneta.append("ERROR：没有获得FIRST集\n");
}
else{
getseset();
}
});
foub.addActionListener(e->{
if(!judone){
oneta.append("ERROR：文法输入没有结束\n");
}
else if(vf.size()==0){
oneta.append("ERROR：没有获得FIRST集\n");
}
else if(onelist.size()==0){
oneta.append("ERROR：没有获得项目集规范族\n");
}
else{
getgototable();
}
});
myframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
myframe.setVisible(true);
}
public boolean judgeright(String s){
if(s.equals("")){
return false;
}
else if(s.equals("test") & judone){
return true;
}
else if(!s.contains("->") & !judone){
return s.equals("test") | s.equals("#");
}
else if(judone){
String se = s.substring(s.length()-1);
return se.equals("#");
}
return true;
}
//"T->S","S->BB","B->aB","B->b"
public void getST(String se){
if(se.equals("test")){//测试用
String[] ss = {"S->E","E->E+T","E->T","T->T*F","T->F","F->(E)","F->i"};
for (String s : ss) {//
putintoST(s);//
into.add(s);//"T->S","S->aAd","S->bAc","S->aec","S->bed","A->e"
}
}
else{//正常输入
putintoST(se);
into.add(se);
}
}
public void putintoST(String sas){//分开储存
twota.append(sas+"\n");
String[] ma = sas.split("->");
Splitsta onesp = new Splitsta();
if(ma[1].contains("|")){
String[] mma = ma[1].split("\\|");
for (String value : mma) {
onesp.putinit(ma[0],value);
ST.add(onesp);
}
}
else{
onesp.putinit(ma[0],ma[1]);
ST.add(onesp);
}
}
public boolean judgein(String s){//判断该字符是否有后续，判断字符是否是非终结符
for (Splitsta splitsta : ST) {
if (splitsta.itleft.equals(s)) {
return true;
}
}
return false;
}
public void alonenext(String s){
if(judgein(s)){
for (Splitsta splitsta : ST) {
if (splitsta.itleft.equals(s)) {
String sk = splitsta.itright;
String sy = sk.substring(0,1);
if(!sy.equals(s)){
ta.push(sy);
}
}
}
String s1 = ta.pop();
alonenext(s1);
}
else{
arr = arr+s+",";
if(!ta.empty()){
String s3 = ta.pop();
alonenext(s3);
}
}
}
public void getfirst(){
for (Splitsta splitsta : ST) {
String s1 = splitsta.itleft;
if (!SLE.contains(s1)) {
SLE.add(s1);
arr = "";
alonenext(s1);
first ff = new first();
ff.geiit(s1,arr.substring(0,arr.length()-1));
vf.add(ff);
}
}
}
public void getTE(){
for (Splitsta splitsta : ST) {
String ms = splitsta.itright;
for (int j = 0; j < ms.length(); j++) {
String me = ms.substring(j, j + 1);
if (!judgein(me) & !me.equals("ε")) {
TE.add(me);
}
}
}
}
int tim=0;
Stack<String> SA = new Stack<>();
public void getseset(){
for (String value : into) {
String s = value + ",";
s = s.replace("->","->.");
uin.add(s);
}
int x = 0;
List<String> f = new ArrayList<>();
f.add(uin.get(0)+"#\n");
waytoss(f,x);
onelist.add(f);
numjud = 0;
while(numjud<onelist.size()){
List<String> two = onelist.get(numjud);
getSA(two);
Wayss();
numjud++;
}
int t=0;
for (List list : onelist) {
String h = "l"+t+":\n";
fouta.append(h);
for (Object o : list) {
fouta.append((String)o);
}
fouta.append("\n");
t++;
}
}
public String putda(String a1){
int b1 = a1.indexOf(".");
StringBuilder s1 = new StringBuilder(a1);
s1.insert(b1+2,".");
s1.deleteCharAt(b1);
return s1.toString();
}
public void Wayss(){
if(!SA.isEmpty()){
tim++;
String s1 = SA.pop();
List<String> l1 = new ArrayList<>();
List<String> one = onelist.get(numjud);
int x = 0;
for(String s : one){
int a1 = s.indexOf(".");
if(a1!=-1){
String s2 = s.substring(a1+1,a1+2);
if(s2.equals(s1)){
String s3 = putda(s);
l1.add(s3);
}
}
}
waytoss(l1,x);
if(!onelist.contains(l1)){
onelist.add(l1);
}
gotot g1 = new gotot();
g1.getot(one,s1,l1);
twoway.add(g1);
Wayss();
}
}
public void waytoss(List<String> one,int x){
if(x<one.size()){
String s1 = one.get(x);
x = x+1;
int a1 = s1.indexOf(".");
String s2 = s1.substring(a1+1,a1+2);
if(judgein(s2)){
String s3 = s1.substring(a1+2,a1+3);
if(judgein(s3)){
for (first first : vf) {
String s4 = first.name;
if (s4.equals(s3)) {
String s5 = first.include;
String[] s6 = s5.split(",");
for (String s8 : uin) {
if (s2.equals(s8.substring(0, 1))) {
for (String s : s6) {
String s7 = s8;
s7 = s7 + s+"\n";
if(!one.contains(s7)){
one.add(s7);
}
}
}
}
break;
}
}
}
else{
String s9;
if(s3.equals(",")){
s9 = s1.substring(s1.length()-2,s1.length()-1);
}
else{
s9 = s3;
}
for(String s8 : uin){
if (s2.equals(s8.substring(0, 1))) {
String k1 = s8+ s9 +"\n";
if(!one.contains(k1)){
one.add(k1);
}
}
}
}
}
waytoss(one,x);
}
}
public void getSA(List<String> ss){
for (String st : ss) {
int a1 = st.indexOf(".");
if (a1!=-1){
String s2 = st.substring(a1+1,a1+2);
if(!SA.contains(s2) & !s2.equals(",")){
SA.push(s2);
}
}
}
}
public void getgototable(){
rows = onelist.size()+2;
cols = SLE.size()+TE.size()+1;
sstable = new String[rows][cols];
sstable[1][0] = "状态";
int i;
for(i=2;i<rows;i++){
sstable[i][0] = Integer.toString(i-2);
}
for(i=0;i<TE.size();i++){
sstable[1][i+1] = TE.get(i);
}
i = i+1;
sstable[0][1] = "ACTION";
sstable[1][i] = "#";
sstable[0][i+1] = "GOTO";
for (String value : SLE) {
if (!value.equals(into.get(0).substring(0, 1))) {
sstable[1][i + 1] = value;
i = i + 1;
}
}
for(int j=0;j<cols;j++){
if(sstable[0][j]==null){
sstable[0][j] = "";
}
}
for (gotot g1 : twoway) {
for (int k1 = 0; k1 < onelist.size(); k1++) {
if (g1.lst.equals(onelist.get(k1))) {
for (int k2 = 0; k2 < onelist.size(); k2++) {
if (g1.led.equals(onelist.get(k2))) {
g1.sta = Integer.toString(k1);
g1.ed = Integer.toString(k2);
}
}
}
}
}
for (gotot m1 : twoway) {
String s = m1.sta;
String s1 = s.replace("l","");
for (int k1 = 2; k1 < rows; k1++) {
String s2 = sstable[k1][0];
if (s2.equals(s1)) {
for (int k2 = 1; k2 < cols; k2++) {
String s3 = sstable[1][k2];
String s4 = m1.way;
if (s3.equals(s4)) {
String s5 = m1.ed;
String s6 = s5.replace("l","");
if (judgein(s4)) {
sstable[k1][k2] = s6;
}
else {
sstable[k1][k2] = "s" + s6;
}
break;
}
}
break;
}
}
}
for(int k1=0;k1<onelist.size();k1++){
List<String> l1 = onelist.get(k1);
for (String s2 : l1) {
int b1 = s2.indexOf(".");
String s3 = s2.substring(b1 + 1, b1 + 2);
if (s3.equals(",")) {
String s4 = s2.substring(s2.length() - 2, s2.length() - 1);
for (int k3 = 1; k3 < cols; k3++) {
if (sstable[1][k3].equals(s4)) {
String s5 = s2.substring(0,b1);
for(int k4 = 0;k4<into.size();k4++){
String s6 = into.get(k4);
if(s6.equals(s5)){
sstable[k1 + 2][k3] = "r"+k4;
}
}
}
}
}
}
}
String s1 = into.get(0)+ ".,#\n";
for(int k=0;k<onelist.size();k++){
List<String> l1 = onelist.get(k);
if (l1.contains(s1)) {
for (int k2 = 1; k2 < cols; k2++) {
if (sstable[1][k2].equals("#")) {
sstable[k+2][k2] = "acc";
}
}
}
}
for(int k1=2;k1<rows;k1++){
for(int k2=1;k2<cols;k2++){
if(sstable[k1][k2]==null){
sstable[k1][k2] = "";
}
}
}
for(int j=0;j<rows;j++){
for(int k=0;k<cols;k++){
fivta.append(sstable[j][k]+"\t");
}
fivta.append("\n");
}
}
Vector<Vector> vb = new Vector<>();
public void analysisit(String s){
Stack<String> ss = new Stack<>();
String fh = "#";
String[] s1 = s.split("");
for(int i=s1.length-1;i>=0;i--){
ss.add(s1[i]);
}
Vector<String> linename = new Vector<>();
linename.add("序号");
linename.add("状态");
linename.add("符号");
linename.add("输入串");
int tims = 1;
Stack<String> now = new Stack<>();
now.add("0");
String s4 = ss.get(ss.size()-1);
addtov(tims,now,fh,ss);
String m1 = into.get(0);
String[] m2 = m1.split("->");
String m3 = m2[1];
m3 = "#"+m3;
while(!(fh.equals(m3) & s4.equals("#"))){
tims++;
String s6 = now.get(now.size()-1);
String s5 = visittable(s6,s4);
if(s5.equals("acc")){
break;
}
if(s5.length()>1) {
String s7 = s5.substring(0, 1);
String s8 = s5.substring(1);
if (s7.equals("s")) {
now.push(s8);
ss.pop();
fh = fh+s4;
} else if (s7.equals("r")) {
int a1 = Integer.parseInt(s8);
String w1 = into.get(a1);
String[] w2 = w1.split("->");
for(int i=0;i<w2[1].length();i++){
now.pop();
}
String w5 = now.get(now.size()-1);
String w4 = visittable(w5, w2[0]);
now.push(w4);
fh = fh.replace(w2[1],w2[0]);
}
}
s4 = ss.get(ss.size()-1);
addtov(tims,now,fh,ss);
}
JFrame myjf = new JFrame();
myjf.setBounds(100,100,400,300);
JPanel myjp = new JPanel();
JTable myjt = new JTable(vb,linename);
JScrollPane myjs = new JScrollPane(myjp);
myjf.add(myjs);
myjp.add(myjt);
myjp.setBorder(BorderFactory.createTitledBorder("分析过程:"));
myjf.setVisible(true);
}
public String visittable(String a,String b){
for(int i=2;i<rows;i++){
String s1 = sstable[i][0];
if(s1.equals(a)){
for(int j=1;j<cols;j++){
String s2 = sstable[1][j];
if(s2.equals(b)){
return sstable[i][j];
}
}
}
}
return "";
}
public void addtov(int a,Stack<String> b,String c,Stack<String> d){
String s = Integer.toString(a);
Vector<String> v1 = new Vector<>();
v1.add(s);
StringBuilder s1 = new StringBuilder();
for (String value : b) {
s1.append(value);
}
v1.add(s1.toString());
v1.add(c);
StringBuilder s3 = new StringBuilder();
for(int i=d.size()-1;i>=0;i--){
s3.append(d.get(i));
}
v1.add(s3.toString());
vb.add(v1);
}
}
class Splitsta{
String itleft;
String itright;
public void putinit(String l,String r){
this.itleft = l;
this.itright = r;
}
}
class first{
String name;
String include;
public void geiit(String n,String i){
this.name = n;
this.include = i;
}
}
class gotot{
String sta;
String way;
String ed;
List<String> lst;
List<String> led;
public void getot(List<String> a,String b,List<String> c){
this.lst = a;
this.way = b;
this.led = c;
}
}
3880
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
