LL(1)文法first集

LL(1) 文法 first集

 思路:  利用递归(但普通递归的方法不能处理非终极符直接递归和间接递归的情况) 考虑到这种情况,见下方利用bfs遍历first集关系图的方法

第一步先计算可导空的非终极符集合

  令first(X)=空

  若 X->a... 则将a加入first(X) 

  若 X->ABC.. ,则计算first(A) ,first(B) ,first(C)..直到遇到第一个不导空的非终结符或者终极符,则将他们都加入first(X) 并除去^(空串)的情况

  若 右部可以导空,将右部所有的非终结符的first集加入first(X),并加上空串的情况

package first_collection;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
* first集
* 第一步先计算可导空的非终极符集合
* 令first(X)=空
* 若 X->a... 则将a加入first(X)
* 若 X->ABC.. ,则计算first(A) ,first(B) ,first(C)..直到遇到第一个不导空的非终结符或者终极符,则将他们都加入first(X) 并除去^(空串)的情况
* 若 右部可以导空,将右部所有的非终结符的first集加入first(X),并加上空串的情况
*
* @author parting_soul
*
*/
public class FirstCollection {
private Set<Character> emptyNonTerminal;
private List<Rule> ruleLists;
private Set<Character> terminalC;
private Set<Character> nonterminalC;
private Map<String, Set<Character>> first;

public FirstCollection() {
ruleLists = new ArrayList<>();
terminalC = new HashSet<>();
nonterminalC = new HashSet<>();
init();
}

/**
* 输入产生式,求出可导空的非终结符
*/
private void init() {
inputRuleLists();
// 计算可导空的非终结符集合
EmptyNonterminalSet nonterminalSet = new EmptyNonterminalSet(ruleLists);
nonterminalSet.solve();
emptyNonTerminal = nonterminalSet.getR();
first = new HashMap<String, Set<Character>>();
initRuleVisit();
}

private void initRuleVisit() {
for (Rule r : ruleLists) {
r.isVisit = false;
}
}

public void getTerminalFirst(char noTernimalLeft) {
Rule r = null;
Set<Character> terminalFirstSet = null;
// 判断之前是否存在该非终结符的first集
if ((terminalFirstSet = first.get(noTernimalLeft + "")) == null) {
// 没有计算过,新建一个集合用来保存该非终结符的first集
terminalFirstSet = new HashSet<>();
first.put(noTernimalLeft + "", terminalFirstSet);
// System.out.println(noTernimalLeft + " create ");
}
for (int i = 0; i < ruleLists.size(); i++) {
// 遍历所有的产生式,计算每一个左边为该非终结符产生式的first集
r = ruleLists.get(i);
// 如果该产生式别计算过,直接选择下一个产生式
if (r.isVisit)
continue;
if (r.left.equals(noTernimalLeft + "")) {
// System.out.println(r);
// 找到左部为该非终极符的产生式,标记为访问过
r.isVisit = true;
String right = r.right;
for (int j = 0; j < right.length(); j++) {
// 右部从左到右扫描每一个字符
char c = right.charAt(j);
if (!isNonTerminal(c)) {
// 如果是非终结符,直接加入到first集,然后停止计算
terminalFirstSet.add(c);
// System.out.println(r.left + " -> " + r.right + " " +
// c);
break;
} else {
// 如果当前为非终结符,递归计算该非终结符的first集
getTerminalFirst(c);
// System.out.println(r.left + " -> " + r.right + " " +
// c + " nonterminal " + first.get(c + ""));
// 将该非终结符的first集加入当前待求的first集中
terminalFirstSet.addAll(first.get(c + ""));
// 除去空串
terminalFirstSet.remove('^');
if (!emptyNonTerminal.contains(c)) {
// 如果当前非终结符不可导空,不用继续计算,跳出循环
break;
}
}
}
// 判断当前产生式最后一个字符是否可导空
char last = right.charAt(right.length() - 1);
if (emptyNonTerminal.contains(last)) {
// 可导空则加入空串
terminalFirstSet.add('^');
}
}
}
}

public Map<String, Set<Character>> getFirstCollection() {
for (Character c : nonterminalC) {
// System.out.println(" current " + c);
// 遍历每一个非终结符,求出该非终结符的first集
getTerminalFirst(c);
}
return first;
}

public static void main(String[] args) {
FirstCollection collection = new FirstCollection();
collection.printTerAndNon();
Map<String, Set<Character>> first = collection.getFirstCollection();
System.out.println(first);
}

/**
* 输入产生式
*/
private void inputRuleLists() {
BufferedReader reader = null;
try {
reader = new BufferedReader(new InputStreamReader(new FileInputStream(new File("rule.txt"))));
String str = null;
while ((str = reader.readLine()) != null) {
// System.out.println(str);
saveRule(str);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
reader = null;
}
}
}
}

