编译原理实验-LL1语法分析器（自动生成First集、Follow集求法）java实现
编译原理实验-LL1语法分析器（自动生成First、Follow）java
博主在做实验时，参考众多他人代码，发现bug众多，在@moni_mm代码基础上，与伙伴把能看到的BUG都做出修正，同时增添了一个GUI展示。再次我将代码做出讲解。完整代码最下方贴出。
一、数据结构
下文程序运行的文法为：
static String[] grammarStr = {"E->TG" ,"G->+TG|-TG" ,"G->ε" ,"T->FS" ,"S->*FS|/FS" ,"S->ε" ,"F->(E)" ,"F->i"};//相关文法
处理的输入串为：
static inStr="i+i*i#";//输入串
-----首先要考虑FOLLOW、FIRST、终结符、非终结符、预测分析表、栈、各个产生式的存储的数据结构设计：
static HashMap<Character, HashSet<Character>> FirstSet = new HashMap<>();//构造FIRST集合
static HashMap<String, HashSet<Character>> FirstSetX = new HashMap<>();//生成任何符号串的first
static HashMap<Character, HashSet<Character>> FollowSet = new HashMap<>();//构造FOLLOW集合
static String[][] table;//预测分析表
static HashSet<Character> VnSet = new HashSet<>();//非终结符Vn集合
static HashSet<Character> VtSet = new HashSet<>();//终结符Vt集合
static Stack<Character> stack = new Stack<>(); //符号栈
static HashMap<Character,ArrayList<String>> production = new HashMap<>();//产生式
二、运行效果
LL(1)预测分析的实现均在类LL1中得到实现，类GUI仅仅将结果在桌面程序得到展示，LL1也可单独运行，结果输出控制台：
运行GUI（注释掉LL1的main即可，反之亦然）：
运行LL1:
三、类的设计
-
class: LL1(打印相关不与介绍)
- dividechar() 将产生式填充进production，划分终结符（vt）与非终结符（vn） - First() 生成FIRST集(非终结符的) - getFirstX() 生成FIRST集(任意字符串的)，Follow()需要调用 - Follow() 生成FOLLOW集 - insert() 将生成式插入表中 - creatTable() 创建预测分析表 - find(char X, char a) 寻找预测分析表中对应内容，X非终结符,a终结符 - processLL1() 执行LL1栈分析 -
class:GUI（可专注于LL1即可，本处简略）
- Gui(String title) 添加组件，创建面板
- class Listener implements ActionListener 时间监听器（添加具体执行语句,展示LL1.stepList、LL1.FirstSet、LL1.FollowSet的数据）
三、核心算法（求first\follow）
- 求First集：
first集叫做首终结符集下面是博主自己的理解，用的列子讲的。在博主自己学的时候，不会的时候，死磕概念是看不懂的。额，博主菜ji.
基本就两种情况：（终结符的first即它本身）- 1.直接遇到终结符
A->aBCd | ε
若a，e为终结符，first(A)= {a,ε}。 - 2.第一个为非终结符
A->BC
此时first(A)=first(B);值得注意的是，若first(B)包含空ε，需要继续求first(C )加入first(A)中。若first（c）仍旧包含空ε，将空字符ε加入first(A)。
- 1.直接遇到终结符
- 程序实现：
/** * 生成非终结符的FIRST集的递归入口 */ static void First(){ //遍历求每一个非终结符vn的first集 for (Character vn: VnSet ) { getfisrst(vn); } } /** * 生成非终结符FIRST集的递归程序 */ static void getfisrst(Character ch){ ArrayList<String> ch_production = production.get(ch); HashSet<Character> set = FirstSet.containsKey(ch) ? FirstSet.get(ch) : new HashSet<>(); // 当ch为终结符vt if(VtSet.contains(ch)){ set.add(ch); FirstSet.put(ch,set); return; } //ch为非终结符vn for (String str:ch_production ) { int i = 0; while (i < str.length()) { char tn = str.charAt(i); //递归 getfisrst(tn); HashSet<Character> tvSet = FirstSet.get(tn); // 将其first集加入左部 for (Character tmp : tvSet) { if (tmp != 'ε') set.add(tmp); } // 若包含空串 处理下一个符号 if (tvSet.contains('ε')) i++; // 否则退出 处理下一个产生式 else break; } //此处处理产生式如A ->BC,B、C的first集都有ε if(i==str.length()) set.add('ε'); } FirstSet.put(ch,set); }- 求follow集：
课本上规则如下：
- 求follow集：
-
将放到follow（S）中，其中S是开始符号，#将放到follow（S）中，其中S是开始符号，而#是输入右端的结束标记。
-
如果存在一个产生式A→αBβ，那么first（β）中除ε之外的所有符号都在follow（B）中。
-
如果存在一个产生式A→αB，或存在产生式A→αBβ（β可以是单个非终结符，或数个非终结符的组合，β或许是CD）且first（β）包含ε，那么follow（A）中的所有符号都在follow（B）中。
举例说明：
①E→TE’
②E’→+TE’ | ε
③T→FT’
④T’→*FT’ | ε
⑤F→（E）| id
各个规则的展现：
规则一：E是文法的开始符号，第一步，follow(E).add(’#’)
规则二：对于产生式①E→TE’，follow(T).add(first(E’))
规则三：对于产生式①E→TE’，E’后面为空，故follow(E’).add(follow(E));又first(E’)包含空ε，follow(T).add(follow(E))
对每条产生式套用上述规则，循环至各个follow集都不增加。
因为：例如对于产生式①E→TE’，first(E’)包含空ε，follow(T).add(follow(E))，而此时follow(E)并未求完整。需要第二遍。
- 程序实现：
/**
* 生成FOLLOW集
*/
static void Follow(){
//此处我多循环了几次，合理的方法应该是看每一个非终结符的follow集师傅增加，不增加即可停止循环。
for (int i = 0; i <3 ; i++) {
for (Character ch:VnSet
) {
getFollow(ch);
}
}
}
/**
* 求单个字符的FOLLOW集
*/
static void getFollow(char c){
ArrayList<String> list = production.get(c);
HashSet<Character> setA = FollowSet.containsKey(c) ? FollowSet.get(c) : new HashSet<Character>();
//如果是开始符 添加 #
if (c == start) {
setA.add('#');
}
//查找输入的所有产生式，确定c的后跟 终结符
for (Character ch : VnSet) {
ArrayList<String> l = production.get(ch);
for (String s : l)
for (int i = 0; i < s.length(); i++)
if (s.charAt(i) == c && i + 1 < s.length() && VtSet.contains(s.charAt(i + 1)))
setA.add(s.charAt(i + 1));
}
FollowSet.put(c, setA);
//处理c的每一条产生式，从右向左分析，A->aBβ，
for (String s : list) {
int i = s.length() - 1;
while (i >= 0 ) {
char tn = s.charAt(i);
//只处理非终结符
if(VnSet.contains(tn)){
// 都按 A->αBβ 形式处理
//若β不存在 followA 加入 followB
//若β存在，把β的非空first集 加入followB
//若β存在 且 first(β)包含空串 followA 加入 followB
//若β存在
if (s.length() - i - 1 > 0) {
String right = s.substring(i + 1);
//非空first集 加入 followB
HashSet<Character> setF = null;
if( right.length() == 1){
if(!FirstSet.containsKey(right.charAt(0)))
getfisrst(right.charAt(0));
setF = FirstSet.get(right.charAt(0));
}
else{
//先找出右部的first集
if(!FirstSetX.containsKey(right))
getFirstX(right);
setF =FirstSetX.get(right);
}
HashSet<Character> setX = FollowSet.containsKey(tn) ? FollowSet.get(tn) : new HashSet<Character>();
for (Character var : setF)
if (var != 'ε')
setX.add(var);
FollowSet.put(tn, setX);
// 若first(β)包含空串 followA 加入 followB
if(setF.contains('ε')){
if(tn != c){
HashSet<Character> setB =FollowSet.containsKey(tn) ? FollowSet.get(tn) : new HashSet<Character>();
for (Character var : setA)
setB.add(var);
FollowSet.put(tn, setB);
}
}
}
//若β不存在 followA 加入 followB
else{
// A和B相同不添加
if(tn != c){
HashSet<Character> setB = FollowSet.containsKey(tn) ? FollowSet.get(tn) : new HashSet<Character>();
for (Character var : setA)
setB.add(var);
FollowSet.put(tn, setB);
}
}
i--;
}
//如果是终结符往前看 如 A->aaaBCDaaaa 此时β为 CDaaaa
else i--;
}
}
}
四、完整代码
IDEA 工程文件放在github上：https://github.com/mhl222/BiYiYuanLi_2
大家可直接git clone下来运行
import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.*;
/**
* class:
* --LL1:
* 实现LL(1)分析,构造分析预测程序（FIRST集-->FOLLOW集-->分析预测表-->stack预测分析）
* --Gui:
* 读取输入串，桌面程序展示分析预测步骤
*/
public class LL1 {
static String[] grammarStr = {"E->TG" ,"G->+TG|-TG" ,"G->ε" ,"T->FS" ,"S->*FS|/FS" ,"S->ε" ,"F->(E)" ,"F->i"};//相关文法
static HashMap<Character,ArrayList<String>> production = new HashMap<>();//产生式
static HashMap<Character, HashSet<Character>> FirstSet = new HashMap<>();//构造FIRST集合
static HashMap<String, HashSet<Character>> FirstSetX = new HashMap<>();//生成任何符号串的first
static HashMap<Character, HashSet<Character>> FollowSet = new HashMap<>();//构造FOLLOW集合
static String[][] table;//预测分析表
static HashSet<Character> VnSet = new HashSet<>();//非终结符Vn集合
static HashSet<Character> VtSet = new HashSet<>();//终结符Vt集合
static Stack<Character> stack = new Stack<>(); //符号栈
static String inStr="i+i*i#";//输入串
static Character start = 'E';
static int index = 0;//输入字符指针
static String action ="";
static ArrayList<Vector> stepList = new ArrayList<>();//与LL（1）无关，可不关心，为GUI记录了stack每一步的变化
public static void main(String[] args) {
dividechar();
First();
for (Character c : VnSet) {
ArrayList<String> l = production.get(c);
for (String s : l)
getFirstX(s);
}
Follow();
creatTable();
ouput();
processLL1();
}
/**
* 生成产生式Map(production)，划分终结符（vt）与非终结符（vn）
*/
static void dividechar(){
//生成产生式Map(production)
for (String str:grammarStr
) {
//将“|”相连的产生式分开
String[] strings = str.split("->")[1].split("\\|");
//非终结符
char Vch = str.charAt(0);
ArrayList<String> list = production.containsKey(Vch) ? production.get(Vch) : new ArrayList<String>();
for (String S:strings
) {
list.add(S);
}
production.put(str.charAt(0),list);
VnSet.add(Vch);
}
//寻找终结符
for (Character ch:VnSet
){
for (String str : production.get(ch)
) {
for (Character c: str.toCharArray()
) {
if( !VnSet.contains(c) )
VtSet.add(c);
}
}
}
}
/**
* 生成非终结符的FIRST集的递归入口
*/
static void First(){
//遍历求每一个非终结符vn的first集
for (Character vn: VnSet
) {
getfisrst(vn);
}
}
/**
* 生成非终结符FIRST集的递归程序
*/
static void getfisrst(Character ch){
ArrayList<String> ch_production = production.get(ch);
HashSet<Character> set = FirstSet.containsKey(ch) ? FirstSet.get(ch) : new HashSet<>();
// 当ch为终结符
if(VtSet.contains(ch)){
set.add(ch);
FirstSet.put(ch,set);
return;
}
//ch为vn
for (String str:ch_production
) {
int i = 0;
while (i < str.length()) {
char tn = str.charAt(i);
//递归
getfisrst(tn);
HashSet<Character> tvSet = FirstSet.get(tn);
// 将其first集加入左部
for (Character tmp : tvSet) {
if (tmp != 'ε')
set.add(tmp);
}
// 若包含空串 处理下一个符号
if (tvSet.contains('ε'))
i++;
// 否则退出 处理下一个产生式
else
break;
}
if(i==str.length())
set.add('ε');
}
FirstSet.put(ch,set);
}
/**
* 生成任何符号串的first
*/
static void getFirstX( String s) {
HashSet<Character> set = (FirstSetX.containsKey(s))? FirstSetX.get(s) : new HashSet<Character>();
// 从左往右扫描该式
int i = 0;
while (i < s.length()) {
char tn = s.charAt(i);
if(!FirstSet.containsKey(tn))
getfisrst(tn);
HashSet<Character> tvSet = FirstSet.get(tn);
// 将其非空 first集加入左部
for (Character tmp : tvSet)
if(tmp != 'ε')
set.add(tmp);
// 若包含空串 处理下一个符号
if (tvSet.contains('ε'))
i++;
// 否则结束
else
break;
// 到了尾部 即所有符号的first集都包含空串 把空串加入
if (i == s.length()) {
set.add('ε');
}
}
FirstSetX.put(s, set);
}
/**
* 生成FOLLOW集
*/
static void Follow(){
//此处我多循环了几次，合理的方法应该是看每一个非终结符的follow集师傅增加，不增加即可停止循环。
for (int i = 0; i <3 ; i++) {
for (Character ch:VnSet
) {
getFollow(ch);
}
}
}
static void getFollow(char c){
ArrayList<String> list = production.get(c);
HashSet<Character> setA = FollowSet.containsKey(c) ? FollowSet.get(c) : new HashSet<Character>();
//如果是开始符 添加 #
if (c == start) {
setA.add('#');
}
//查找输入的所有产生式，确定c的后跟 终结符
for (Character ch : VnSet) {
ArrayList<String> l = production.get(ch);
for (String s : l)
for (int i = 0; i < s.length(); i++)
if (s.charAt(i) == c && i + 1 < s.length() && VtSet.contains(s.charAt(i + 1)))
setA.add(s.charAt(i + 1));
}
FollowSet.put(c, setA);
//处理c的每一条产生式
for (String s : list) {
int i = s.length() - 1;
while (i >= 0 ) {
char tn = s.charAt(i);
//只处理非终结符
if(VnSet.contains(tn)){
// 都按 A->αBβ 形式处理
//若β不存在 followA 加入 followB
//若β存在，把β的非空first集 加入followB
//若β存在 且 first(β)包含空串 followA 加入 followB
//若β存在
if (s.length() - i - 1 > 0) {
String right = s.substring(i + 1);
//非空first集 加入 followB
HashSet<Character> setF = null;
if( right.length() == 1){
if(!FirstSet.containsKey(right.charAt(0)))
getfisrst(right.charAt(0));
setF = FirstSet.get(right.charAt(0));
}
else{
//先找出右部的first集
if(!FirstSetX.containsKey(right))
getFirstX(right);
setF =FirstSetX.get(right);
}
HashSet<Character> setX = FollowSet.containsKey(tn) ? FollowSet.get(tn) : new HashSet<Character>();
for (Character var : setF)
if (var != 'ε')
setX.add(var);
FollowSet.put(tn, setX);
// 若first(β)包含空串 followA 加入 followB
if(setF.contains('ε')){
if(tn != c){
HashSet<Character> setB =FollowSet.containsKey(tn) ? FollowSet.get(tn) : new HashSet<Character>();
for (Character var : setA)
setB.add(var);
FollowSet.put(tn, setB);
}
}
}
//若β不存在 followA 加入 followB
else{
// A和B相同不添加
if(tn != c){
HashSet<Character> setB = FollowSet.containsKey(tn) ? FollowSet.get(tn) : new HashSet<Character>();
for (Character var : setA)
setB.add(var);
FollowSet.put(tn, setB);
}
}
i--;
}
//如果是终结符往前看 如 A->aaaBCDaaaa 此时β为 CDaaaa
else i--;
}
}
}
/**
* 生成预测分析表
*/
static void creatTable(){
Object[] VtArray = VtSet.toArray();
Object[] VnArray = VnSet.toArray();
// 预测分析表初始化
table = new String[VnArray.length + 1][VtArray.length + 1];
table[0][0] = "Vn/Vt";
//初始化首行首列
for (int i = 0; i < VtArray.length; i++)
table[0][i + 1] = (VtArray[i].toString().charAt(0) == 'ε') ? "#" : VtArray[i].toString();
for (int i = 0; i < VnArray.length; i++)
table[i + 1][0] = VnArray[i] + "";
//全部置error
for (int i = 0; i < VnArray.length; i++)
for (int j = 0; j < VtArray.length; j++)
table[i + 1][j + 1] = "error";
//插入生成式
for (char A : VnSet) {
ArrayList<String> l = production.get(A);
for(String s : l){
HashSet<Character> set = FirstSetX.get(s);
for (char a : set)
insert(A, a, s);
if(set.contains('ε')) {
HashSet<Character> setFollow = FollowSet.get(A);
if(setFollow.contains('#'))
insert(A, '#', s);
for (char b : setFollow)
insert(A, b, s);
}
}
}
}
/**
* 将生成式插入表中
*/
static void insert(char X, char a,String s) {
if(a == 'ε') a = '#';
for (int i = 0; i < VnSet.size() + 1; i++) {
if (table[i][0].charAt(0) == X)
for (int j = 0; j < VtSet.size() + 1; j++) {
if (table[0][j].charAt(0) == a){
table[i][j] = s;
return;
}
}
}
}
/**
* 返回当前栈内容的字符串，与LL(1)无关，为GUI提供字符串
*
*/
static String getStack(){
String str ="";
for (Character ch : stack
) {
str+=ch;
}
return str;
}
/**
* 与LL（1）无关，为GUI的表格所需的setpList,提供一行数据
*/
static void addRowToList(String production,String action){
Vector v = new Vector();
v.add(stepList.size()+1);
v.add(getStack());
v.add(inStr.substring(index));
v.add(production);
v.add(action);
stepList.add(v);
}
/**
* 执行LL1栈分析
*/
static void processLL1(){
System.out.println("****************LL分析过程**********");
System.out.println(" Stack Input Action");
stack.push('#');
stack.push('E');
addRowToList("","");//GUI数据，可不关心
displayLL();
char X = stack.peek();
while (X != '#') {
char a = inStr.charAt(index);
if (X == a) {
action = "match " + stack.peek();
stack.pop();
index++;
addRowToList("","POP,GETNEXT(I)");//GUI数据，可不关心
}
// }else if (VtSet.contains(X))
// return;
else if (find(X, a).equals("error")){
boolean flag = false;
if(FirstSet.get(X).contains('ε')){
addRowToList(X+"->ε","POP");//GUI数据，可不关心
action = X+"->ε";
stack.pop();
flag = true;
}
if(!flag){
action="error";
addRowToList("","ERROR");//GUI数据，可不关心
displayLL();
return;
}
}
else if (find(X, a).equals("ε")) {
stack.pop();
action = X + "->ε";
addRowToList(action,"POP");//GUI数据，可不关心
}
else {
String str = find(X, a);
if (str != "") {
action = X + "->" + str;
stack.pop();
int len = str.length();
String pushStr="";
for (int i = len - 1; i >= 0; i--){
stack.push(str.charAt(i));
pushStr+=str.charAt(i);
}
addRowToList(action,"POP,PUSH("+pushStr+")");//GUI数据，可不关心
}
else {
System.out.println("error at '" + inStr.charAt(index) + " in " + index);
return;
}
}
X = stack.peek();
displayLL();
}
System.out.println("analyze LL1 successfully");
System.out.println("****************LL分析过程**********");
}
/**
*
* @param X 非终结符
* @param a 终结符
* @return 预测分析表中对应内容
*/
static String find(char X, char a) {
for (int i = 0; i < VnSet.size() + 1; i++) {
if (table[i][0].charAt(0) == X)
for (int j = 0; j < VtSet.size() + 1; j++) {
if (table[0][j].charAt(0) == a)
return table[i][j];
}
}
return "";
}
static void displayLL() {
// 输出 LL1单步处理
Stack<Character> s = stack;
System.out.printf("%23s", s);
System.out.printf("%13s", inStr.substring(index));
System.out.printf("%10s", action);
System.out.println();
}
/**
* 打印first.follow集，预测分析表
*/
static void ouput() {
System.out.println("*********first集********");
for (Character c : VnSet) {
HashSet<Character> set = FirstSet.get(c);
System.out.printf("%10s",c + " -> ");
for (Character var : set)
System.out.print(var);
System.out.println();
}
System.out.println("**********first集**********");
System.out.println("**********follow集*********");
for (Character c : VnSet) {
HashSet<Character> set =FollowSet.get(c);
System.out.print("Follow " + c + ":");
for (Character var : set)
System.out.print(var);
System.out.println();
}
System.out.println("**********follow集**********");
System.out.println("**********LL1预测分析表********");
for (int i = 0; i < VnSet.size() + 1; i++) {
for (int j = 0; j < VtSet.size() + 1; j++) {
System.out.printf("%6s", table[i][j] + " ");
}
System.out.println();
}
System.out.println("**********LL1预测分析表********");
}
}
class Gui extends JFrame {
static JButton btnLL1 = new JButton("LL(1)分析");
static JTextField input = new JTextField("i+i*i#",8);
static JLabel label = new JLabel("输入串:");
static JLabel first = new JLabel("FIRST:");
static JLabel follow = new JLabel("FOLLOW:");
static JLabel tit = new JLabel("--------------- LL(1)单步 -------------");
static JPanel contentPanel = new JPanel();
static Vector row= new Vector();;
static Vector row2= new Vector();
static Vector row3= new Vector();
static Vector columnNames2 = new Vector() ;
static Vector columnNames1 = new Vector() ;
static JTable table3;
static JTable table2;
static JTable table;
// public static void main(String[] args) {
// new Gui("LL1");
// }
public Gui(String title) throws HeadlessException {
super(title);
setSize(550,500);
setResizable(false);
contentPanel.setLayout(null);
columnNames1.add("步骤");
columnNames1.add("分析栈");
columnNames1.add( "剩余输入串");
columnNames1.add("所用产生式");
columnNames1.add("动作");
table = new JTable(row,columnNames1);
JScrollPane scrollPane1 = new JScrollPane(table);
columnNames2.add("非终结符");
columnNames2.add("结果");
table2 = new JTable(row2,columnNames2);
JScrollPane scrollPane2 = new JScrollPane(table2);
table3 = new JTable(row3,columnNames2);
JScrollPane scrollPane3 = new JScrollPane(table3);
contentPanel.add(btnLL1);
contentPanel.add(input);
contentPanel.add(label);
contentPanel.add(first);
contentPanel.add(follow);
contentPanel.add(scrollPane1);
contentPanel.add(scrollPane2);
contentPanel.add(scrollPane3);
contentPanel.add(tit);
label.setBounds(5,5,110,30);
input.setBounds(70,8,100,25);
btnLL1.setBounds(180,8,100,25);
first.setBounds(5,40,110,30);
follow.setBounds(280,40,110,30);
tit.setBounds(150,180,300,30);
scrollPane1.setBounds(5,220,520,200);
scrollPane2.setBounds(5,70,250,100);
scrollPane3.setBounds(280,70,250,100);
btnLL1.addActionListener(new Listener());
this.add(contentPanel);
this.setVisible(true);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
class Listener implements ActionListener {
@Override
public void actionPerformed(ActionEvent actionEvent) {
if(actionEvent.getSource()==btnLL1){
String in = input.getText();
LL1.inStr = in;
LL1.dividechar();
LL1.First();
for (Character ch:LL1.VnSet
) {
HashSet<Character> firset = LL1.FirstSet.get(ch);
String token = "";
for (Character c:firset
) {
token+=c;
}
Vector vc = new Vector();
vc.add(ch);
vc.add(token);
((DefaultTableModel)Gui.table2.getModel()).addRow(vc);
}
for (Character c : LL1.VnSet) {
ArrayList<String> l = LL1.production.get(c);
for (String s : l)
LL1.getFirstX(s);
}
LL1.Follow();
for (Character chr:LL1.VnSet
) {
HashSet<Character> firset = LL1.FollowSet.get(chr);
String token1 = "";
for (Character c:firset
) {
token1+=c;
}
Vector vc1 = new Vector();
vc1.add(chr);
vc1.add(token1);
((DefaultTableModel)Gui.table3.getModel()).addRow(vc1);
}
LL1.creatTable();
LL1.processLL1();
for (Vector vc2: LL1.stepList
) {
((DefaultTableModel)Gui.table.getModel()).addRow(vc2);
}
}
}
}
}
