Lexer, parser, analyse, interpréteur, VM, diagnostics : tout se rejoint dans HashScript.
⏱️ Durée : environ 110 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Créateur·rice de langage
🎬 L'histoire
Dernier chapitre du module. Les formateurs de HashBox veulent utiliser HashScript pour écrire leurs exercices auto-corrigés. Maya demande une démonstration complète : un programme, ses erreurs éventuelles, son exécution.
« Tu as chaque brique, dit Sam. Il faut maintenant les assembler, tester l'ensemble comme un produit, et prouver qu'on peut le faire évoluer sans tout casser. »
Tu assembles et fais évoluer HashScript, puis tu présentes l'ensemble comme une vraie chaîne de compilation.
🎯 Ta mission
À la fin, je serai capable de :
- assembler lexer, parser, analyse sémantique, exécution et diagnostics en un pipeline
- tester un langage avec une batterie de programmes de référence (tests de bout en bout)
- écrire des programmes HashScript non triviaux
- ajouter une fonctionnalité de langage de façon propre (grammaire, lexer, parser, sémantique, exécution, tests)
- documenter un langage (grammaire, exemples, limites)
🧩 Défi d'échauffement (5 XP)
Tu veux ajouter l'opérateur reste de la division % à un langage existant. Fais la liste de tous les endroits où tu dois toucher (écriture du texte, découpage en mots, structure des phrases, vérification du sens, exécution). Dans quel ordre travaillerais-tu, et quels tests écrirais-tu avant de commencer ?
💡 Le concept
Le pipeline complet
flowchart LR
S["source .hs"] --> L["Lexer<br/>tokenize"]
L --> P["Parseur<br/>→ AST"]
P --> A["Analyseur<br/>erreurs + avertissements"]
A --> E["Interpréteur<br/>ou VM"]
E --> O["Sortie"]
L -.erreur.-> D["Diagnostics"]
P -.erreur.-> D
A -.erreur.-> D
E -.erreur.-> D
Description du schéma : le code source passe par le lexer, le parseur, l'analyseur puis l'interpréteur (ou la VM) pour produire la sortie. À chaque étape, une erreur est envoyée au module de diagnostics.
La version de référence de HashScript se trouve dans 01-Course/code/hashscript.py, avec ses tests dans test_hashscript.py. Elle rassemble le travail des missions 2 à 9.
Les composants de la référence
| Composant | Rôle |
|---|---|
tokenize(source) | texte → jetons positionnés |
Parseur / parser(source) | jetons → AST |
Analyseur / analyser(programme) | erreurs et avertissements sémantiques |
Interprete | exécution de l'AST (variables, fonctions, fermetures) |
executer_complet(source) | pipeline complet → (sortie, erreurs, avertissements) |
ErreurLangage | erreur positionnée, avec afficher(source) |
La grammaire de HashScript
programme → instruction*
instruction → "let" ID "=" expression ";"
| "print" expression ";"
| ID "=" expression ";"
| "if" expression bloc ("else" bloc)?
| "while" expression bloc
| "fun" ID "(" paramètres? ")" bloc
| "return" expression ";"
| expression ";"
bloc → "{" instruction* "}"
expression → comparaison
comparaison → somme (("==" | "!=" | "<" | ">" | "<=" | ">=") somme)*
somme → produit (("+" | "-") produit)*
produit → unaire (("*" | "/") unaire)*
unaire → "-" unaire | appel
appel → primaire ("(" arguments? ")")*
primaire → NOMBRE | ID | "true" | "false" | "(" expression ")"
Faire évoluer un langage : la méthode
Pour ajouter une fonctionnalité, on suit toujours la même checklist :
- Spécifier : écrire la grammaire et la sémantique, avec des exemples et des cas d'erreur.
- Écrire les tests d'abord (bout en bout).
- Lexer : de nouveaux jetons ?
- Parseur : quelle(s) règle(s) ? Quelle priorité ?
- AST : de nouveaux nœuds ?
- Analyse sémantique : quelles vérifications (types, portées) ?
- Exécution (interpréteur, et VM si elle existe).
- Diagnostics : messages et positions.
- Documentation et mise à jour de la grammaire.
Étendre sans modifier (pour l'exercice)
Pour garder la référence intacte, on peut étendre par héritage et par substitution contrôlée de motifs. En pratique, on modifie directement les fichiers et on garde les tests au vert.
Tester un langage
| Type de test | Exemple |
|---|---|
| Unitaire | lexer sur une chaîne, parseur sur une expression |
| De bout en bout | programme source → sortie attendue |
| Erreurs | source invalide → message, ligne et colonne |
| Propriétés | l'optimiseur ne change pas la sortie ; interpréteur = VM |
| Régression | chaque bug corrigé devient un test |
🧠 Astuce : un langage vit par ses tests. Plus ils sont complets, plus on ose le faire évoluer.
🔍 Exemple pas à pas
Problème : exécuter une batterie de programmes de bout en bout, produire un rapport, et vérifier que l'interpréteur et la VM sont d'accord.
from hashscript import executer_complet, parser, executer
PROGRAMMES = {
"factorielle": ("fun f(n) { if n <= 1 { return 1; } return n * f(n - 1); } print f(10);", ["3628800"]),
"fibonacci récursif": ("fun fib(n) { if n < 2 { return n; } return fib(n - 1) + fib(n - 2); } print fib(15);", ["610"]),
"compteur (fermeture)": ("fun mk() { let c = 0; fun inc() { c = c + 1; return c; } return inc; } let a = mk(); a(); a(); print a();", ["3"]),
"somme 1..100": ("let i = 1; let s = 0; while i <= 100 { s = s + i; i = i + 1; } print s;", ["5050"]),
"pgcd (soustractions)": ("fun pgcd(a, b) { while a != b { if a > b { a = a - b; } else { b = b - a; } } return a; } print pgcd(48, 18);", ["6"]),
"puissance récursive": ("fun p(x, n) { if n == 0 { return 1; } return x * p(x, n - 1); } print p(2, 20);", ["1048576"]),
"composition": ("fun add(n) { fun f(x) { return x + n; } return f; } fun twice(f) { fun g(x) { return f(f(x)); } return g; } print twice(add(3))(10);", ["16"]),
"portée de bloc": ("let x = 1; if true { let x = 2; print x; } print x;", ["2", "1"]),
}
ok = 0
for nom, (source, attendu) in PROGRAMMES.items():
sortie, erreurs, avertissements = executer_complet(source)
statut = "OK " if sortie == attendu and not erreurs else "ÉCHEC"
ok += statut.strip() ==
()
()
ERREURS = {
: ,
: ,
: ,
: ,
}
nom, source ERREURS.items():
_, erreurs, _ = executer_complet(source)
ligne, colonne, message = erreurs[]
()
Lecture : huit programmes de référence s'exécutent correctement (récursion, fermetures, boucles, composition de fonctions), et les quatre cas d'erreur produisent un message positionné. Cette batterie est le filet de sécurité qui permet de modifier le langage.
Faire passer HashScript en ligne de commande : le fichier de référence contient un point d'entrée :
python hashscript.py mon_programme.hs
Les avertissements et erreurs vont sur stderr, la sortie sur stdout, et le code de sortie du processus vaut 1 en cas d'erreur (voir HEF-050).
✍️ À toi, avec aide (10 XP)
Écris trois programmes HashScript de ton choix qui utilisent chacun une fonctionnalité différente (fonction récursive, fermeture, boucle avec condition). Pour chacun :
- donne le programme et la sortie attendue ;
- exécute-le avec
executer_complet; - introduis volontairement une faute (variable mal orthographiée, oubli de
;, mauvais nombre d'arguments) et note le message obtenu.
💡 Indice 1
Idées : puissance récursive, accumulateur par fermeture, nombre de doublements nécessaires pour dépasser 1000.
💡 Indice 2
Un compteur ou un accumulateur par fermeture est un bon exemple de fonctionnalité à tester.
💡 Indice 3
Pour la faute volontaire, change juste un caractère (un nom, un point-virgule, un argument).
✅ Réponse
from hashscript import executer_complet
programmes = [
("fun puissance(x, n) { if n == 0 { return 1; } return x * puissance(x, n - 1); } print puissance(3, 4);", ["81"]),
("fun accumulateur() { let total = 0; fun ajoute(n) { total = total + n; return total; } return ajoute; } let a = accumulateur(); a(5); a(7); print a(0);", ["12"]),
("let n = 1; let pas = 0; while n < 1000 { n = n * 2; pas = pas + 1; } print pas;", ["10"]),
]
for source, attendu in programmes:
sortie, erreurs, _ = executer_complet(source)
assert sortie == attendu and not erreurs, (source, sortie, erreurs)
fautes = [
"fun puissance(x, n) { if n == 0 { return 1; } return x * puissanse(x, n - 1); } print puissance(3, 4);",
"let n = 1 let pas = 0; print pas;",
"fun accumulateur() { let total = 0; fun ajoute(n) { total = total + n; return total; } return ajoute; } let a = accumulateur(); print a(1, 2);",
]
for source in fautes:
_, erreurs, _ = executer_complet(source)
print(erreurs[0])
Les trois fautes produisent respectivement : « fonction inconnue 'puissanse' », « attendu ';' », « ajoute attend 1 argument(s), reçu 2 ».
🚀 À toi, en solo (20 XP)
Ajouter l'opérateur reste %. Suis la checklist pour ajouter a % b (reste de la division) à HashScript, avec la priorité de * et /, sans modifier le fichier de référence (on étend par héritage et substitution contrôlée du motif du lexer) :
- tests d'abord :
print 17 % 5;→2,print 2 + 7 % 4 * 2;→8,print 5 % 0;→ erreur positionnée « modulo par zéro » ; - lexer : étendre le motif
OP; - parseur : sous-classe de
Parseurdontproduitaccepte%; - analyseur :
%demande deux nombres ; - interpréteur : sous-classe de
Interpretequi évalue%; - un pipeline
executer_etendu(source)qui assemble tout.
✅ Pistes de correction
import re
import hashscript
from hashscript import Parseur, Interprete, Analyseur, Bin, ErreurLangage, tokenize
# 2. Lexer : on étend le motif OP et on recompile
hashscript.SPEC[3] = ("OP", r"==|!=|<=|>=|[-+*/%()<>=;{},]")
hashscript.MOTIF = re.compile("|".join(f"(?P<{n}>{p})" for n, p in hashscript.SPEC))
# 3. Parseur : même priorité que * et /
class ParseurModulo(Parseur):
def produit(self):
g = self.unaire()
while self.courant()[0] == "OP" and self.courant()[1] in ("*", "/", "%"):
_, op, l, c = self.avancer()
g = Bin(op, g, self.unaire(), l, c)
return g
# 4. Analyse : % est arithmétique
class AnalyseurModulo(Analyseur):
def type_de():
(n, Bin) n.op == :
g, d = .type_de(n.gauche), .type_de(n.droite)
(g, d) (g, d) != (, ):
.erreur(n, )
().type_de(n)
():
():
(n, Bin) n.op == :
a, b = .(n.gauche, env), .(n.droite, env)
b == :
ErreurLangage(, n.ligne, n.col)
a % b
().(n, env)
():
:
programme = ParseurModulo(tokenize(source)).programme()
ErreurLangage e:
[], [(e.ligne, e.colonne, e.message)], []
erreurs, avertissements = AnalyseurModulo().analyser(programme)
erreurs:
[], erreurs, avertissements
:
InterpreteModulo().executer(programme), [], avertissements
ErreurLangage e:
[], [(e.ligne, e.colonne, e.message)], avertissements
executer_etendu()[] == []
executer_etendu()[] == []
executer_etendu()[] == []
_, erreurs, _ = executer_etendu()
erreurs erreurs[][]
_, erreurs, _ = executer_etendu()
erreurs erreurs[][]
()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Ajouter une fonctionnalité sans tests | On casse l'existant sans le voir | Tests de bout en bout d'abord |
| Oublier une phase | La fonction passe le parseur mais plante à l'exécution | Suivre la checklist : lexer, parseur, AST, sémantique, exécution, diagnostics |
| Changer la grammaire sans la documenter | Les utilisateurs découvrent le comportement par accident | Mettre la grammaire à jour avec le code |
| Un seul mode d'exécution testé | Interpréteur et VM divergent | Test de propriété : mêmes sorties |
🐉 Mini-boss (60 XP)
Projet final du module HEF-090 : étendre HashScript. Choisis deux extensions et implémente-les proprement à travers tout le pipeline, avec grammaire mise à jour, tests de bout en bout (au moins 8 par extension), messages d'erreur soignés et une note de conception :
- Booléens logiques :
et,ou,non(court-circuit pouret/ou) ; - Chaînes de caractères : littéraux
"…", concaténation avec+, longueur, comparaison ; - Boucle
pour:pour i de 1 a 10 { … }; - Listes : littéraux
[1, 2, 3], indexationl[0], fonction nativelongueur, ajout ; - Commentaires de bloc et constantes (
const).
Livrables :
- le code modifié (lexer, parseur, analyseur, interpréteur) avec tous les tests au vert ;
- la grammaire EBNF mise à jour ;
- un ADR pour chaque extension (alternatives envisagées, conséquences) ;
- si tu as fait la VM de la mission 8, son extension aussi (ou une justification de ne pas la faire) ;
- un petit programme de démonstration qui utilise tes deux extensions ;
- une présentation de 10 lignes : ce que tu as appris sur la conception d'un langage.
✅ Pistes de correction
Pistes. Booléens logiques : mots-clés et, ou, non dans MOTS_CLES ; deux niveaux de grammaire entre expression et comparaison (ou → et ("ou" et)*, et → non ("et" non)*, non → "non" non | comparaison) ; évaluation avec court-circuit (ne pas évaluer la droite si la gauche suffit) ; l'analyseur exige des booléens. Chaînes : motif CHAINE dans le lexer, nœud Chaine(valeur), + surchargé (nombre+nombre ou chaîne+chaîne, erreur sinon), formater sans guillemets. Pour : sucre syntaxique : le parseur peut produire un bloc Let + TantQue équivalent (désucrage), sans toucher à l'interpréteur. Listes : nœuds Liste et Indice, vérification des bornes avec message positionné, affectation indexée optionnelle. Un bon dossier montre le désucrage comme technique d'ajout peu coûteux, des tests de non-régression sur les 8 programmes de référence, et un ADR qui compare au moins deux alternatives (par exemple court-circuit ou évaluation stricte).
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Pour ajouter un opérateur à un langage, il faut modifier :
- A. lexer, parseur, analyse, exécution et tests
- B. seulement le lexer
- C. seulement l'interpréteur
2. Un test de bout en bout d'un langage vérifie :
- A. uniquement le lexer
- B. qu'un programme source donne la sortie attendue
- C. la vitesse du processeur
3. Le désucrage consiste à :
- A. supprimer les commentaires
- B. compresser le programme
- C. traduire une syntaxe pratique en constructions plus simples du langage
4. 🔁 Révision mission 09 : Un bon message d'erreur indique :
- A. où, quoi, pourquoi et comment corriger
- B. seulement « erreur »
- C. un code interne
5. 🔁 Révision mission 09 : La récupération d'erreur du parseur consiste à :
- A. s'arrêter à la première erreur
- B. avancer jusqu'à un point de synchronisation puis reprendre
- C. ignorer toutes les erreurs
✅ Réponses
- A.
- B.
- C.
- A.
- B.
🪞 Je réfléchis (10 XP)
- Quel élément de la chaîne de compilation t'a le plus surpris·e en profondeur, et lequel te semble le plus utile dans ton travail quotidien ?
- Quel petit langage (règles, requêtes, configuration) pourrais-tu concevoir pour un outil que tu utilises ?
🎒 À retenir
- Pipeline : lexer → parseur → analyse → exécution, avec diagnostics à chaque étape.
- Ajouter une fonctionnalité : spécifier, tester, lexer, parseur, AST, sémantique, exécution, diagnostics, doc.
- Tests de bout en bout, d'erreurs, de propriétés, de régression.
- Le désucrage ajoute de la syntaxe sans toucher à l'exécution.
- Un langage vit par ses tests et sa documentation.
🏅 Récompenses
Total possible : 120 XP · 🏅 Badge Créateur·rice de langage
← Mission 09 — Erreurs et diagnostics
🎉 Félicitations
Tu as terminé HEF-090 — Compilateurs et langages. Tu sais décrire un langage par une grammaire, écrire un lexer et un parseur par descente récursive, manipuler un AST, vérifier la sémantique, exécuter un programme par interpréteur ou par machine virtuelle, soigner les diagnostics, et faire évoluer un langage proprement.
→ Prochain module : HEF-100 — Sécurité
HEF-090 — Compilateurs et langages

