编译作业——LR文法的语法分析器

依旧是编译的上机作业，第四次的了吧。

做一个LR的语法分析器。

文法是

E->E+T | T
T->T*F | F
F->(E) | id

然后如果用这个文法推LR（1）的状态，状态太多了，所以我换了一个，用

E->E+E|E*E|(E)|id

这个有二义性，左递归的文法推，只有10个状态，好手写分析表，同时里面还用了上一次作业的部分代码，以下是代码部分。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class ThirdHW {
static String E="E",Ee="E'",T="T",Tt="T'",F="F",//代表各种非终结符
//synch="synch",//同步记号，用于标记错误
id="id";//一个终结符

static Set<String> unLimitedSign=new HashSet<String>();
static{//初始化 非终结符的集合
unLimitedSign.add(E);
/*
unLimitedSign.add(Ee);
unLimitedSign.add(T);
unLimitedSign.add(Tt);
unLimitedSign.add(F);
*/
}
//下面两个变量有违封装原则，不过东西小，看不出影响
static Integer timeForPutToMap=0;//全局变量用于下面的putToMap方法
static Map<String,Map<String,Action>> table=new HashMap<String,Map<String,Action>>();//全局变量，一个Action表
//用于构建诸如s3,r1,e1这样形式的一个类
static class  Action{
String SorR;
int state;
public Action(String SorR,Integer state){
this.SorR=SorR;
this.state=state;
}
public String getSorR(){
return SorR;
}
public int getState(){
return state;
}
@Override
public String toString(){
return SorR+" "+state;
}
}
public static Map<Integer,List<String>> produceEquation(){
Map<Integer,List<String>> ProduceEquation=new HashMap<Integer,List<String>>();
List<String> temp=new ArrayList<String>();
temp=fullList(new String[]{E,"+",E});
ProduceEquation.put(1,temp);
temp=fullList(new String[]{E,"*",E});
ProduceEquation.put(2,temp);
temp=fullList(new String[]{"(",E,")"});
ProduceEquation.put(3,temp);
temp=fullList(new String[]{id});
ProduceEquation.put(4,temp);
return ProduceEquation;
}
//goto表，没错，分析表action部分和goto部分是分开的，很奇葩
//原因是这样写方便（个人认为）
//Action的对象，不用和数字放在一个map里，泛型用起来舒服了
public static Map<String,Integer> GotoTable(){
Map<String,Integer> gotoTable=new HashMap<String,Integer>();
gotoTable.put("0",1);
gotoTable.put("2",6);
gotoTable.put("4",7);
gotoTable.put("5",8);
return gotoTable;
}
//action表，没错，分析表action部分和goto部分是分开的，很奇葩
public static Map<String,Map<String,Action>> ActionTable(){
Map<String,Action> tempList=null;
String s="s",e="e",r="r";
tempList=fullList(new Object[]{s,3,e,1,e,1,s,2,e,2,e,1});
putToMap(tempList);
tempList=fullList(new Object[]{e,3,s,4,s,5,e,3,e,2,"a",-1});
putToMap(tempList);
tempList=fullList(new Object[]{s,3,e,1,e,1,s,2,e,2,e,1});
putToMap(tempList);
tempList=fullList(new Object[]{r,4,r,4,r,4,r,4,r,4,r,4});
putToMap(tempList);
tempList=fullList(new Object[]{s,3,e,1,e,1,s,2,e,2,e,1});
putToMap(tempList);
putToMap(tempList);
tempList=fullList(new Object[]{e,3,s,4,s,5,e,3,s,9,e,4});
putToMap(tempList);
tempList=fullList(new Object[]{r,1,r,1,s,5,r,1,r,1,r,1});
putToMap(tempList);
tempList=fullList(new Object[]{r,2,r,2,r,2,r,2,r,2,r,2});
putToMap(tempList);
tempList=fullList(new Object[]{r,3,r,3,r,3,r,3,r,3,r,3});
putToMap(tempList);
return table;
}
//用于生成分析表的Action部分
//不想很傻地一个一个增添状态对应的条目，每次都写table.put((一个数字),tempList)干脆自动化一点
//缺点是引入了一个全局变量timeForPutToMap
public static void putToMap(Map<String,Action> tempList){
table.put(timeForPutToMap.toString(),tempList);
timeForPutToMap++;
}
/**
* 传入一个数组，填充成一个List,输入成对的String，int组合，每一对组合成一个Action
* @param object []args,注意，是偶数个，成对出现的的String、int
* @return List<Action>
*/
private static Map<String,Action> fullList(Object[] args){
Map<String,Action> temp=new HashMap<String,Action>();
String []SQE=new String[]{id,"+","*","(",")","$"};
for(int i=0;i<args.length;i+=2){
Action a=new Action((String)args[i], (Integer)args[i+1]);
temp.put(SQE[i/2],a);
}
return temp;
}
/**
* 传入一个数组，填充成一个List
* @param object []args
* @return List<String>
*/
private static List<String> fullList(String[] args){
List<String> temp=new ArrayList<String>();
for(String s:args){
temp.add(s);
}
return temp;
}

public static void main(String []args){
Map<String, Map<String, Action>> actionTable=ActionTable();
Map<String,Integer> gotoTable=GotoTable();
Map<Integer,List<String>> ProduceEquation=produceEquation();
LinkedList<String> stack=new LinkedList<String>();
stack.addFirst("0");
int point=0;
boolean successFlag=false;
/*
Scanner sc=new Scanner(System.in);
System.out.println("输入一个记号流的串，注意每个终结符需要以空格隔开 ");
String[] test=sc.nextLine().split(" ");
sc.close();
*/
//输入记号流
//三个测试用例
//String[] test=new String[]{id,"+",id,"*",id,"$"};
String[] test=new String[]{id,id,"$"};
//String[] test=new String[]{"(",")","$"};
//String[] test=new String[]{id,"*",id,"+",")",id,"$"};
//String[] test=new String[]{id,"*","+",")",id,id,"$"};
while(point<test.length){
Action a=actionTable.get(stack.getFirst()).get(test[point]);
//出错处理
//没有default处理
if(a.getSorR().equals("e")){
switch(a.getState()){
case 1:
System.out.println("缺少运算对象,可能是运算符输入过多,默认做‘移入一个id’处理");
error(test,point);
//point++;
stack.addFirst(id);
stack.addFirst("3");
break;
case 2:
System.out.println("不匹配的右括号");
error(test,point);
point++;
break;
case 3:
System.out.println("缺少算符，可能是运算对象输入过多,默认做‘移入一个+’处理");
error(test,point);
//point++;
stack.addFirst("+");
stack.addFirst("4");
break;
case 4:
System.out.println("缺少右括号");
error(test,point);
//point++;
stack.addFirst(")");
stack.addFirst("9");
break;
}
}else if(a.getSorR().equals("s")){//移进
System.out.println(stack.toString());
printString(test, point);
stack.addFirst(test[point]);
System.out.println("移进"+test[point]);
System.out.println("===========");
point++;
stack.addFirst(((Integer)a.getState()).toString());
}else if(a.getSorR().equals("r")){//归约
System.out.println(stack.toString());
printString(test, point);
//规约弹栈的操作
for(int i=0;i<ProduceEquation.get(a.getState()).size();){//缺省一条语句，没错，只有移出非终结符和终结符时i++，其他时候仅仅是移出，i不变
if(!stack.removeFirst().matches("[0-9]+")){
i++;
}
}
//记录栈顶状态的临时量
Integer state=Integer.parseInt(stack.getFirst());
//栈顶压入非终结符
stack.addFirst(E);
//通过非终结符和栈顶状态的临时量，定位新的栈顶状态，入栈
stack.addFirst(gotoTable.get(state.toString()).toString());
System.out.println("归约，使用产生式:E->"+ProduceEquation.get(a.getState()));
System.out.println("===========");
}else if(a.getSorR().equals("a")){//接受
successFlag=true;
System.out.println(stack.toString()+"->acc");
System.out.println("接受,识别结束");
break;
}
}
if(!successFlag){
System.out.println("识别结束，输入串有问题");
}
}
/**
* 用于从指定位置输出一个数组的一部分
* @param args 要输出的数组
* @param index 指定的输出起点
*/
public static void printString(String[] args,int index){
for(int i=index;i<args.length;i++){
System.out.print(args[i]);
}
System.out.println();
}
/**
* 用于展示输入记号流的出错位置
* @param args 输入的记号流，终结符的数组
* @param index 出错的位置
*/
public static void error(String[] args,int index){
for(int i=0;i<args.length;i++){
System.out.print(args[i]+"\t");
}
System.out.println();
for(int i=0;i<args.length;i++){
if(i==index){
System.out.print("↑这里有错");
}else System.out.print("\t");
}
System.out.println();
}
}