use of priv.bajdcc.LALR1.syntax.exp.RuleExp in project jMiniLang by bajdcc.
the class Syntax method getOriginalString.
/**
* 获得原推导式描述
* @return 原推导式描述
*/
public String getOriginalString() {
StringBuilder sb = new StringBuilder();
for (RuleExp exp : arrNonTerminals) {
for (RuleItem item : exp.rule.arrRules) {
sb.append(getSingleString(exp.name, item.expression));
sb.append(System.lineSeparator());
}
}
return sb.toString();
}
use of priv.bajdcc.LALR1.syntax.exp.RuleExp in project jMiniLang by bajdcc.
the class PredictionTable method predict.
/**
* 构造预测分析表
*/
private void predict() {
for (RuleExp exp : arrNonTerminals) {
indexVn++;
for (RuleItem item : exp.rule.arrRules) {
this.item = item;
item.expression.visit(this);
}
}
}
use of priv.bajdcc.LALR1.syntax.exp.RuleExp in project jMiniLang by bajdcc.
the class Syntax method buildFirstAndFollow.
/**
* 构造First集和Follow集
*
* @throws SyntaxException 词法错误
*/
private void buildFirstAndFollow() throws SyntaxException {
/* 非终结符数量 */
int size = arrNonTerminals.size();
/* 计算规则的First集合 */
boolean update;
do {
update = false;
for (RuleExp exp : arrNonTerminals) {
for (RuleItem item : exp.rule.arrRules) {
FirstSetSolver solver = new FirstSetSolver();
// 计算规则的First集合
item.expression.visit(solver);
item.epsilon = solver.solve(item);
if (item.epsilon && !exp.rule.epsilon) {
exp.rule.epsilon = true;
update = true;
}
}
}
} while (update);
/* 建立连通矩阵 */
// First集依赖矩阵
BitVector2 firstsetDependency = new BitVector2(size, size);
firstsetDependency.clear();
/* 计算非终结符First集合包含关系的布尔连通矩阵 */
{
int i = 0;
for (RuleExp exp : arrNonTerminals) {
for (RuleItem item : exp.rule.arrRules) {
for (RuleExp rule : item.setFirstSetRules) {
firstsetDependency.set(i, rule.id);
}
}
i++;
}
}
/* 检查间接左递归 */
{
/* 标记直接左递归 */
for (int i = 0; i < size; i++) {
if (firstsetDependency.test(i, i)) {
// 出现直接左递归
err(SyntaxError.DIRECT_RECURSION, arrNonTerminals.get(i).name);
}
}
/* 获得拷贝 */
BitVector2 a = (BitVector2) firstsetDependency.clone();
BitVector2 b = (BitVector2) firstsetDependency.clone();
BitVector2 r = new BitVector2(size, size);
/* 检查是否出现环 */
for (int level = 2; level < size; level++) {
/* 进行布尔连通矩阵乘法,即r=aXb */
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
r.clear(i, j);
for (int k = 0; k < size; k++) {
boolean value = r.test(i, j) || (a.test(i, k) && b.test(k, j));
r.set(i, j, value);
}
}
}
/* 检查当前结果是否出现环 */
{
int i = 0;
for (RuleExp exp : arrNonTerminals) {
if (r.test(i, i)) {
if (exp.rule.iRecursiveLevel < 2) {
exp.rule.iRecursiveLevel = level;
}
}
i++;
}
}
/* 保存结果 */
a = (BitVector2) r.clone();
}
/* 检查是否存在环并报告错误 */
for (RuleExp exp : arrNonTerminals) {
if (exp.rule.iRecursiveLevel > 1) {
err(SyntaxError.INDIRECT_RECURSION, exp.name + " level:" + exp.rule.iRecursiveLevel);
}
}
}
/* 建立规则的依赖关系 */
ArrayList<Integer> nodependencyList = new ArrayList<>();
{
/* 建立处理标记表 */
BitSet processed = new BitSet(size);
processed.clear();
/* 寻找First集的依赖关系 */
for (RuleExp arrNonTerminal : arrNonTerminals) {
/* 找出一条无最左依赖的规则 */
// 最左依赖的规则索引
int nodependencyRule = -1;
for (int j = 0; j < size; j++) {
if (!processed.get(j)) {
boolean empty = true;
for (int k = 0; k < size; k++) {
if (firstsetDependency.test(j, k)) {
empty = false;
break;
}
}
if (empty) {
// 找到
nodependencyRule = j;
break;
}
}
}
if (nodependencyRule == -1) {
err(SyntaxError.MISS_NODEPENDENCY_RULE, arrNonTerminal.name);
}
/* 清除该规则 */
processed.set(nodependencyRule);
for (int j = 0; j < size; j++) {
firstsetDependency.clear(j, nodependencyRule);
}
nodependencyList.add(nodependencyRule);
}
}
for (int nodependencyRule : nodependencyList) {
/* 计算该规则的终结符First集合 */
Rule rule = arrNonTerminals.get(nodependencyRule).rule;
/* 计算规则的终结符First集合 */
for (RuleItem item : rule.arrRules) {
for (RuleExp exp : item.setFirstSetRules) {
item.setFirstSetTokens.addAll(exp.rule.arrFirsts);
}
}
/* 计算非终结符的终结符First集合 */
for (RuleItem item : rule.arrRules) {
rule.arrFirsts.addAll(item.setFirstSetTokens);
}
}
/* 搜索不能产生字符串的规则 */
for (RuleExp exp : arrNonTerminals) {
for (RuleItem item : exp.rule.arrRules) {
if (item.setFirstSetTokens.isEmpty()) {
err(SyntaxError.FAILED, getSingleString(exp.name, item.expression));
}
}
}
/* 求Follow集 */
mapNonTerminals.get(beginRuleName).rule.setFollows.add(mapTerminals.get(epsilonName));
do {
update = false;
for (RuleExp origin : arrNonTerminals) {
for (RuleItem item : origin.rule.arrRules) {
for (RuleExp target : arrNonTerminals) {
FollowSetSolver solver = new FollowSetSolver(origin, target);
if (origin.name.equals("E1") && target.name.equals("T")) {
update = !!update;
}
item.expression.visit(solver);
update |= solver.isUpdated();
}
}
}
} while (update);
/* 将哈希表按ID排序并保存 */
for (RuleExp exp : arrNonTerminals) {
for (RuleItem item : exp.rule.arrRules) {
item.arrFirstSetTokens = sortTerminal(item.setFirstSetTokens);
item.parent.arrFollows = sortTerminal(item.parent.setFollows);
}
}
}
use of priv.bajdcc.LALR1.syntax.exp.RuleExp in project jMiniLang by bajdcc.
the class Syntax method addNonTerminal.
/**
* 添加非终结符
*
* @param name
* 非终结符名称
* @throws SyntaxException 词法错误
*/
public void addNonTerminal(String name) throws SyntaxException {
RuleExp exp = new RuleExp(arrNonTerminals.size(), name);
if (!mapNonTerminals.containsKey(name)) {
mapNonTerminals.put(name, exp);
arrNonTerminals.add(exp);
} else {
err(SyntaxError.REDECLARATION);
}
}
use of priv.bajdcc.LALR1.syntax.exp.RuleExp in project jMiniLang by bajdcc.
the class Syntax method getOriginalString.
/**
* 获得原推导式描述
* @return 原推导式描述
*/
public String getOriginalString() {
StringBuilder sb = new StringBuilder();
for (RuleExp exp : arrNonTerminals) {
for (RuleItem item : exp.rule.arrRules) {
sb.append(getSingleString(exp.name, item.expression));
sb.append(System.lineSeparator());
}
}
return sb.toString();
}
Aggregations