Avant de comprendre une phrase, il faut la découper en mots. Le lexer transforme un texte brut en une suite de jetons.
⏱️ Durée : environ 75 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Découpeur de mots
🎬 L'histoire
Kodi commence HashScript. Première étape : lire le texte let prix = 12.5 * quantite; # total. Il essaie de couper sur les espaces avec split(). Ça marche… jusqu'à prix=12.5*quantite; sans espaces.
« Un lexer ne coupe pas sur les espaces, dit Sam. Il reconnaît des motifs : un nombre, un identifiant, un opérateur. Et il note la ligne et la colonne de chacun, pour les messages d'erreur. »
Tu écris le premier maillon de la chaîne : le lexer de HashScript.
🎯 Ta mission
À la fin, je serai capable de :
- définir un jeton (genre, texte, position)
- écrire un lexer avec des expressions régulières
- gérer mots-clés, identifiants, nombres, opérateurs, commentaires
- suivre la ligne et la colonne pour les erreurs
- signaler un caractère inattendu avec sa position
🧩 Défi d'échauffement (5 XP)
Découpe en « mots » cette suite de caractères, comme le ferait un programme : x=3.14*r2; # aire. Quels sont les morceaux ? Combien de sortes de morceaux différents peux-tu distinguer (nombres, noms, symboles…) ? Que fais-tu de l'espace et du commentaire ?
💡 Le concept
Le jeton (token)
Un jeton est une unité lexicale : un genre (catégorie), un texte (le lexème) et une position.
| Texte | Genre | Position |
|---|---|---|
let | MOT (mot-clé) | ligne 1, colonne 1 |
prix | ID (identifiant) | 1, 5 |
= | OP | 1, 10 |
12.5 | NUM | 1, 12 |
Le lexer ignore ce qui n'a pas de sens pour la suite (espaces, commentaires).
Les motifs avec des expressions régulières
| Genre | Motif | Explication |
|---|---|---|
NUM | \d+(?:\.\d+)? | des chiffres, éventuellement un point et des chiffres |
ID | [A-Za-z_]\w* | une lettre ou _, puis lettres, chiffres, _ |
OP | `== | != |
COM | #[^\n]* | commentaire jusqu'à la fin de ligne |
ESPACE | [ \t\r]+ | à ignorer |
Deux règles essentielles
- Plus long préfixe d'abord :
<=doit être reconnu avant<;==avant=. L'ordre des alternatives compte. - Mot-clé ou identifiant ? On reconnaît d'abord un identifiant, puis on regarde s'il est dans la liste des mots-clés.
Positions
On suit le numéro de ligne et le début de la ligne courante. La colonne d'un jeton = début du jeton − début de la ligne + 1.
Un lexer en Python
import re
MOTS_CLES = {"let", "print", "if", "else", "while", "fun", "return", "true", "false"}
SPEC = [("NUM", r"\d+(?:\.\d+)?"), ("ID", r"[A-Za-z_]\w*"), ("COM", r"#[^\n]*"),
("OP", r"==|!=|<=|>=|[-+*/()<>=;{},]"), ("ESPACE", r"[ \t\r]+"), ("NL", r"\n"), ("ERR", r".")]
MOTIF = re.compile("|".join(f"(?P<{nom}>{motif})" for nom, motif in SPEC))
def tokenize(source):
ligne, debut_ligne, jetons = 1, 0, []
for m in MOTIF.finditer(source):
genre, texte, colonne = m.lastgroup, m.group(), m.start() - debut_ligne + 1
if genre == "NL":
ligne, debut_ligne = ligne + 1, m.end()
elif genre in ("ESPACE", "COM"):
continue
elif genre == "ERR":
SyntaxError()
:
genre == texte MOTS_CLES:
genre =
jetons.append((genre, texte, ligne, colonne))
jetons.append((, , ligne, (source) - debut_ligne + ))
jetons
m.lastgroup donne le nom du motif qui a correspondu ; le motif ERR (.) à la fin récupère tout caractère non reconnu.
Le jeton de fin
On ajoute un jeton spécial FIN : le parser peut ainsi toujours « regarder le jeton suivant » sans test spécial de fin de liste.
🧠 Astuce : un lexer est une machine à états (automate fini). Les regex en sont une écriture compacte, mais l'idée est la même : lire caractère par caractère et décider de la catégorie.
🔍 Exemple pas à pas
Problème : tokeniser un programme HashScript et afficher le résultat.
import re
MOTS_CLES = {"let", "print", "if", "else", "while", "fun", "return", "true", "false"}
SPEC = [("NUM", r"\d+(?:\.\d+)?"), ("ID", r"[A-Za-z_]\w*"), ("COM", r"#[^\n]*"),
("OP", r"==|!=|<=|>=|[-+*/()<>=;{},]"), ("ESPACE", r"[ \t\r]+"), ("NL", r"\n"), ("ERR", r".")]
MOTIF = re.compile("|".join(f"(?P<{nom}>{motif})" for nom, motif in SPEC))
def tokenize(source):
ligne, debut_ligne, jetons = 1, 0, []
for m in MOTIF.finditer(source):
genre, texte, colonne = m.lastgroup, m.group(), m.start() - debut_ligne + 1
if genre == "NL":
ligne, debut_ligne = ligne + 1, m.end()
elif genre in ("ESPACE", "COM"):
continue
elif genre == "ERR":
SyntaxError()
:
genre == texte MOTS_CLES:
genre =
jetons.append((genre, texte, ligne, colonne))
jetons.append((, , ligne, (source) - debut_ligne + ))
jetons
source =
jeton tokenize(source):
(jeton)
Résultat (extrait) :
('MOT', 'let', 1, 1)
('ID', 'prix', 1, 5)
('OP', '=', 1, 9)
('NUM', '12.5', 1, 10)
('OP', '*', 1, 14)
('ID', 'qte', 1, 15)
...
('MOT', 'print', 2, 1)
('ID', 'prix', 2, 7)
('OP', '>=', 2, 11)
Lecture :
prix=12.5*qte;est correctement découpé sans espaces ;- le commentaire est ignoré ;
>=est un seul jeton (plus long préfixe) ;- les positions sont exactes (le
printest ligne 2, colonne 1) ; 12.5est un nombre à virgule : le motifNUMessaie de prolonger avec.chiffres.
Une erreur lexicale :
try:
tokenize("let a = 5 $ 3;")
except SyntaxError as e:
print(e) # caractère inattendu '$' ligne 1, colonne 11
✍️ À toi, avec aide (10 XP)
Étends le lexer pour reconnaître les chaînes de caractères entre guillemets doubles ("bonjour"), genre CHAINE, sans séquences d'échappement. Teste avec : print "salut " ; et un cas d'erreur : une chaîne non terminée print "abc; (doit lever une erreur à la bonne position).
💡 Indice 1
Ajoute ("CHAINE", r'"[^"\n]*"') avant ERR dans SPEC.
💡 Indice 2
Pour la chaîne non terminée, ajoute un motif CHAINE_OUVERTE : "[^"\n]* (sans guillemet fermant) placé après CHAINE.
💡 Indice 3
Le texte du jeton doit contenir les guillemets ; tu peux les retirer si tu veux la valeur.
✅ Réponse
import re
MOTS_CLES = {"let", "print", "if", "else", "while", "fun", "return", "true", "false"}
SPEC = [("NUM", r"\d+(?:\.\d+)?"), ("ID", r"[A-Za-z_]\w*"), ("COM", r"#[^\n]*"),
("CHAINE", r'"[^"\n]*"'), ("CHAINE_OUVERTE", r'"[^"\n]*'),
("OP", r"==|!=|<=|>=|[-+*/()<>=;{},]"), ("ESPACE", r"[ \t\r]+"), ("NL", r"\n"), ("ERR", r".")]
MOTIF = re.compile("|".join(f"(?P<{nom}>{motif})" for nom, motif in SPEC))
def tokenize(source):
ligne, debut_ligne, jetons = 1, 0, []
for m in MOTIF.finditer(source):
genre, texte, colonne = m.lastgroup, m.group(), m.start() - debut_ligne + 1
if genre == "NL":
ligne, debut_ligne = ligne + 1, m.end()
genre (, ):
genre == :
SyntaxError()
genre == :
SyntaxError()
:
genre == texte MOTS_CLES:
genre =
jetons.append((genre, texte, ligne, colonne))
jetons.append((, , ligne, (source) - debut_ligne + ))
jetons
([j[:] j tokenize()])
:
tokenize()
SyntaxError e:
(e)
🚀 À toi, en solo (20 XP)
Un autre langage. Écris un lexer pour un mini-SQL :
SELECT nom, age FROM membres WHERE age >= 18 AND ville = 'Lyon';
- mots-clés insensibles à la casse (
select,Select,SELECT) :SELECT FROM WHERE AND OR, avec leur texte normalisé en majuscules ; - identifiants, nombres, chaînes entre apostrophes
'Lyon', opérateurs= != < > <= >= , ; ( ) *; - positions ligne/colonne ;
- erreurs : caractère inconnu, chaîne non terminée.
Teste sur au moins 6 requêtes dont 2 invalides.
✅ Pistes de correction
import re
MOTS = {"SELECT", "FROM", "WHERE", "AND", "OR"}
SPEC = [("NUM", r"\d+(?:\.\d+)?"), ("ID", r"[A-Za-z_]\w*"), ("CHAINE", r"'[^'\n]*'"), ("CHAINE_OUVERTE", r"'[^'\n]*"),
("OP", r"!=|<=|>=|[=<>,;()*]"), ("ESPACE", r"[ \t\r]+"), ("NL", r"\n"), ("ERR", r".")]
MOTIF = re.compile("|".join(f"(?P<{n}>{p})" for n, p in SPEC))
def tokenize_sql(source):
ligne, debut, jetons = 1, 0, []
for m in MOTIF.finditer(source):
genre, texte, col = m.lastgroup, m.group(), m.start() - debut + 1
if genre == "NL":
ligne, debut = ligne + 1, m.end()
elif genre == "ESPACE":
continue
elif genre == "CHAINE_OUVERTE":
SyntaxError()
genre == :
SyntaxError()
:
genre == texte.upper() MOTS:
genre, texte = , texte.upper()
jetons.append((genre, texte, ligne, col))
jetons
jetons = tokenize_sql()
[j[] j jetons][:] == [, , ]
jetons[][:] == (, ) jetons[][] ==
sql (, ):
tokenize_sql(sql)
mauvais (, ):
:
tokenize_sql(mauvais)
AssertionError()
SyntaxError e:
(e)
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Couper sur les espaces | x=3 n'est pas découpé | Reconnaître des motifs, pas des séparateurs |
| Mauvais ordre des motifs | = avant == coupe un opérateur en deux | Plus longs préfixes d'abord |
| Oublier les positions | Messages d'erreur inutiles | Suivre ligne et colonne dans le lexer |
| Ne pas gérer les caractères inconnus | Le lexer ignore silencieusement une erreur | Motif de repli ERR qui lève une erreur |
🐉 Mini-boss (40 XP)
Lexer robuste de HashScript. Écris un lexer complet qui reconnaît :
- nombres entiers et à virgule, identifiants, mots-clés, opérateurs (
==,!=,<=,>=,+,-,*,/,**pour la puissance, parenthèses, accolades, virgule, point-virgule) ; - chaînes entre guillemets avec échappements
\n,\"et\\(la valeur du jeton doit contenir la chaîne décodée) ; - commentaires
#…et commentaires de bloc/* … */(qui peuvent s'étendre sur plusieurs lignes) ; - suivi exact de ligne/colonne, y compris après un commentaire de bloc ;
- erreurs : caractère inconnu, chaîne ou commentaire de bloc non terminés (avec la position du début).
Écris au moins 20 tests, dont un test aléatoire : génère des programmes à partir de jetons, remets-les en texte avec des espaces aléatoires, et vérifie que le lexer retrouve les mêmes jetons.
✅ Pistes de correction
Un bon travail : les motifs CHAINE avec "(?:[^"\\\n]|\\.)*" pour gérer les échappements puis un décodage par bytes(...).decode("unicode_escape") ou une table de remplacement; le commentaire de bloc /\*.*?\*/ avec le drapeau re.S; le calcul de ligne/colonne qui compte les \n à l'intérieur d'un jeton multi-lignes (texte.count("\n") et texte.rfind("\n") pour mettre à jour debut_ligne); les erreurs de chaîne/commentaire non terminés utilisent des motifs « ouverts » placés après les motifs fermés; le test aléatoire compare [(genre, texte)] avant et après insertion d'espaces et de commentaires entre les jetons. L'opérateur ** est placé avant * dans la liste des motifs.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un jeton est :
- A. une instruction du processeur
- B. un type de variable
- C. une unité lexicale avec un genre, un texte et une position
2. Pourquoi reconnaître <= avant < ?
- A. pour ne pas couper l'opérateur en deux
- B. pour aller plus vite
- C. par convention esthétique
3. Le rôle d'un lexer est de :
- A. vérifier les types
- B. transformer le texte en suite de jetons
- C. exécuter le programme
4. 🔁 Révision mission 01 : Une grammaire est ambiguë si :
- A. elle est trop longue
- B. elle utilise des regex
- C. une phrase a plusieurs arbres syntaxiques
5. 🔁 Révision mission 01 : Une expression régulière suffit pour :
- A. reconnaître des mots (nombres, identifiants)
- B. reconnaître des parenthèses équilibrées
- C. exécuter un programme
✅ Réponses
- C.
- A.
- B.
- C.
- A.
🪞 Je réfléchis (10 XP)
- Dans quelle situation de ta vie « découpes-tu » un texte en morceaux significatifs avant de le comprendre ?
- Pourquoi mettre les positions dans les jetons dès le début est-il un investissement rentable ?
🎒 À retenir
- Jeton = genre + texte + position.
- Motifs en regex, plus longs d'abord.
- Mots-clés vs identifiants : on teste après avoir reconnu un identifiant.
- Ligne et colonne suivies par le lexer.
- Un motif de repli lève une erreur sur tout caractère inconnu.
flowchart LR
T(["Les jetons et l'analyse lexicale"])
T --> R1["1. Jeton = genre + texte + position."]
T --> R2["2. Motifs en regex, plus longs d'abord."]
T --> R3["3. Mots-clés vs identifiants : on teste après avoir reconnu un…"]
T --> R4["4. Ligne et colonne suivies par le lexer."]
T --> R5["5. Un motif de repli lève une erreur sur tout caractère inconnu."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Découpeur de mots
← Mission 01 — Langages et grammaires · Mission 03 — Le parsing par descente récursive →
HEF-090 — Compilateurs et langages

