具有语法

谁能启发我，为什么尝试回溯产生式和（按顺序）的带有回溯的递归下降解析器不能识别语法形成的语言。小号→ 一个一个小号→ 一个小号一个| 一个$S \rightarrow aSa$$S \rightarrow aa$$S \rightarrow aSa\ |\ aa$

它似乎只能解析语言单词。$\{a^{2^n}\ |\ n \ge 1 \}$

我使用具有生产规则的ABNF Parser Generator生成了这样的解析器，例如，S = "a" S "a" / "aa"解析器无法识别单词aaaaaa。

我希望它使用生产，直到解析树的终端节点从7左边开始串联的，然后去分析树选择生产小号→ 一个一个来代替，直到树看起来像这样：$S \rightarrow aSa$a$S \rightarrow aa$

   S 
 / | \
a  S  a
 / | \
a  S  a
  / \
 a   a

这不是一个很大的答案，但是解析树不适合常规注释。

您的语法应该解析字符串 一个一个一个一个一个一个。$S \rightarrow aSa\ |\ aa$$aaaaaa$

但是解析树具有以下形式：

      S 
     /|\
    / S \
   / /|\ \
  / / S \ \
 / / / \ \ \
a a a   a a a

或者，如果您喜欢此演示文稿，请在不同的端子上使用端子

     S 
   / | \
  a  S  a
   / | \
  a  S  a
    / \
   a   a

我检查了ABNF解析器生成器似乎不起作用，但是我不知道如何跟踪它的功能。

确实确实使集合 至极不是什么语法定义。$\{a^{2^n}\ |\ n \ge 1 \}$

围绕一个错误的解析器拥有如此精致的站点有点令人惊讶，该解析器还使用了一种完全不有趣的解析技术。

进一步查看之后：

我想我找到了问题的根源。方括号表示 可选。

所以你的语法应该写成 S = "a" S "a" / "aa" 或S = "a" [S] "a"。然后，它似乎可以正常工作。

但是当以不同的形式拥有两次相同的规则时，系统显然会丢失。我不知道为什么。

我没有找到说明这些语法问题的页面来指定语法。

我仍然认为那辆马车。

s1()$S \rightarrow aSa$trues()s2()$S \rightarrow aa$

考虑aaaaaa再次解析该单词。一方面，解析树将如下所示：

   S 
 / | \
a  S  a
 / | \
a  S  a    <--
 / | \
a  S  a
  / \
 a   a

s()trueS$S \rightarrow aa$

   S 
 / | \
a  S  a
  / \
 a   a

不过，我倾向于将其视为实现问题，而不是一般回溯递归下降解析器。

#include <iostream>

char* next;    
bool term(char token) {
    if (*next != '\0')
        return *next++ == token;
    else
        return false;
}

bool s();    
bool s1() {
    return term('a') && s() && term('a');
}    
bool s2() {
    return term('a') && term('a');
}    
bool s() {
    auto save = next;
    return s1() or (next = save, s2());
}    

int main(int argc, char* argv[]) {
    next = "aaaaaa";
    if (s() && *next == '\0') {
        std::cout << "match";
    }
    else
        std::cout << "no match";
}

这是功能而不是错误

仔细查看何时及何处发生回溯：

     1.           2.          3.          4.          5.          6.          7.          8.          9.          10.         11.         12.

     S            S           S           S           S           S           S           S           S           S           S           S      
   / | \        / | \       / | \       / | \       / | \       / | \       / | \       / | \       / | \       / | \       / | \       / | \
  a  S  a      a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a  S  a
                / | \       / | \       / | \       / | \       / | \       / | \       / | \       / | \       / | \       / | \       /   \
               a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a     a
                            / | \       / | \       / | \       / | \       / | \       / | \       / | \       / | \       / | \
                           a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a  S  a
                                        / | \       / | \       / | \       / | \       / | \       / | \       / | \       /   \
                                       a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a     a
                                                    / | \       / | \       / | \       / | \       / | \       /   \
                                                   a  S  a     a  S  a     a  S  a     a  S  a     a  S  a     a     a
                                                                / | \       / | \       / | \       /   \   
                                                               a  S  a     a  S  a     a  S  a     a     a
                                                                            / | \       /   \
                                                                           a  S  a     a     a



w[] = 'aaaaaa'  //input
l[] = ''        //current tree leafs


 1. tree:   The parser starts with the start symbol S and tries first alternative S->aSa:       Result: w[0]  = l[0]     w = aaaaaa    l = aSa
 |          -- S->aSa works                                                                         | |     | | 
 6. tree:   The parser matches a after a:                                                       Result: w[6]  = l[6]     w = aaaaaa    l = aaaaaaSaaaaaa
 7. tree:   The parser tries S->aSa again but there is no match!                                Result: w[7] != l[7]     w = aaaaaa    l = aaaaaaaSaaaaaaa 
 8. tree:   The parser tries S->aa but there is still no match!                                 Result: w[7] != l[7]     w = aaaaaa    l = aaaaaaaaaaaaaa
 9. tree:   Backtracking after the last symbol that matched => Backtracking at l[7]             Result: w[7] != l[7]     w = aaaaaa    l = aaaaaaaaaaaa
10. tree:   Backtracking after the last symbol that matched => Backtracking at l[7]             Result: w[7] != l[7]     w = aaaaaa    l = aaaaaaaaaa
11. tree:   Backtracking after the last symbol that matched => Backtracking at l[7]             Result: w[7] != l[7]     w = aaaaaa    l = aaaaaaaa
12. tree:   Backtracking after the last symbol that matched => Backtracking at l[7]             Result: w[7] != l[7]     w = aaaaaa    l = aaaa

这里的关键点是解析器在找到最后一个匹配字符的位置之后回溯。 这就是为什么它通过在l [7]处使用S-> aa从l = aaaaaaaaa的树11“跳” 到l = aaaa的第十二棵树。