CKTIS / C#
Architecture d’un programme : analyseur, AST et interpréteur de DSL
Séparez la syntaxe d’un petit langage spécifique à un domaine de son exécution. Un analyseur construit un arbre syntaxique abstrait, puis un interpréteur d’AST calcule le résultat à partir de ses nœuds. Cette séparation permet de tester indépendamment le traitement du texte, la représentation du programme et les règles d’exécution.
Version : .NET 10; repository net10.0 and LangVersion=preview; feature versions require per-entry verification
Syntaxe
DSL text → parser → abstract syntax tree (AST) → AST interpreter → resultL’architecture d’un programme définit les responsabilités de ses composants et la circulation des données entre eux. Pour un petit langage spécifique à un domaine (DSL) décrivant un ensemble restreint d’opérations, utilisez une chaîne de traitement : texte → parser → abstract syntax tree (AST, arbre syntaxique abstrait) → AST interpreter → résultat. Il s’agit d’un modèle de conception, et non d’une fonctionnalité spéciale de C#.
L’analyseur vérifie la syntaxe et construit des nœuds d’AST au lieu d’exécuter la commande pendant sa lecture. Un lexer distinct peut d’abord extraire les jetons ; ici, une séparation sur les espaces suffit. Un AST conserve la structure des opérations, pas nécessairement l’intégralité du texte source. Ne le confondez pas avec l’arbre Roslyn complet, qui conserve également les commentaires et les espaces blancs.
L’exemple reconnaît les commandes de la forme add <int> <int>. Parse découpe le texte sur les caractères espace, élimine les jetons vides et attend exactement trois jetons restants. Le premier doit être add en minuscules ; les deux autres doivent pouvoir être convertis en valeurs Int32 par Int32.TryParse avec NumberStyles.AllowLeadingSign et CultureInfo.InvariantCulture. Un signe initial est facultatif et Int32.TryParse ignore les caractères NUL (U+0000) en fin de jeton numérique : un chiffre suivi d’un caractère NUL est donc également accepté. Parse construit un Add contenant deux nœuds Number. Evaluate, l’interpréteur d’AST, calcule récursivement les valeurs des nœuds ; il ne génère ni code machine ni IL. L’entrée add 2 3 produit 5.
La séparation de ces étapes permet de tester indépendamment l’analyseur et l’interpréteur. Parse lève FormatException si le nombre de jetons est différent de trois, si le premier jeton n’est pas add ou si l’un des deux jetons numériques ne peut pas être converti. Une addition hors de la plage Int32 provoque OverflowException à cause de checked. Ce langage est volontairement minimal et ne prend pas en charge les expressions imbriquées. Pour le développer, ajoutez des diagnostics indiquant les positions dans le texte, ainsi que des limites de longueur d’entrée et de profondeur de l’arbre ; la séparation des étapes ne suffit pas à sécuriser l’exécution de programmes non fiables.
Exemples
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;Résultat
5
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.