/**
* 分析产生式
*
* @param str
*/
private void saveRule(String str) {
String[] strs = str.split("->");
// System.out.println(strs.length);
if (strs.length == 2) {
Rule r = new Rule();
r.left = strs[0];
r.right = strs[1];
if (isNonTerminal(r.left.charAt(0))) {
nonterminalC.add(r.left.charAt(0));
for (int i = 0; i < r.right.length(); i++) {
char c = r.right.charAt(i);
if (!isNonTerminal(c)) {
terminalC.add(c);
} else {
nonterminalC.add(c);
}
}
ruleLists.add(r);
}
}
}

void printTerAndNon() {
System.out.println("终结符:");
for (Character c : terminalC) {
System.out.print(c + " ");
}
System.out.println();
System.out.println("非终结符:");
for (Character c : nonterminalC) {
System.out.print(c + " ");
}
System.out.println();
System.out.println("产生式");
for (Rule r : ruleLists) {
System.out.println(r.left + "->" + r.right);
}
System.out.println("可导空非终极符");
System.out.println(emptyNonTerminal);
}

/**
* 是否为终极符
*
* @param c
* @return
*/
private boolean isNonTerminal(char c) {
if (c >= 'A' && c <= 'Z') {
return true;
}
return false;
}

}

/**
* 求出可导空的非终极符集合类
*
* @author parting_soul
*
*/
class EmptyNonterminalSet {
private List<Rule> L;

private Set<Character> R = new HashSet<>();

public EmptyNonterminalSet(List<Rule> L) {
this.L = L;
}

public Set<Character> getR() {
return R;
}

public void solve() {
// 先扫描一遍所有的产生式，将右端为空的且左端为终结符的产生式左端加入集合R中(这里^号表示空)
for (int i = 0; i < L.size(); i++) {
Rule r = L.get(i);
if (r.right.equals("^") && !isTerminator(r.left.charAt(0))) {
R.add(r.left.charAt(0));
r.isVisit = true;
}
}

int rLength = 0;
while (rLength != R.size()) {
rLength = R.size();
for (int i = 0; i < L.size(); i++) {
Rule r = L.get(i);
if (!r.isVisit && isBelongToR(r.right)) {
R.add(r.left.charAt(0));
r.isVisit = true;
}
}
}
}

/**
* 判断产生式右端的所有字符是否属于R
*
* @return
*/
private boolean isBelongToR(String right) {
for (int i = 0; i < right.length(); i++) {
if (!R.contains(right.charAt(i))) {
// System.out.println(right.charAt(i));
return false;
}
}
return true;
}

// 判断是否是终结符
public boolean isTerminator(Character c) {
return Character.isLowerCase(c);
}

public void print() {
for (Rule r : L) {
System.out.println(r);
}
}

public void printR() {
for (Character c : R) {
System.out.print(c + " ");
}
System.out.println();
}

}

class Rule {
String left;
String right;
boolean isVisit;

@Override
public String toString() {
return "Rule [left=" + left + ", right=" + right + ", isVisit=" + isVisit + "]";
}

}

