🗺️ Plan du cours

• 1. Introduction — la calculette qui parle LISP
• 2. Pointeurs — l'adresse en mémoire
• 3. Structures & typedef
• 4. Chaînes & allocation dynamique
• 5. Récursivité — la fonction qui s'appelle elle-même
• 6. Tokeniseur — du texte aux jetons
• 7. Parseur récursif descendant — la grammaire en action
• 8. AST — l'arbre qui cache l'expression
• 9. Évaluateur — calculer l'arbre
• 10. Compilateur — s-exp → bytecode VM
• 11. REPL & philosophie Unix

1. Introduction — la calculette LISP

On part d'une chaîne comme "(+ 2 (* 3 4))" et on arrive à :

calc.c (414 lignes) fait tout : parse, évalue, compile, REPL.

2. Pointeurs — l'adresse en mémoire

Un pointeur est une variable qui contient une adresse mémoire.

int x = 42;
int *p = &x;     // & = "adresse de"
printf("%d", *p);  // * = "valeur pointée" → 42
*p = 99;            // x vaut maintenant 99

3. Structures

Regrouper des variables de types différents dans une structure :

typedef struct Node {
    int    type;      // 0 = nombre, 1 = opérateur
    int    valeur;    // pour les nombres
    char   op;        // pour les opérateurs : + - * /
    struct Node *gauche;
    struct Node *droite;
} Node;

typedef crée un alias : on écrit Node au lieu de struct Node.

Node *n = malloc(sizeof(Node));
n->type   = 0;     // -> = accès membre via pointeur
n->valeur = 42;

4. Chaînes & allocation dynamique

char s[] = "hello";
// s = ['h','e','l','l','o','\0']
strlen(s);   // → 5
strcmp(a,b); // compare
strcpy(d,s); // copie

int *p = malloc(10 * sizeof(int));
if (!p) { /* échec */ }
p[0] = 42;
free(p);     // libérer
p = NULL;   // bonne pratique

5. Récursivité

Une fonction qui s'appelle elle-même — avec une condition d'arrêt.

long long fact(int n) {
    if (n <= 1) return 1;
    return n * fact(n - 1);
}

int evaluer(Node *n) {
    if (n->type == 0)
        return n->valeur;
    int vg = evaluer(n->gauche);
    int vd = evaluer(n->droite);
    // combiner vg et vd selon l'op
}

6. Tokeniseur — du texte aux jetons

Première étape : découper la chaîne en tokens (unités lexicales).

static char *pos;
static char token[64];

void token_suivant(void) {
    while (*pos && isspace(*pos)) pos++;  // skip espaces
    if (*pos == '(' || *pos == ')') {    // parenthèse
        token[0] = *pos++; token[1] = '\0';
        return;
    }
    if (strchr("+-*/", *pos)) {           // opérateur
        token[0] = *pos++; token[1] = '\0';
        return;
    }
    // nombre (avec chiffres)
    int i = 0;
    while (isdigit((unsigned char)*pos))
        token[i++] = *pos++;
    token[i] = '\0';
}

7. Parseur récursif descendant

Grammaire : expr → '(' op expr expr ')' | nombre

Node *parse_expr(void) {
    if (strcmp(token, "(") == 0) {   // liste → opérateur
        token_suivant();                // consommer '('
        char op = token[0];              // lire l'opérateur
        token_suivant();                // passer à l'opérande
        Node *g = parse_expr();          // enfant gauche
        Node *d = parse_expr();          // enfant droit
        token_suivant();                // consommer ')'
        return nouvel_operateur(op, g, d);
    }
    // atome → nombre
    int v = atoi(token);
    token_suivant();
    return nouveau_nombre(v);
}

Il s'appelle lui-même pour les sous-expressions → récursif descendant.

7.2 Fonctionnement pas-à-pas

Pour (+ 2 (* 3 4)) :

8. AST — l'arbre syntaxique abstrait

L'AST est la structure en mémoire de l'expression, avec des pointeurs gauche et droite.

Affichage indenté (depth-first) :

opérateur '+'
  nombre 2
  opérateur '*'
    nombre 3
    nombre 4

9. Évaluateur — calculer l'arbre

Parcours postfixé (post-order) : on évalue d'abord les enfants, puis le parent.

int evaluer(Node *n) {
    if (n->type == 0)               // nombre
        return n->valeur;

    int vg = evaluer(n->gauche);   // ← gauche d'abord
    int vd = evaluer(n->droite);    // ← droite ensuite

    switch (n->op) {
        case '+': return vg + vd;
        case '*': return vg * vd;
    }
}

10. Compilateur — s-exp → bytecode VM

Même parcours postfixé, mais au lieu de calculer, on émet des instructions.

void compiler_expr(Bytecode *bc, Node *n) {
    if (n->type == 0) {
        emettre(bc, PUSH);
        emettre(bc, n->valeur);
        return;
    }
    compiler_expr(bc, n->gauche);
    compiler_expr(bc, n->droite);
    switch (n->op) {
        case '+': emettre(bc, ADD); break;
        case '*': emettre(bc, MUL); break;
    }
}

PUSH 2
PUSH 3
PUSH 4
MUL
ADD
PRINT
HALT

10.2 Bytecode dynamique

Le compilateur émet dans un tableau dynamique (Bytecode) :

typedef struct {
    int *code;
    int taille;
    int capacite;
} Bytecode;

void emettre(Bytecode *bc, int v) {
    if (bc->taille >= bc->capacite) {
        bc->capacite *= 2;
        bc->code = realloc(bc->code,
                          bc->capacite * sizeof(int));
    }
    bc->code[bc->taille++] = v;
}

10.3 Génération de fichier .c

Le compilateur peut aussi écrire un fichier .C contenant le bytecode :

// Fichier généré par : ./calc -vm '(+ 2 (* 3 4))' -o out.c
int bytecode[] = {
    PUSH, 2,
    PUSH, 3,
    PUSH, 4,
    MUL,
    ADD,
    PRINT,
    HALT
};
int taille_bytecode = sizeof(bytecode) / sizeof(bytecode[0]);

On peut même #include le fichier dans vm.c. C'est de la génération de code : un programme qui écrit un autre programme.

11. REPL — la boucle interactive

Read → Eval → Print → Loop :

> (+ 2 (* 3 4))
  => 14
> (* (+ 2 3) (- 5 2))
  => 15
> quit
Au revoir !

Le REPL utilise fgets pour lire l'entrée, parse_expr + evaluer pour le calcul :

void repl(void) {
    char ligne[1024];
    printf("> ");
    while (fgets(ligne, sizeof(ligne), stdin)) {
        traiter_expression(ligne, 0, NULL);
        printf("> ");
    }
}

11.2 Modes d'utilisation

calc.c accepte plusieurs modes via la ligne de commande :

12. LISP — l'héritage

LISP (1958) est le 2^e plus vieux langage. Sa grande idée : code et données ont la même forme.

Résumé du cours

L'évaluateur et le compilateur font le même parcours d'arbre. L'un calcule, l'autre génère du code. C'est la même recette, mais avec des ingrédients différents.