Java 下列语法正确吗？

我尝试使用递归下降分析检查以下语法的语法正确性：

<FACTOR> ::= <EXPR> | i
<TERM> ::= <FACTOR> * <TERM> | <FACTOR>
<EXPR> ::= <TERM> + <EXPR> | <TERM>

---

问题中键入的语法与正常表达式语法不一致，因为它不允许使用括号。这也是模棱两可的。所以我会说“不，下面的语法不正确。”

我建议使用以下语法（注意括号）：

：：=（）| i
::=  *  | 
::=  +  | 

问题中键入的语法与正常表达式语法不一致，因为它不允许使用括号。这也是模棱两可的。所以我会说“不，下面的语法不正确。”

我建议使用以下语法（注意括号）：

：：=（）| i
::=  *  | 
::=  +  | 

开始符号应为“”，而不是“”。你应该检查一下这个

语法模棱两可。例如，“i”可以由 “”=>i
或 “”=>“”=>“”=>“”=>“”=>i

"

开始符号应为“”，而不是“”。您应该对此进行检查

语法是模棱两可的。例如“i”可以由 “”=>i
或 “”=>“”=>“”=>“”=>“”=>i

---

“如果它是递归的，那么递归应该是算法。当它不是一个时，它将停止，在其中它将扩展到i并停止递归。你基本上只需要语法中的一件事，就可以最终以一个非递归调用结束，这样它才能正常工作。我不明白。在我的算法中，当提供expr时，它停止，因为expr将检查它是否是一个术语，它将再次检查它是否是一个因子，它将再次检查它是否是一个表达式等等…RD解析器不是这样工作的。您有一个表示每个语法规则的方法，其中包含确定它是否需要继续到下一个语法规则或停止的逻辑。所以，这就像是“如果我们有‘我’，返回，否则”，你也会有如果没有'*'，则为'*'。在上面的语法中，是停止点，因为它最终计算为“i”。@CodeChimp:那么你是说语法不正确？例如，语法是否适用于

i*i

？我认为第一条规则应该是：

：=（）i

，这更标准。否则，（1）表达式中不能使用括号，（2）语法不明确。如果是递归的，那么递归应该是算法。当它不是一个时，它将停止，在其中它将扩展到i并停止递归。你基本上只需要语法中的一件事，就可以最终以一个非递归调用结束，这样它才能正常工作。我不明白。在我的算法中，当提供expr时，它停止，因为expr将检查它是否是一个术语，它将再次检查它是否是一个因子，它将再次检查它是否是一个表达式等等…RD解析器不是这样工作的。您有一个表示每个语法规则的方法，其中包含确定它是否需要继续到下一个语法规则或停止的逻辑。所以，这就像是“如果我们有‘我’，返回，否则”，你也会有如果没有'*'，则为'*'。在上面的语法中，是停止点，因为它最终计算为“i”。@CodeChimp:那么你是说语法不正确？例如，语法是否适用于

i*i

？我认为第一条规则应该是：

：=（）i

，这更标准。否则，（1）您不能在表达式中使用括号，（2）语法不明确。您提出的语法使用不同的样式，其中（除其他外）不编码运算符的优先级-因此，这对识别器/验证器是有好处的，但对于需要构造AST的解析器来说，这是非常糟糕的。优先级取决于您定义的语言。有些语言只使用关联性，不使用优先级。如果我有要求，我会提出rigth语法。您提出的语法使用不同的样式，其中（除其他外）不编码运算符的优先级-因此，它对识别器/验证器很好，但对于需要构造AST的解析器来说，这是非常糟糕的。优先级取决于您定义的语言。有些语言只使用关联性，不使用优先级。如果我有要求，我会提出正确的语法。

//Variable to store our current character index
static int i = 0;
//Variable to store our input string
static String input;

public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    System.out.print("Enter text to check for correctness: ");
    input = scan.nextLine();
    if(input.charAt(input.length() - 1) != '#'){
        input += scan.nextLine();                    
    }
    //Remove all spaces just to prevent space interference
    input = input.replaceAll(" ", "");
    if(Factor(nextChar()))
    {
        System.out.println("Your text input is correct");
    }
    else
    {
        System.out.println("Your text input does not conform with the grammar");
    }
}

public static boolean Factor(char ourChar){
    //<factor> ::= <expr> | i        
    if(ourChar == '#')
    {
        //If it's # we should bounce back if and return true since no errors yet
        return true;
    }
    if(ourChar == 'i')
    {
        //if it's i then return true
        return true;
    }
    else{
        //so the character is not i, let's check if satisfies the Expr grammar
        if(!Expr(ourChar))
        {
            //oooh, it's not return false!
            return false;
        }
        return true;
    }        
}

public static boolean Expr(char ourChar){
    //<expr> ::= <term> + <expr> | <term>
    //Before you can be an expression, you must start with a term
    if(!Term(ourChar))
        //so it doesn't start with term? Bounce back dear
        return false;
    if(nextChar() != '+'){
        //The next character is not a plus, return false to sender
        return false;
    }
    else
    {
        //So it's plus? Ok, let's check if the next character is another expr
        if(!Expr(nextChar()))
            return false;
        else
            //Everybody satisfied, return true
            return true;
    }
}

public static boolean Term(char ourChar){
    //<term> ::= <factor> * <term> | <factor>
    //If the character does not start with a factor bounce back
    if(!Factor(ourChar))
        return false;
    if(nextChar() != '*'){
        //Yekpa! The factor is not followed by * so bounce back
        return false;
    }
    else{
        //SO, it's a star. Ok, if it's followed by a term, bounce back
        if(!Term(nextChar()))
        {
            return false;
        }
        //Well, all bouncers satisfied, so return true
        return true;
    }
}

public static char nextChar(){
    i++;
    return input.charAt(i - 1);
}    

<FACTOR> ::= ( <EXPR> ) | i
<TERM> ::= <FACTOR> * <TERM> | <FACTOR>
<EXPR> ::= <TERM> + <EXPR> | <TERM>