Rekursiver Abstiegsparser mit Backtracking für die Grammatik

Kann mich jemand aufklären, warum ein rekursiver Abstiegsparser mit Backtracking, der die Produktionen und S → a a (in dieser Reihenfolge) versucht, die durch die Grammatik S → a S a | gebildete Sprache nicht erkennt a a .$S \rightarrow aSa$$S \rightarrow aa$$S \rightarrow aSa\ |\ aa$

Es scheint nur Wörter aus der Sprache zu analysieren n ≥ 1 } .$\{a^{2^n}\ |\ n \ge 1 \}$

Ich habe einen solchen Parser mit diesem ABNF-Parser-Generator mit der Produktionsregel generiert, S = "a" S "a" / "aa"und der Parser erkennt das Wort aaaaaabeispielsweise nicht.

Ich würde erwarten, dass die Produktion bis die Verkettung der Endknoten des Analysebaums von links mit 7 beginnt , und dann den Analysebaum hinaufgehen und stattdessen die Produktion S → a a auswählen, bis der Baum aussieht so was:$S \rightarrow aSa$a$S \rightarrow aa$

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

Dies ist keine gute Antwort, aber die Analysebäume passen nicht zu den normalen Kommentaren.

$S \rightarrow aSa\ |\ aa$$aaaaaa$

Der Analysebaum hat jedoch die folgende Form:

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

oder wenn Sie diese Präsentation bevorzugen, mit den Terminals in verschiedenen Zeilen

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

Ich habe überprüft, ob der ABNF-Parser-Generator nicht zu funktionieren scheint, aber ich weiß nicht, wie ich verfolgen soll, was er tut.

$\{a^{2^n}\ |\ n \ge 1 \}$

Es ist ein bisschen überraschend, eine so aufwändige Site um einen Buggy-Parser herum zu haben, der außerdem eine völlig uninteressante Parsing-Technik verwendet.

Nach einem weiteren Blick darauf:

Ich glaube, ich habe eine Ursache für das Problem gefunden. Die eckigen Klammern bedeuten optional .

Ihre Grammatik sollte also entweder S = "a" S "a" / "aa" oder geschrieben sein S = "a" [S] "a". Dann scheint es richtig zu funktionieren.

Aber das System geht anscheinend verloren, wenn es zweimal dieselbe Regel in verschiedenen Formen gibt. Ich bin mir nicht sicher warum.

Ich habe keine Seite gefunden, auf der diese syntaktischen Probleme zur Angabe der Grammatik erläutert werden.

Ich betrachte diesen Buggy immer noch.

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

Erwägen Sie, das Wort aaaaaaerneut zu analysieren . An einem Punkt sieht der Analysebaum folgendermaßen aus:

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

s()trueS$S \rightarrow aa$

   S 
 / | \
a  S  a
  / \
 a   a

Ich neige dazu, dies als Problem bei meiner Implementierung zu betrachten und nicht als Rückverfolgung von Parsern rekursiver Abstammung im Allgemeinen.

#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";
}

Es ist eine Funktion, kein Fehler

Sehen Sie sich genau an, wann und wo Backtracking stattfindet:

     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

Der entscheidende Punkt hierbei ist, dass der Parser nach der Position zurückverfolgt, an der das letzte übereinstimmende Zeichen gefunden wurde. Deshalb "springt" es von Baum 11 mit l = aaaaaaaa zum 12. Baum mit l = aaaa, indem es S -> aa bei l [7] verwendet.