De la source à l'exécutable

Point de départ

// ── Les fichiers du projet ────────────────────────────────────────────────
const FICHIERS = {
  "calcul.h": [
    "#define PI 3.14159",
    "int aire(int r);",              // déclaration seule
    "int perimetre(int r);",         // déclarée, jamais définie : piège
  ].join("\n"),

  "calcul.c": [
    '#include "calcul.h"',
    "int aire(int r) { return PI * r * r; }",
  ].join("\n"),

  "main.c": [
    '#include "calcul.h"',
    "int main(void) {",
    "  int a = aire(3);",
    "  int p = perimetre(3);",       // appelée, jamais définie
    "  return a + p;",
    "}",
  ].join("\n"),
};

// ── ① Préprocesseur ───────────────────────────────────────────────────────
// Manipulation de TEXTE : recopier les #include, remplacer les #define.
function preprocesseur(nom, vus = new Set()) {
  if (vus.has(nom)) return "";        // garde d'inclusion
  vus.add(nom);
  const defines = {};
  const sortie = [];
  for (const ligne of FICHIERS[nom].split("\n")) {
    const inc = /^#include "(.+)"$/.exec(ligne.trim());
    if (inc) { sortie.push(preprocesseur(inc[1], vus)); continue; }
    const def = /^#define (\w+) (.+)$/.exec(ligne.trim());
    if (def) { defines[def[1]] = def[2]; continue; }
    // ← à écrire : remplacer chaque macro connue par sa valeur
    sortie.push(ligne);
  }
  return sortie.join("\n");
}

