CKTIS / C#
Architettura di un programma: parser, AST e interprete di una DSL
Separa la sintassi di un piccolo linguaggio specifico di un dominio dalla sua esecuzione. Un parser costruisce un albero sintattico astratto e un interprete AST calcola il risultato a partire dai suoi nodi. Questa separazione consente di testare in modo indipendente l’elaborazione del testo, la rappresentazione del programma e le regole di esecuzione.
Versione: .NET 10; repository net10.0 and LangVersion=preview; feature versions require per-entry verification
Sintassi
DSL text → parser → abstract syntax tree (AST) → AST interpreter → resultL’architettura di un programma definisce le responsabilità dei suoi componenti e il flusso di dati tra loro. Per un piccolo linguaggio specifico di un dominio (DSL) che descrive un insieme ristretto di operazioni, usa una pipeline: testo → parser → abstract syntax tree (AST, albero sintattico astratto) → AST interpreter → risultato. È un modello di progettazione, non una funzionalità speciale di C#.
Il parser controlla la sintassi e costruisce i nodi AST, invece di eseguire il comando mentre lo legge. Un lexer separato può estrarre prima i token; qui è sufficiente dividere il testo in corrispondenza degli spazi. Un AST conserva la struttura delle operazioni, non necessariamente tutto il testo sorgente. Non va confuso con l’albero Roslyn completo, che conserva anche commenti e spazi bianchi.
L’esempio riconosce i comandi della forma add <int> <int>. Parse divide il testo in corrispondenza dei caratteri di spazio, scarta i token vuoti e si aspetta che ne rimangano esattamente tre. Il primo deve essere add in minuscolo; gli altri due devono poter essere convertiti in valori Int32 da Int32.TryParse con NumberStyles.AllowLeadingSign e CultureInfo.InvariantCulture. Il segno iniziale è facoltativo e Int32.TryParse ignora i caratteri NUL (U+0000) alla fine dei token numerici, quindi accetta anche una cifra seguita da un carattere NUL. Parse crea un Add contenente due nodi Number. Evaluate, l’interprete AST, calcola ricorsivamente i valori dei nodi; non genera codice macchina né IL. L’input add 2 3 produce 5.
Separare queste fasi consente di testare parser e interprete in modo indipendente. Parse genera FormatException se i token non sono esattamente tre, se il primo non è add o se non è possibile convertire uno dei due token numerici. Un’addizione al di fuori dell’intervallo Int32 genera OverflowException per effetto di checked. Questo è volutamente un linguaggio minimo, senza espressioni annidate. Per ampliarlo, aggiungi diagnostica con le posizioni nel testo e limiti alla lunghezza dell’input e alla profondità dell’albero; la separazione delle fasi, da sola, non rende sicura l’esecuzione di programmi non attendibili.
Esempi
using System;
using System.Globalization;
Expr ast = Parse("add 2 3");
Console.WriteLine(Evaluate(ast).ToString(CultureInfo.InvariantCulture));
static Expr Parse(string text)
{
string[] tokens = text.Split(' ', StringSplitOptions.RemoveEmptyEntries);
if (tokens.Length != 3 || tokens[0] != "add" ||
!int.TryParse(tokens[1], NumberStyles.AllowLeadingSign,
CultureInfo.InvariantCulture, out int left) ||
!int.TryParse(tokens[2], NumberStyles.AllowLeadingSign,
CultureInfo.InvariantCulture, out int right))
throw new FormatException("Expected: add <int> <int>");
return new Add(new Number(left), new Number(right));
}
static int Evaluate(Expr expr) => expr switch
{
Number n => n.Value,
Add a => checked(Evaluate(a.Left) + Evaluate(a.Right)),
_ => throw new InvalidOperationException("Unknown AST node.")
};
abstract record Expr;
sealed record Number(int Value) : Expr;
sealed record Add(Expr Left, Expr Right) : Expr;Risultato
5
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.