E → TE' E' → +TE' | -TE' | ε T → FT' T' → *FT' | /FT' | ε F → i | (E)写出对应的递归下降语法分析器

以下是对应的递归下降语法分析器：

def E():
    T()
    E_()

def E_():
    if lookahead == '+':
        match('+')
        T()
        E_()
    elif lookahead == '-':
        match('-')
        T()
        E_()
    else:
        pass

def T():
    F()
    T_()

def T_():
    if lookahead == '*':
        match('*')
        F()
        T_()
    elif lookahead == '/':
        match('/')
        F()
        T_()
    else:
        pass

def F():
    if lookahead == 'i':
        match('i')
    elif lookahead == '(':
        match('(')
        E()
        match(')')
    else:
        error()

其中，`match()`函数表示匹配读入符号和当前待分析符号是否相同，如果相同，则读入下一个符号；否则，抛出错误。`lookahead`变量表示当前待分析符号。

相关问题

E → TE' E' → +TE' | -TE' | ε T → FT' T' → *FT' | /FT' | ε F → i | (E)写出对应的java递归下降语法分析器和操作步骤

以下是对应的Java递归下降语法分析器和操作步骤：

// 定义全局变量
int ptr = 0; // 指向当前读入符号的位置
String input; // 存储输入的字符串
char lookahead; // 存储当前待分析符号

// 读取下一个符号
void next() {
    if (ptr < input.length()) {
        lookahead = input.charAt(ptr++);
    } else {
        lookahead = '\0'; // 表示输入串已经结束
    }
}

// 匹配当前符号
void match(char c) {
    if (lookahead == c) {
        next();
    } else {
        error();
    }
}

// E -> TE'
void E() {
    T();
    E_();
}

// E' -> +TE' | -TE' | ε
void E_() {
    if (lookahead == '+') {
        match('+');
        T();
        E_();
        System.out.print("+");
    } else if (lookahead == '-') {
        match('-');
        T();
        E_();
        System.out.print("-");
    } else {
        // 空产生式，不输出任何符号
    }
}

// T -> FT'
void T() {
    F();
    T_();
}

// T' -> *FT' | /FT' | ε
void T_() {
    if (lookahead == '*') {
        match('*');
        F();
        T_();
        System.out.print("*");
    } else if (lookahead == '/') {
        match('/');
        F();
        T_();
        System.out.print("/");
    } else {
        // 空产生式，不输出任何符号
    }
}

// F -> i | (E)
void F() {
    if (lookahead == 'i') {
        match('i');
        System.out.print("i");
    } else if (lookahead == '(') {
        match('(');
        E();
        match(')');
    } else {
        error();
    }
}

// 错误处理
void error() {
    System.out.println("Syntax error!");
    System.exit(1);
}

// 分析输入串
void parse(String s) {
    input = s;
    next(); // 读入第一个符号
    E(); // 从E开始分析
    if (lookahead == '\0') {
        System.out.println("Parsing succeeded!");
    } else {
        System.out.println("Parsing failed!");
    }
}

对于输入串 `i+i*i#`，调用 `parse()` 函数进行分析：

parse("i+i*i#");

输出结果为：

i+i*i
Parsing succeeded!

其中，输出结果 `i+i*i` 表示根据输入串推导出的表达式。

E→T|E+T|E-T T→F|T*F|T/F F→i|(E)消除左递归

消除 E 的左递归，得到如下文法：

E -> TE'
E' -> +TE' | -TE' | ε
T -> FT'
T' -> *FT' | /FT' | ε
F -> i | (E)

其中，E' 和 T' 是 E 和 T 的右部公共结尾。

接下来，我们可以使用递归下降语法分析器对消除左递归后的文法进行语法分析。以下是相应的 Python 代码：

# 定义全局变量
lookahead = None
index = 0
input_str = ""

# E -> TE'
def parse_expression():
    parse_term()
    parse_expression_prime()

# E' -> +TE' | -TE' | ε
def parse_expression_prime():
    if lookahead == '+':
        match('+')
        parse_term()
        parse_expression_prime()
        print('+')
    elif lookahead == '-':
        match('-')
        parse_term()
        parse_expression_prime()
        print('-')

# T -> FT'
def parse_term():
    parse_factor()
    parse_term_prime()

# T' -> *FT' | /FT' | ε
def parse_term_prime():
    if lookahead == '*':
        match('*')
        parse_factor()
        parse_term_prime()
        print('*')
    elif lookahead == '/':
        match('/')
        parse_factor()
        parse_term_prime()
        print('/')

# F -> i | (E)
def parse_factor():
    if lookahead.isdigit():
        print('i')
        match('digit')
    elif lookahead == '(':
        match('(')
        parse_expression()
        match(')')
    else:
        error()

def match(token):
    global lookahead, index
    if lookahead == token:
        if index < len(input_str):
            index += 1
            lookahead = input_str[index]
        else:
            lookahead = None
    else:
        error()

def error():
    print("Syntax error!")

# 测试代码
input_str = "i*i+i"
lookahead = input_str[index]
parse_expression()

在测试代码中，将输入符号串设置为 "i*i+i"，然后调用 `parse_expression` 进行语法分析。运行结果为：

i
*
i
+
i

这表明，输入符号串 "i*i+i" 被成功地分析成为了一个表达式，其中包含了三个运算符：乘号、加号和乘号。