Analizador de descenso recursivo con retroceso para la gramática

¿Puede alguien aclararme por qué un analizador de descenso recursivo con retroceso que prueba las producciones y (en ese orden) no reconoce el lenguaje formado por la gramática .$S \rightarrow aSa$$S \rightarrow aa$$S \rightarrow aSa\ |\ aa$

Parece que solo analiza palabras del idioma .$\{a^{2^n}\ |\ n \ge 1 \}$

Generé dicho analizador utilizando este generador de analizador ABNF con la regla de producción S = "a" S "a" / "aa"y el analizador no reconoce la palabra aaaaaa, por ejemplo.

Esperaría que use la producción hasta que la concatenación de los nodos terminales del árbol de análisis desde la izquierda comience con 7 's, y luego suba el árbol de análisis eligiendo la producción lugar hasta que el árbol se vea como esta:$S \rightarrow aSa$a$S \rightarrow aa$

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

Esta no es una gran respuesta, pero los árboles de análisis no se ajustan a los comentarios normales.

Su gramática debe analizar la cadena a a a a a a .$S \rightarrow aSa\ |\ aa$$aaaaaa$

Pero el árbol de análisis tiene la siguiente forma:

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

o si prefiere esta presentación, con los terminales en diferentes líneas

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

Verifiqué que el generador de analizador ABNF no parece funcionar, pero no sé cómo rastrear lo que hace.

De hecho, parece reconocer el conjunto que no es lo que define la gramática.$\{a^{2^n}\ |\ n \ge 1 \}$

Es un poco sorprendente tener un sitio tan elaborado alrededor de un analizador de errores, que además utiliza una técnica de análisis totalmente poco interesante.

Después de mirarlo más a fondo:

Creo que encontré una fuente del problema. Los corchetes significan opcional .

Por lo tanto, su gramática debe escribirse S = "a" S "a" / "aa" o S = "a" [S] "a". Entonces parece funcionar correctamente.

Pero el sistema aparentemente se pierde cuando se tiene el doble de la misma regla en diferentes formas. No estoy seguro por qué.

No encontré una página que explicara estos problemas sintácticos para especificar la gramática.

Todavía considero ese buggy.

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

Considere analizar la palabra aaaaaanuevamente. En un momento, el árbol de análisis se verá así:

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

s()trueS$S \rightarrow aa$

   S 
 / | \
a  S  a
  / \
 a   a

Sin embargo, tiendo a considerar esto un problema con mi implementación y no con el retroceso de analizadores de descenso recursivo en general.

#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 una característica, no un error.

Observe de cerca cuándo y dónde ocurre el retroceso:

     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

El punto crucial aquí es que el analizador retrocede después de la posición, donde se encontró el último personaje coincidente. Es por eso que "salta" del árbol 11 con l = aaaaaaaa al árbol 12 con l = aaaa usando S -> aa en l [7].