Examples with FirstSetSolver priv.bajdcc.LL1.syntax.solver.FirstSetSolver used on opensource projects

Example 1 with FirstSetSolver

use of priv.bajdcc.LL1.syntax.solver.FirstSetSolver in project jMiniLang by bajdcc.

the class Syntax method semanticAnalysis.

/**
 * 进行语义分析
 *
 * @throws SyntaxException 词法错误
 */
private void semanticAnalysis() throws SyntaxException {
    /* 非终结符数量 */
    int size = arrNonTerminals.size();
    /* 计算规则的First集合 */
    for (RuleExp exp : arrNonTerminals) {
        for (RuleItem item : exp.rule.arrRules) {
            FirstsetSolver solver = new FirstsetSolver();
            // 计算规则的First集合
            item.expression.visit(solver);
            if (!solver.solve(item)) {
                // 若串长度可能为零，即产生空串
                err(SyntaxError.EPSILON, getSingleString(exp.name, item.expression));
            }
        }
    }
    /* 建立连通矩阵 */
    // 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)) {
                // 直接左递归
                arrNonTerminals.get(i).rule.iRecursiveLevel = 1;
                firstsetDependency.clear(i, i);
            }
        }
        /* 获得拷贝 */
        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);
            }
        }
    }
    /* 计算完整的First集合 */
    {
        /* 建立处理标记表 */
        BitSet processed = new BitSet(size);
        processed.clear();
        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);
            }
            /* 计算该规则的终结符First集合 */
            {
                Rule rule = arrNonTerminals.get(nodependencyRule).rule;
                /* 计算规则的终结符First集合 */
                for (RuleItem item : rule.arrRules) {
                    for (RuleExp exp : item.setFirstSetRules) {
                        item.setFirstSetTokens.addAll(exp.rule.arrTokens);
                    }
                }
                /* 计算非终结符的终结符First集合 */
                for (RuleItem item : rule.arrRules) {
                    rule.arrTokens.addAll(item.setFirstSetTokens);
                }
                /* 修正左递归规则的终结符First集合 */
                for (RuleItem item : rule.arrRules) {
                    if (item.setFirstSetRules.contains(arrNonTerminals.get(nodependencyRule))) {
                        item.setFirstSetTokens.addAll(rule.arrTokens);
                    }
                }
            }
            /* 清除该规则 */
            processed.set(nodependencyRule);
            for (int j = 0; j < size; j++) {
                firstsetDependency.clear(j, nodependencyRule);
            }
        }
    }
    /* 搜索不能产生字符串的规则 */
    for (RuleExp exp : arrNonTerminals) {
        for (RuleItem item : exp.rule.arrRules) {
            if (item.setFirstSetTokens.isEmpty()) {
                err(SyntaxError.FAILED, getSingleString(exp.name, item.expression));
            }
        }
    }
}

Example 2 with FirstSetSolver

use of priv.bajdcc.LL1.syntax.solver.FirstSetSolver 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);
        }
    }
}