// ── ② Compilation : un fichier à la fois ──────────────────────────────────
// On récolte les symboles DÉFINIS et les symboles APPELÉS.
function compiler(source) {
  const definis = [...source.matchAll(/^(?:int|void) (\w+)\s*\([^)]*\)\s*\{/gm)].map((m) => m[1]);
  const appeles = [...source.matchAll(/(\w+)\s*\(/g)].map((m) => m[1])
    .filter((n) => !["int", "void", "if", "while", "for", "return"].includes(n));
  return { definis, appeles: [...new Set(appeles)].filter((n) => !definis.includes(n)) };
}

// ── ④ Édition de liens ────────────────────────────────────────────────────
function editerLiens(objets) {
  const erreurs = [];
  // ← à écrire : rassembler tous les symboles définis, puis vérifier que
  //   chaque symbole appelé en trouve un. Signaler aussi les doublons.
  return erreurs;
}

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Faites remplacer les macros par le préprocesseur (PI doit disparaître).
// 2. Écrivez editerLiens, avec les DEUX erreurs : symbole non résolu et
//    définition multiple.
// 3. Compilez main.c SEUL, puis main.c + calcul.c. Quelle erreur reste ?

console.log("— calcul.c après préprocesseur —");
console.log(preprocesseur("calcul.c"));

Solution

const FICHIERS = {
  "calcul.h": ["#define PI 3.14159", "int aire(int r);", "int perimetre(int r);"].join("\n"),
  "calcul.c": ['#include "calcul.h"', "int aire(int r) { return PI * r * r; }"].join("\n"),
  "main.c": ['#include "calcul.h"', "int main(void) {", "  int a = aire(3);",
             "  int p = perimetre(3);", "  return a + p;", "}"].join("\n"),
  "geo.c": ['#include "calcul.h"', "int aire(int r) { return 3 * r * r; }"].join("\n"),
};

function preprocesseur(nom, vus = new Set()) {
  if (vus.has(nom)) return "";
  vus.add(nom);
  const defines = {};
  const sortie = [];
  for (const ligne of FICHIERS[nom].split("\n")) {
    const inc = /^#include "(.+)"$/.exec(ligne.trim());
    if (inc) { sortie.push(preprocesseur(inc[1], vus)); continue; }
    const def = /^#define (\w+) (.+)$/.exec(ligne.trim());
    if (def) { defines[def[1]] = def[2]; continue; }
    // Substitution textuelle pure : le préprocesseur ne sait pas ce qu'est
    // une variable, il remplace un motif par un autre. D'où les surprises
    // classiques des macros mal parenthésées.
    let l = ligne;
    for (const [nomMacro, valeur] of Object.entries(defines)) {
      l = l.replace(new RegExp("\\b" + nomMacro + "\\b", "g"), valeur);
    }
    sortie.push(l);
  }
  return sortie.filter((x) => x !== "").join("\n");
}

function compiler(source) {
  const definis = [...source.matchAll(/^(?:int|void) (\w+)\s*\([^)]*\)\s*\{/gm)].map((m) => m[1]);
  const appeles = [...source.matchAll(/(\w+)\s*\(/g)].map((m) => m[1])
    .filter((n) => !["int", "void", "if", "while", "for", "return"].includes(n));
  return { definis, appeles: [...new Set(appeles)].filter((n) => !definis.includes(n)) };
}

function editerLiens(objets) {
  const erreurs = [];
  const table = {};
  // Une seule passe pour collecter, une seconde pour résoudre : l'éditeur
  // de liens ne connaît que des NOMS, ni types ni lignes de code.
  for (const o of objets) {
    for (const d of o.definis) {
      if (table[d]) erreurs.push("multiple definition of " + d +
        " (" + table[d] + " et " + o.nom + ")");
      else table[d] = o.nom;
    }
  }
  for (const o of objets) {
    for (const a of o.appeles) {
      if (!table[a]) erreurs.push("undefined reference to " + a + " (appelé depuis " + o.nom + ")");
    }
  }
  return erreurs;
}

function construire(noms) {
  const objets = noms.map((n) => ({ nom: n.replace(".c", ".o"), ...compiler(preprocesseur(n)) }));
  console.log("   objets : " + objets.map((o) =>
    o.nom + " définit [" + o.definis.join(",") + "] appelle [" + o.appeles.join(",") + "]").join("  |  "));
  const erreurs = editerLiens(objets);
  if (erreurs.length === 0) console.log("   édition de liens : ok");
  else for (const e of erreurs) console.log("   ld: " + e);
}

console.log("— calcul.c après préprocesseur (PI a disparu) —");
console.log(preprocesseur("calcul.c"));

console.log("");
console.log("— gcc -c main.c  puis  ld main.o —");
construire(["main.c"]);
// Deux symboles manquent : aire, dont la définition est dans un fichier
// qu'on n'a pas passé, et perimetre, qui n'existe nulle part.

console.log("");
console.log("— gcc main.c calcul.c —");
construire(["main.c", "calcul.c"]);
// aire est résolu. perimetre reste introuvable : il était DÉCLARÉ dans
// l'en-tête, donc le compilateur n'a rien eu à redire — c'est bien
// l'éditeur de liens qui s'en aperçoit, et lui seul.

console.log("");
console.log("— gcc main.c calcul.c geo.c —");
construire(["main.c", "calcul.c", "geo.c"]);
// Et l'erreur symétrique : deux fichiers définissent aire.

Avant de commencer

• gcc et make installés
• Un éditeur de texte, et un terminal

Énoncé

1. Les quatre étapes, une par une — À partir d'un programme d'une ligne, produisez successivement le fichier prétraité, l'assembleur, l'objet, puis l'exécutable. Regardez la taille de chacun. Indice : Les options -E, -S, -c arrêtent gcc à chaque étape.
2. Ce que fait le préprocesseur — Comptez les lignes de votre source, puis celles du fichier prétraité. Trouvez d'où viennent les autres, et cherchez-y la déclaration de printf.
3. Activer les avertissements — Écrivez un programme qui utilise une variable non initialisée et oublie une valeur de retour. Compilez sans option, puis avec -Wall -Wextra. Comparez.
4. Séparer en deux fichiers — Créez le fil rouge du semestre : un fichier principal et un module de comptage, avec son en-tête. Compilez les deux séparément puis liez-les.
5. L'erreur de l'éditeur de liens — Déclarez une fonction dans l'en-tête sans l'écrire. Compilez chaque fichier — ça passe. Liez — ça échoue. Expliquez la différence entre les deux messages.
6. Le Makefile — Écrivez un Makefile qui reconstruit uniquement ce qui a changé. Modifiez un seul fichier et vérifiez que l'autre n'est pas recompilé.

C'est réussi quand

• ✓ Vous nommez les quatre étapes et ce qui entre et sort de chacune
• ✓ -Wall -Wextra vous signale au moins deux problèmes que la compilation muette laissait passer
• ✓ make ne recompile que le fichier modifié
• ✓ Vous distinguez une erreur de compilation d'une erreur d'édition de liens

Correction

gcc -E bonjour.c -o bonjour.i   # préprocesseur  : 800 lignes
gcc -S bonjour.i -o bonjour.s   # compilation    : assembleur
gcc -c bonjour.s -o bonjour.o   # assemblage     : code machine
gcc    bonjour.o -o bonjour     # édition de liens : exécutable

bonjour.c : 120 octets
bonjour.i :  26 Ko      ← stdio.h a été recopié en entier
bonjour.o : 1,5 Ko
bonjour   :  16 Ko

grep -n "printf" bonjour.i
extern int printf (const char *__restrict __format, ...);

#include ne « charge » rien : il RECOPIE le fichier à cet endroit

int main(void) {
  int x;
  printf("%d\n", x + 1);   /* x non initialisé */
}

gcc essai.c                    → aucun message. Compile.
gcc -Wall -Wextra essai.c
warning: 'x' is used uninitialized
warning: control reaches end of non-void function

/* journal.h — les DÉCLARATIONS */
#ifndef JOURNAL_H
#define JOURNAL_H
int compter_lignes(const char *chemin);
#endif

/* journal.c — les DÉFINITIONS */
#include "journal.h"
int compter_lignes(const char *chemin) { … }

/* main.c */
#include "journal.h"
int main(int argc, char **argv) {
  if (argc < 2) { fprintf(stderr, "usage: journal FICHIER\n"); return 1; }
  printf("%d lignes\n", compter_lignes(argv[1]));
  return 0;
}

# compilation : le fichier COURANT est incohérent
journal.c:12: error: 'compter' undeclared

# édition de liens : tous les fichiers compilent, rien ne les relie
/usr/bin/ld: undefined reference to 'compter_lignes'

CC     = gcc
CFLAGS = -Wall -Wextra -std=c17 -g

journal: main.o journal.o
$(CC) $^ -o $@

main.o:    main.c journal.h
journal.o: journal.c journal.h

clean:
rm -f *.o journal