Nome corretto per un parser di discesa ricorsivo che utilizza loop per gestire la ricorsione a sinistra?

Questa grammatica è ricorsiva:

Expression  ::= AdditionExpression

AdditionExpression  ::=
    MultiplicationExpression
        | AdditionExpression '+' MultiplicationExpression
        | AdditionExpression '-' MultiplicationExpression

MultiplicationExpression    ::=
    Term
        | MultiplicationExpression '*' Term
        | MultiplicationExpression '/' Term

Term    ::=
    Number
        | '(' AdditionExpression ')'

Number  ::=
    [+-]?[0-9]+(\.[0-9]+)?

Quindi, in teoria, la discesa ricorsiva non funzionerà. Ma sfruttando le proprietà della grammatica secondo cui ciascuna regola ricorsiva a sinistra corrisponde a un livello di precedenza specifico e che lo sguardo di un singolo token è sufficiente per scegliere la produzione corretta, le regole ricorsive a sinistra possono essere analizzate individualmente con mentre loop.

Ad esempio, per analizzare il terminale non AdditionExpression, questo pseudocodice è sufficiente:

function parse_addition_expression() {
    num = parse_multiplication_expression()
    while (has_token()) {
        get_token()
        if (current_token == PLUS)
            num += parse_multiplication_expression()
        else if (current_token == MINUS)
            num -= parse_multiplication_expression()
        else {
            unget_token()
            return num
        }
    }
    return num
}

Qual è il nome corretto per questo tipo di parser? Questo articolo informativo si riferisce solo ad esso come alla "soluzione classica": https://www.engr.mun.ca/~theo/Misc/exp_parsing.htm

Ci deve essere un nome proprio per questo tipo di parser.

È solo un parser LL (1) implementato con discesa ricorsiva.

Inizia con:

AdditionExpression  ::=
    MultiplicationExpression
        | AdditionExpression '+' MultiplicationExpression
        | AdditionExpression '-' MultiplicationExpression

applica la rimozione della ricorsione a sinistra per ottenere una grammatica LL (1):

AdditionExpression  ::= 
    MultiplicationExpression AdditionExpressionTail

AdditionExpressionTail ::=
        | '+' MultiplicationExpression AdditionExpressionTail
        | '-' MultiplicationExpression AdditionExpressionTail

scrivere le funzioni corrispondenti:

function parse_AdditionExpression() {
    parse_MultiplicationExpression()
    parse_AdditionExpressionTail()
}

function parse_AdditionExpressionTail() {
    if (has_token()) {
        get_token()
        if (current_token == PLUS) {
            parse_MultiplicationExpression()
            parse_AdditionExpressionTail()
        } else if (current_token == MINUS) {
            parse_MultiplicationExpression()
            parse_AdditionExpressionTail()
        } else {
            unget_token()
        }
    }
}

rimuovere la ricorsione della coda:

function parse_AdditionExpressionTail() {
    while (has_token()) {
        get_token()
        if (current_token == PLUS)
            parse_MultiplicationExpression()
        else if (current_token == MINUS)
            parse_MultiplicationExpression()
        else {
            unget_token()
            return
        }
    }
}

in linea:

function parse_AdditionExpression() {
    parse_MultiplicationExpression()
    while (has_token()) {
        get_token()
        if (current_token == PLUS)
            parse_MultiplicationExpression()
        else if (current_token == MINUS)
            parse_MultiplicationExpression()
        else {
            unget_token()
            return
        }
    }
}

e devi solo aggiungere l'elaborazione semantica per ottenere la tua funzione.

Vuoi dare un'occhiata a LL ($k$) analisi . L'articolo di Wikipedia è per lo più inutile, ma è fondamentalmente una discesa ricorsiva$k$ simboli lookahead.

C'è anche LL ($*$) che consente lookahead illimitato.

Vedi qui per una panoramica completa di quanto sia potente questa classe di parser.