编译原理 LL文法判别方法
Posted Ice丨shine
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了编译原理 LL文法判别方法相关的知识，希望对你有一定的参考价值。
实验目的与内容
理解LL(1)文法的判定方法，进一步掌握文法的改造原理（左递归消去、左公共因子提取），FIRST集、FOLLOW集的构造方法，预测分析表的的构造算法。
针对任意的文法，编写相应的左递归消除、左公共因子提取程序，求解相应的FIRST、FOLLOW集，构造预测分析表。
判断LL(1)文法部分：
- 输入：文法
- 处理：左递归消除、左公共因子提取，FIRST、FOLLOW等集合构造，判断LL(1)
- 输出：是LL(1)的情况输出预测分析表，否则判断不是LL(1)
程序总体设计思路和框架
使用公共map储存FIRST,FOLLOW,SELECT集，并记录开始符号、终结符号和非终结符号。
主要函数：
public static String Init(File file)
用于初始化分析，根据所给的路径读取txt中的文法，文法左式和右式用空格隔开（输入“E TX”代表“E->TX”）。确定终结符号和非终结符号以及开始符号。
public static boolean dofirst()
该函数用于找到文法非终结符号的FIRST集，根据定义求解FIRST集（对每一文法符号X∈VN 计算FIRST(X)）：
(1). 若X∈VT，则FIRST(X)＝{X}。
(2). 若X∈VN，且有产生式X→a…，a∈VT， 则 a∈FIRST(X)X→ε,则ε∈FIRST(X)。
(3). X→Y…是一个产生式且Y ∈VN 则把FIRST(Y)中的所有非空符号串ε元素都加入到FIRST(X)中。
(4).若X∈VN；Y1，Y2，…，Yi∈VN，且有产生式X→Y1 Y2 … Yn；当Y1 Y2 … Yn-1→ε时，则FIRST(Y1)、FIRST(Y2)、…、FIRST(Yn-1)的所有非空元素和FIRST(Yn) 包含在FIRST(X)中。
(5).当(4)中所有Yi→ε,(i=1,2,…n)，则
FIRST(X)=(FIRST(Y1)－{ε}）∪（FIRST(Y2)－ {ε}∪…∪（FIRST(Yn) －{ε}）∪{ε}
反复使用上述(2)～(5)步直到每个符号的FIRST集合不再增大为止。
如果存在左递归则输出false,以下函数都不再执行
public static void dofollow()
该函数用于找到文法的FOLLOW集，根据定义求解FOLLOW集（对每一文法符号S∈VN 计算FOLLOW(S)）：
(1). 设S为文法中开始符号，把{$}加入FOLLOW(S)中。
(2). 若A→αBβ是一个产生式，则把FIRST(β)的非空元素加入FOLLOW(B)中。如果β→ε则把FOLLOW(A)也加入FOLLOW(B)中。
(3).反复使用(b)直到每个非终结符的FOLLOW集不再增大为止。
public static void doSelect()
该函数用于找到文法的SELECT集,
若α不能推导出ε,则SELECT(A→α)=FIRST(α)
如果α能推导出ε则：SELECT(A→α)=（FIRST(α) –{ε}）∪FOLLOW(A)
public static boolean checkLL1()
该函数用于检查该文法是否为LL（1）文法
这里使用一个finalselect储存同一个非终结符号的SELECT集，并且将其转换为不能有重复元素的set集合，如果长度变小则不是LL(1)文法，如果长度相同则是LL（1）文法。
主要数据结构
public static String str="";
public static Map<Character,List<Character>> first = new HashMap<>();
public static Map<Character,List<Character>> follow = new HashMap<>();
public static Map<String,List<Character>> select = new HashMap<>();
public static Map<Character,List<Character>> finalselect = new HashMap<>();//储存同一个非终结符号的select集
public static List<Character> unfinal = new LinkedList<>();//非终结符号
public static List<Character> ifinal = new LinkedList<>();//终结符号
public static char begin;//开始符号
public static Map<Character,List<String>> relation = new HashMap<>();//储存文法
代码
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.*;
public class IsLL1 {//LL(1)文法判别方法
public static String str="";
public static Map<Character,List<Character>> first = new HashMap<>();
public static Map<Character,List<Character>> follow = new HashMap<>();
public static Map<String,List<Character>> select = new HashMap<>();
public static Map<Character,List<Character>> finalselect = new HashMap<>();//储存同一个非终结符号的select集
public static List<Character> unfinal = new LinkedList<>();//非终结符号
public static List<Character> ifinal = new LinkedList<>();//终结符号
public static char begin;//开始符号
public static Map<Character,List<String>> relation = new HashMap<>();//储存文法
public static String Init(File file){
try{
BufferedReader br = new BufferedReader(new FileReader(file));//构造一个BufferedReader类来读取文件
String s = null;
int is = 1;
while((s = br.readLine())!=null){//使用readLine方法，一次读一行
String[] s1 = s.split(" ");//按空格分隔，要求输入“E TX”代表“E->TX”
if(!unfinal.contains(s1[0].charAt(0)))
unfinal.add(s1[0].charAt(0));//加入左侧非终结符号
char[] chars = s1[1].toCharArray();
for (char aChar : chars) {
if(!ifinal.contains(aChar)) ifinal.add(aChar);//先加入，最后去除非终结符号
}
if(is == 1) {
begin = s1[0].charAt(0);
is = 0;
}
if(relation.containsKey(s1[0].charAt(0))){
relation.get(s1[0].charAt(0)).add(s1[1]);//如果已经有该文法了加入后面的list
}else{
List<String> list = new LinkedList<>();
list.add(s1[1]);
relation.put(s1[0].charAt(0),list);
}
str = str +s+" ";
}
for (int i = 0; i < ifinal.size(); i++) {//去除已经加入的非终结符号
if(unfinal.contains(ifinal.get(i))) {
ifinal.remove(i);
i--;
}
}
br.close();
}catch(Exception e){
e.printStackTrace();
}
return str;
}
public static boolean dofirst(){
int flag1=0,flag2=1;
while(flag1!=flag2){
//for(int i=0;i<2;i++){
flag1=flag2;
for (Map.Entry<Character, List<String>> entry : relation.entrySet()) {//遍历所有的关系
List<String> value = entry.getValue();
Character left = entry.getKey();
//System.out.println(entry);
List<Character> firstvalue = new LinkedList<>();
for (int i1 = 0; i1 < value.size(); i1++) {//遍历左式对应的所有右式
char[] chars = value.get(i1).toCharArray();
if(chars[0]==left){
System.out.println("存在左递归");
return false;
}
for (int i2 = 0; i2 < chars.length; i2++) {//遍历右式中的所有字符
if(ifinal.contains(chars[i2])){//包含终结字符则直接加入
if(!firstvalue.contains(chars[i2]))
firstvalue.add(chars[i2]);
//flag2++;
break;
}else if(unfinal.contains(chars[i2])){
if(first.containsKey(chars[i2])){//将非终结符号的first集除去ε后加入
List<Character> characters = first.get(chars[i2]);
for (int i3 = 0; i3 < characters.size(); i3++) {
if(characters.get(i3)!='ε') {
firstvalue.add(characters.get(i3));
//flag2++;
}
}
}
if(relation.get(chars[i2]).contains("ε")){//如果推导出ε则将其加入
firstvalue.add('ε');
//flag2++;
}else{
break;
}
}
}
}
List<Character> characters = first.get(entry.getKey());
if(!firstvalue.equals(characters)) flag2++;
// System.out.println("firstvalue: "+entry.getKey()+" "+firstvalue);
first.put(entry.getKey(),firstvalue);
}
}
return true;
}
public static void dofollow(){
List<Character> listbegin = new LinkedList<>();
listbegin.add('$');
follow.put(begin,listbegin);
int flag1=0,flag2=1;
while(flag1!=flag2) {
flag1=flag2;
for (Map.Entry<Character, List<String>> entry : relation.entrySet()) {//遍历所有的关系
List<String> value = entry.getValue();
Character left = entry.getKey();
// System.out.println(left);
//System.out.println(entry);
List<Character> followvalue = new LinkedList<>();
for (int i1 = 0; i1 < value.size(); i1++) {//遍历左式对应的所有右式
char[] chars = value.get(i1).toCharArray();
for (int i2 = chars.length-1; i2 >=0; i2--) {//遍历右式中的所有字符
if(unfinal.contains(chars[i2])){
if(follow.containsKey(left)){
//follow左式加入followcharsi2中
if(!follow.containsKey(chars[i2])){//右式follow集还未添加过元素
List<Character> list = new LinkedList<>();
List<Character> characters = follow.get(left);
list.addAll(characters);
follow.put(chars[i2],list);
flag2++;
}else{
List<Character> characters = follow.get(left);
for (int i = 0; i < characters.size(); i++) {
if(!follow.get(chars[i2]).contains(characters.get(i))){
follow.get(chars[i2]).add(characters.get(i));
flag2++;
}
}
}
}
}
if(ifinal.contains(chars[i2])||!relation.get(chars[i2]).contains("ε")) break;//若不能推出空则跳出循环
}
//System.out.println("follow1: "+follow);
for (int i2 = chars.length-1; i2 >0; i2--) {//遍历右式中的所有字符，这次并入first集
if(unfinal.contains(chars[i2-1])){
if(!follow.containsKey(chars[i2-1])){//还未添加过元素
List<Character> list = new LinkedList<>();
if(ifinal.contains(chars[i2])&&chars[i2]!='ε'){
list.add(chars[i2]);
flag2++;
}else if(unfinal.contains(chars[i2])){
List<Character> characters = first.get(chars[i2]);
for (int i3 = 0; i3 < characters.size(); i3++) {
if(characters.get(i3)!='ε') {
list.add(characters.get(i3));
flag2++;
}
}
}
follow.put(chars[i2-1],list);
}else{
if(chars[i2]!='ε'&&ifinal.contains(chars[i2])&&!follow.get(chars[i2-1]).contains(chars[i2])){
follow.get(chars[i2-1]).add(chars[i2]);
}else if(unfinal.contains(chars[i2])){
List<Character> characters = first.get(chars[i2]);
for (编译原理 LL文法判别方法