写一个ll1的语法分析器

好的，那么我们先来了解一下 LL(1) 语法分析器的相关知识。

LL(1) 语法分析器是指一种自顶向下的语法分析器，其中 LL 表示从左到右扫描输入串，从左到右处理推导式，1 表示每个输入符号都能唯一确定一个推导式。

实现 LL(1) 语法分析器的基本步骤如下：

1. 将文法转换为 LL(1) 文法。

2. 构造预测分析表。

3. 读入源程序，使用预测分析表进行语法分析。

下面我们来编写一个简单的 LL(1) 语法分析器的代码实现，其中我们使用 Java 语言来完成。

import java.util.*;

public class LL1Parser {
    private String[][] predictTable;
    private String[] terminals;
    private String[] nonTerminals;
    private String startSymbol;
    private String inputString;

    public LL1Parser(String[][] predictTable, String[] terminals, String[] nonTerminals, String startSymbol, String inputString) {
        this.predictTable = predictTable;
        this.terminals = terminals;
        this.nonTerminals = nonTerminals;
        this.startSymbol = startSymbol;
        this.inputString = inputString;
    }

    public void parse() {
        Stack<String> stack = new Stack<>();
        stack.push("$");
        stack.push(startSymbol);

        int inputIndex = 0;
        String curSymbol = inputString.charAt(inputIndex) + "";

        while (!stack.isEmpty()) {
            String topSymbol = stack.peek();

            if (isTerminal(topSymbol)) {
                if (topSymbol.equals(curSymbol)) {
                    stack.pop();
                    inputIndex++;
                    if (inputIndex < inputString.length()) {
                        curSymbol = inputString.charAt(inputIndex) + "";
                    } else {
                        curSymbol = "$";
                    }
                } else {
                    System.out.println("Error: Mismatched terminal symbol");
                    return;
                }
            } else if (isNonTerminal(topSymbol)) {
                int row = getNonTerminalIndex(topSymbol);
                int col = getTerminalIndex(curSymbol);

                if (row != -1 && col != -1) {
                    String production = predictTable[row][col];
                    if (!production.equals("")) {
                        stack.pop();
                        if (!production.equals("ε")) {
                            String[] symbols = production.split(" ");
                            for (int i = symbols.length - 1; i >= 0; i--) {
                                stack.push(symbols[i]);
                            }
                        }
                    } else {
                        System.out.println("Error: Empty production");
                        return;
                    }
                } else {
                    System.out.println("Error: Invalid row or column index");
                    return;
                }
            } else {
                System.out.println("Error: Invalid symbol");
                return;
            }
        }

        System.out.println("Parsing successful");
    }

    private boolean isTerminal(String symbol) {
        return Arrays.asList(terminals).contains(symbol);
    }

    private boolean isNonTerminal(String symbol) {
        return Arrays.asList(nonTerminals).contains(symbol);
    }

    private int getTerminalIndex(String terminal) {
        for (int i = 0; i < terminals.length; i++) {
            if (terminals[i].equals(terminal)) {
                return i;
            }
        }
        return -1;
    }

    private int getNonTerminalIndex(String nonTerminal) {
        for (int i = 0; i < nonTerminals.length; i++) {
            if (nonTerminals[i].equals(nonTerminal)) {
                return i;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        String[][] predictTable = {
                {"", "", "", "ε", "", ""},
                {"", "aBa", "", "", "aBa", "aBa"},
                {"", "", "bBc", "", "", ""},
                {"", "d", "", "", "d", "d"},
                {"", "", "", "ε", "", ""},
                {"", "", "", "ε", "", ""}
        };
        String[] terminals = {"a", "b", "c", "d", "$"};
        String[] nonTerminals = {"S", "A", "B", "C", "D", "E"};
        String startSymbol = "S";
        String inputString = "adbd$";

        LL1Parser parser = new LL1Parser(predictTable, terminals, nonTerminals, startSymbol, inputString);
        parser.parse();
    }
}

在上述代码中，我们定义了一个 LL1Parser 类，其中包含了 parse() 方法用于进行语法分析。在构造函数中，我们需要传入预测分析表、终结符集合、非终结符集合、起始符号和输入串。在 parse() 方法中，我们使用栈来模拟语法分析的过程，并根据不同情况进行相应的处理。最后，我们可以通过 main() 方法来测试代码的正确性。

当然，这只是一个简单的 LL(1) 语法分析器的实现，实际应用中还需要考虑更多的情况和细节。