利用bfs的方法

first集 思想: 利用图的广度遍历

对文法先进行预处理,求出每一个非终结符的出度

然后将待求的非终结符加入到队列,并标记为访问过,然后开始广度优先遍历,

队列为空,则停止遍历,若出队的是终极符,则加入到该非终结符的first集中

若出队的是非终结符,则将该非终结符中没有被访问过的出度加入到队列中

package first_collection_bfs;

import java.io.*;
import java.util.*;

/**
* first集 思想: 利用图的广度遍历
* 对文法先进行预处理,求出每一个非终结符的出度
* 然后将待求的非终结符加入到队列,并标记为访问过,然后开始广度优先遍历,
* 队列为空,则停止遍历,若出队的是终极符,则加入到该非终结符的first集中
* 若出队的是非终结符,则将该非终结符中没有被访问过的出度加入到队列中
*
* @author parting_soul
*/
public class FirstCollection {
private Set<Character> emptyNonTerminal;
private List<Rule> ruleLists;
private Set<Character> terminalC;
private Set<Character> nonterminalC;
private Map<String, Set<Character>> first;
private Map<Character, Set<Character>> map;
private Queue<Character> queue;

private Map<Character, Boolean> isVisistMap;

public FirstCollection() {
ruleLists = new ArrayList<>();
terminalC = new HashSet<>();
nonterminalC = new HashSet<>();
map = new HashMap<>();
queue = new LinkedList<>();
isVisistMap = new HashMap<>();
init();
}

/**
* 输入产生式,求出可导空的非终结符
*/
private void init() {
inputRuleLists();
// 计算可导空的非终结符集合
EmptyNonterminalSet nonterminalSet = new EmptyNonterminalSet(ruleLists);
nonterminalSet.solve();
emptyNonTerminal = nonterminalSet.getR();
getMap();
first = new HashMap<>();
}

/**
* 预处理,得到每一个非终结符的出度
*/
private void getMap() {
for (char c : nonterminalC) {
for (int j = 0; j < ruleLists.size(); j++) {
Rule rule = ruleLists.get(j);
if (rule.left.equals(c + "")) {
Set<Character> characters = map.get(c);
if (characters == null) {
characters = new HashSet<>();
}
for (int k = 0; k < rule.right.length(); k++) {
char currentC = rule.right.charAt(k);
if ("^".equals(currentC + "")) break;
characters.add(currentC);
if (!isNonTerminal(currentC) || !emptyNonTerminal.contains(currentC)) {
break;
}
}
map.put(c, characters);
}

}
}
}

/**
* bfs求非终结符first
*
* @param noTernimalLeft
*/
public void getNonTerminalFirstByBFS(char noTernimalLeft) {
queue.clear();
//将待求的非终结符加入队列
queue.offer(noTernimalLeft);
//标记为访问过
isVisistMap.put(noTernimalLeft, true);
Set<Character> sets = new HashSet<>();
first.put(noTernimalLeft + "", sets);
while (queue.size() != 0) {
//队首出队
char currentC = queue.poll();
if (!isNonTerminal(currentC)) {
//如果是终结符加入到该非终结符的first中
sets.add(currentC);
continue;
}
//如果是非终结符,就遍历该非终结符的出度
Set<Character> characters = map.get(currentC);
for (char c : characters) {
if (!isNonTerminal(c)) {
//如果是终结符,直接加入队列
queue.offer(c);
continue;
}
//如果是非终结符就先判断是否访问过,没有访问过就入队,并标记为访问过
boolean isVisist = isVisistMap.get(c);
if (isVisist) continue;
isVisistMap.put(c, true);
queue.offer(c);
}
}

}

public Map<String, Set<Character>> getFirstCollection() {
for (Character c : nonterminalC) {
// System.out.println(" current " + c);
// 遍历每一个非终结符,求出该非终结符的first集
getNonTerminalFirstByBFS(c);
//重置非终结符为未访问
initNonTernimalVisit();
//若该非终结符可导空,加入^
if (emptyNonTerminal.contains(c)) {
first.get(c.charValue() + "").add('^');
}
}
return first;
}

private void initNonTernimalVisit() {
for (char c : nonterminalC) {
isVisistMap.put(c, false);
}
}

public static void main(String[] args) {
FirstCollection collection = new FirstCollection();
collection.printTerAndNon();
Map<String, Set<Character>> first = collection.getFirstCollection();
System.out.println(first);
}

/**
* 输入产生式
*/
private void inputRuleLists() {
BufferedReader reader = null;
try {
reader = new BufferedReader(new InputStreamReader(new FileInputStream(new File("rule1.txt"))));
String str = null;
while ((str = reader.readLine()) != null) {
// System.out.println(str);
saveRule(str);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
reader = null;
}
}
}
}

