Découper l’entrée en jetons
Transformez le texte en jetons.
Découper l’entrée en jetons est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C Academy comprend 4 leçons au total.
Qu’est-ce qu’un tokenizer ?
Un interpréteur commence par transformer le texte brut en tokens — les plus petites unités porteuses de sens. Pour la chaîne 3 + 4 * 2, le tokenizer (ou analyseur lexical) produit des nombres et des opérateurs.
Cette étape supprime les espaces et classe chaque groupe de caractères, afin que l’analyseur syntaxique n’ait jamais affaire aux octets bruts.
Un type de Token
Nous représentons chaque Token avec une étiquette d’énumération et une charge utile. Les nombres contiennent une valeur entière ; les opérateurs et les parenthèses ont seulement besoin de leur catégorie.
Conserver la valeur dans la structure évite de parcourir à nouveau la source plus tard.
typedef enum {
TOK_NUM, TOK_PLUS, TOK_MINUS,
TOK_STAR, TOK_SLASH,
TOK_LPAREN, TOK_RPAREN, TOK_EOF
} TokKind;
typedef struct {
TokKind kind;
int value; /* used when kind == TOK_NUM */
} Token;Position de lecture
L’analyseur lexical parcourt la source avec un pointeur de curseur. Un petit utilitaire examine le caractère actuel sans le consommer et renvoie '\0' à la fin.
L’arithmétique des pointeurs permet de conserver un analyseur rapide et simple.
static const char *src;
static char peek(void) {
return *src;
}
static char advance(void) {
return *src++;
}Ignorer les espaces
Avant de lire un Token, nous supprimons les espaces et les tabulations. La fonction standard isspace de <ctype.h> gère tous les caractères blancs.
Les sauts de ligne sont considérés comme des espaces ici, l’expression peut donc s’étendre sur plusieurs lignes.
#include <ctype.h>
static void skip_ws(void) {
while (isspace((unsigned char)peek()))
advance();
}Analyse lexicale d’un nombre
Lorsque le curseur se trouve sur un chiffre, nous accumulons les chiffres consécutifs dans un entier. Multiplier par dix et ajouter chaque chiffre construit la valeur de gauche à droite.
La boucle s’arrête au premier caractère qui n’est pas un chiffre et laisse le curseur prêt pour le Token suivant.
static int lex_number(void) {
int n = 0;
while (isdigit((unsigned char)peek())) {
n = n * 10 + (advance() - '0');
}
return n;
}La fonction next_token
La routine centrale ignore les espaces, puis choisit une action selon le caractère actuel. Les chiffres deviennent un TOK_NUM ; chaque opérateur correspond à sa propre catégorie.
Atteindre le NUL final produit TOK_EOF, le signal d’arrêt.
static Token next_token(void) {
skip_ws();
char c = peek();
if (c == '\0') return (Token){TOK_EOF, 0};
if (isdigit((unsigned char)c))
return (Token){TOK_NUM, lex_number()};
advance();
switch (c) {
case '+': return (Token){TOK_PLUS, 0};
case '-': return (Token){TOK_MINUS, 0};
case '*': return (Token){TOK_STAR, 0};
case '/': return (Token){TOK_SLASH, 0};
case '(': return (Token){TOK_LPAREN, 0};
case ')': return (Token){TOK_RPAREN, 0};
}
return (Token){TOK_EOF, 0};
}Exécuter l’analyseur lexical
Voici un programme complet qui transforme une expression en tokens et affiche la catégorie de chaque Token. Les nombres affichent également leur valeur.
Remarquez que la boucle se termine lorsqu’elle lit TOK_EOF.
#include <stdio.h>
#include <ctype.h>
typedef enum { TOK_NUM, TOK_PLUS, TOK_STAR, TOK_EOF } TokKind;
typedef struct { TokKind kind; int value; } Token;
static const char *src;
static char peek(void){ return *src; }
static char advance(void){ return *src++; }
static Token next_token(void){
while (isspace((unsigned char)peek())) advance();
char c = peek();
if (c=='\0') return (Token){TOK_EOF,0};
if (isdigit((unsigned char)c)){
int n=0; while(isdigit((unsigned char)peek())) n=n*10+(advance()-'0');
return (Token){TOK_NUM,n};
}
advance();
if (c=='+') return (Token){TOK_PLUS,0};
return (Token){TOK_STAR,0};
}
int main(void){
src = "12 + 3 * 4";
Token t;
do {
t = next_token();
if (t.kind==TOK_NUM) printf("NUM %d\n", t.value);
else if (t.kind==TOK_PLUS) printf("PLUS\n");
else if (t.kind==TOK_STAR) printf("STAR\n");
else printf("EOF\n");
} while (t.kind != TOK_EOF);
return 0;
}Un Token d’anticipation
Les analyseurs syntaxiques doivent généralement examiner le Token suivant avant de le consommer. Nous stockons un Token dans un current global et le remplaçons après chaque correspondance.
Cette anticipation d’un seul Token suffit pour notre grammaire LL(1).
static Token current;
static void init_lexer(const char *s) {
src = s;
current = next_token();
}
static Token cur(void) { return current; }
static void bump(void) { current = next_token(); }Signaler les erreurs lexicales
Un caractère inconnu — par exemple $ ou @ — ne doit pas disparaître silencieusement. Un analyseur lexical robuste signale l’octet fautif et s’arrête.
Un échec immédiat dans l’analyseur lexical empêche les étapes suivantes de rencontrer des tokens incohérents.
#include <stdio.h>
#include <stdlib.h>
static void lex_error(char c) {
fprintf(stderr, "lex error: unexpected '%c'\n", c);
exit(1);
}Opérateurs à plusieurs caractères
Les langages réels possèdent des tokens comme == ou <=. Pour les analyser lexicalement, nous examinons un caractère supplémentaire après le premier.
Si l’octet suivant complète l’opérateur, nous consommons les deux ; sinon, nous produisons la forme à un seul caractère.
/* fragment: distinguish '=' from '==' */
if (peek() == '=') {
advance();
if (peek() == '=') { advance(); /* TOK_EQ */ }
else { /* TOK_ASSIGN */ }
}Pourquoi les tokens sont importants
En regroupant les caractères en tokens, l’analyseur syntaxique travaille avec un flux propre et typé. La priorité des opérateurs, le regroupement et les erreurs deviennent tous plus faciles à comprendre.
Nous allons maintenant transmettre ces tokens à un analyseur syntaxique descendant récursif.
Vérification rapide
Réfléchissez à ce que produit l’analyseur lexical pour les symboles de regroupement.
Récapitulatif
Vous avez créé un analyseur lexical : un type de Token, un curseur de lecture, l’ignorance des espaces, l’analyse lexicale des nombres et un répartiteur next_token avec anticipation d’un Token.
Ces tokens sont les données d’entrée de l’analyse syntaxique, qui construit un arbre syntaxique à partir d’eux.
Questions Fréquemment Posées
La leçon « Découper l’entrée en jetons » est-elle gratuite ?
Oui — le texte complet de « Découper l’entrée en jetons » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C Academy, passe à CoddyKit PRO. Le cours C Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Découper l’entrée en jetons » ?
Transformez le texte en jetons. Tu pratiques C Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C Academy ?
Aucune expérience préalable n'est requise. C Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Découper l’entrée en jetons » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C Academy ?
Oui. Chaque leçon C Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Découper l’entrée en jetons
- Analyser des expressions
- Évaluer l’arbre
- Ajouter des variables