/**
* 分析产生式
*
* @param str
*/
private void saveRule(String str) {
String[] strs = str.split("->");
// System.out.println(strs.length);
if (strs.length == 2) {
Rule r = new Rule();
r.left = strs[0];
r.right = strs[1];
if (isNonTerminal(r.left.charAt(0))) {
nonterminalC.add(r.left.charAt(0));
isVisistMap.put(r.left.charAt(0), false);
for (int i = 0; i < r.right.length(); i++) {
char c = r.right.charAt(i);
if (!isNonTerminal(c)) {
terminalC.add(c);
} else {
nonterminalC.add(c);
}
}
ruleLists.add(r);
}
}
}

void printTerAndNon() {
System.out.println("终结符:");
for (Character c : terminalC) {
System.out.print(c + " ");
}
System.out.println();
System.out.println("非终结符:");
for (Character c : nonterminalC) {
System.out.print(c + " ");
}
System.out.println();
System.out.println("产生式");
for (Rule r : ruleLists) {
System.out.println(r.left + "->" + r.right);
}
System.out.println("可导空非终极符");
System.out.println(emptyNonTerminal);
}

/**
* 是否为非终极符
*
* @param c
* @return
*/
private boolean isNonTerminal(char c) {
if (c >= 'A' && c <= 'Z') {
return true;
}
return false;
}

}

/**
* 求出可导空的非终极符集合类
*
* @author parting_soul
*/
class EmptyNonterminalSet {
private List<Rule> L;

private Set<Character> R = new HashSet<>();

public EmptyNonterminalSet(List<Rule> L) {
this.L = L;
}

public Set<Character> getR() {
return R;
}

public void solve() {
// 先扫描一遍所有的产生式，将右端为空的且左端为终结符的产生式左端加入集合R中(这里#号表示空)
for (int i = 0; i < L.size(); i++) {
Rule r = L.get(i);
if (r.right.equals("^") && !isTerminator(r.left.charAt(0))) {
R.add(r.left.charAt(0));
r.isVisit = true;
}
}

int rLength = 0;
while (rLength != R.size()) {
rLength = R.size();
for (int i = 0; i < L.size(); i++) {
Rule r = L.get(i);
if (!r.isVisit && isBelongToR(r.right)) {
R.add(r.left.charAt(0));
r.isVisit = true;
}
}
}
}

/**
* 判断产生式右端的所有字符是否属于R
*
* @return
*/
private boolean isBelongToR(String right) {
for (int i = 0; i < right.length(); i++) {
if (!R.contains(right.charAt(i))) {
// System.out.println(right.charAt(i));
return false;
}
}
return true;
}

// 判断是否是终结符
public boolean isTerminator(Character c) {
return Character.isLowerCase(c);
}

public void print() {
for (Rule r : L) {
System.out.println(r);
}
}

public void printR() {
for (Character c : R) {
System.out.print(c + " ");
}
System.out.println();
}

}

class Rule {
String left;
String right;
boolean isVisit;

@Override
public String toString() {
return "Rule [left=" + left + ", right=" + right + ", isVisit=" + isVisit + "]";
}

}