Informatique

Pascal, le langage qui a appris à programmer avec méthode

Conçu par Niklaus Wirth à Zurich en 1970 pour enseigner une programmation claire et rigoureuse, Pascal a formé des générations d'étudiants, puis a conquis les micro-ordinateurs avec Turbo Pascal et le développement d'applications avec Delphi. Cinq planches pour découvrir ses types vérifiés par le compilateur, son P-code portable, ses algorithmes récursifs, ses pointeurs, puis pour compiler et exécuter de vrais programmes Pascal.

Un langage pour enseigner

À la fin des années 1960, Niklaus Wirth, professeur à l'École polytechnique fédérale de Zurich (ETH), juge les langages de l'époque trop complexes (PL/I, ALGOL 68) ou trop permissifs (Fortran) pour enseigner. Il conçoit un langage petit, régulier, où chaque donnée a un type déclaré et où le programme se lit comme une suite de blocs emboîtés : begin ... end, if ... then ... else, while ... do. Il le baptise Pascal, en hommage au mathématicien et philosophe Blaise Pascal, inventeur en 1642 d'une machine à calculer. Le premier compilateur fonctionne en 1970 sur un ordinateur CDC 6000 de l'ETH ; la définition du langage est publiée en 1971.

Les étapes du langage (en haut) et ses grands usages (en bas). De l'enseignement aux applications Windows, Pascal a eu plusieurs vies.
Planche 1

Des types vérifiés par le compilateur

1970

En Pascal, toute variable est déclarée avec son type : integer (entier), real (réel), boolean, char, string, mais aussi des types que l'on invente : une énumération (Rouge, Vert, Bleu), un intervalle 1..10, un tableau, un enregistrement. Avant d'exécuter quoi que ce soit, le compilateur vérifie que chaque valeur va dans une variable de type compatible : beaucoup d'erreurs sont ainsi détectées avant même le premier essai. Choisissez une instruction : le compilateur l'accepte-t-il ?

Les déclarations

L'instruction testée

L'instruction entre dans le compilateur, qui vérifie la compatibilité des types : refus (en rouge), avertissement (en orange) ou acceptation et production du code machine (en vert). Un intervalle dépassé ne provoque qu'un avertissement.
Verdict de ce petit compilateur
—
Message de Free Pascal 3.2.2 pour l'instruction d'origine
—
Ce que cela évite
—
Contrôle : les 20 verdicts (accepté ou refusé) comparés à ceux de Free Pascal
—
Ce qu'il faut retenir. Le typage fort de Pascal interdit les mélanges hasardeux : on peut ranger un entier dans un réel, mais pas l'inverse sans dire comment arrondir (round ou trunc) ; une condition doit être un booléen ; une couleur n'est pas un jour de la semaine. Les types inventés par le programmeur rendent le programme plus lisible et plus sûr. Mais le compilateur ne peut pas tout prévoir : un débordement de calcul pendant l'exécution passe inaperçu, sauf si l'on active les contrôles avec {$R+} et {$Q+}. Ces idées ont inspiré Ada, Modula-2, Java ou Rust.
Planche 2

Le P-code : un programme pour toutes les machines

1973 – 1983

Écrire un compilateur pour chaque ordinateur coûte cher. Vers 1973, l'équipe de Wirth diffuse un compilateur Pascal qui ne produit pas du code machine, mais du P-code : les instructions d'une machine imaginaire très simple, à pile. Pour faire fonctionner Pascal sur un nouvel ordinateur, il suffit d'écrire un petit interpréteur de P-code. En 1977, l'UCSD Pascal de l'université de Californie à San Diego étend l'idée à tout un système, qui tourne sur l'Apple II et l'IBM PC. Suivez la traduction d'un programme et son exécution sur la pile.

4

Pascal

P-code

    La machine P : à gauche la pile de calcul (le sommet en haut), à droite les variables en mémoire, en bas la sortie. LOD empile une variable, LDC une constante, STR range le sommet dans une variable, ADD, MOD, NEQ… combinent les deux valeurs du sommet, FJP saute si le sommet est faux, UJP saute toujours.
    Instructions P-code : programme / exécutées
    —
    Instruction en cours
    —
    Profondeur maximale de la pile
    —
    Contrôle : sortie de la machine P identique à celle du programme compilé par Free Pascal (3 programmes)
    —
    Ce qu'il faut retenir. Une machine à pile n'a pas besoin de registres : pour calculer a mod b, on empile a, on empile b, puis MOD remplace les deux valeurs du sommet par le résultat. Le code produit est compact et l'interpréteur tient en quelques pages : c'est ainsi que Pascal s'est répandu sur des dizaines de machines différentes. L'interprétation est plus lente que du vrai code machine, mais l'idée a fait école : vingt ans plus tard, Java reprend exactement ce principe avec son bytecode et sa machine virtuelle, tout comme Python ou WebAssembly.
    Planche 3

    Algorithmes + structures de données = programmes

    1976

    Le livre de Wirth paru en 1976 porte un titre qui résume sa pensée : Algorithms + Data Structures = Programs. Un exemple célèbre en est le problème des huit reines : placer huit reines sur un échiquier sans qu'aucune n'en menace une autre (même ligne, même colonne, même diagonale). La procédure récursive Placer(i) essaie chaque colonne de la ligne i ; si la case est libre, elle pose la reine et passe à la ligne suivante, sinon elle essaie la colonne d'après, et revient en arrière quand rien ne marche : c'est le retour sur trace. Trois tableaux de booléens retiennent les colonnes et les diagonales occupées.

    4
    L'échiquier : les reines posées, la case essayée (cadre), les cases menacées par les reines déjà posées (hachures). Rouge : refus ; vert : la reine est posée.
    La pile des appels récursifs : une ligne par appel de Placer, avec la colonne essayée. Quand la pile se vide d'un niveau, l'algorithme revient en arrière.
    Cases essayées / profondeur de récursivité
    —
    Solutions trouvées
    —
    Sans retour sur trace : placements à examiner
    —
    Contrôle : première solution, nombre de solutions et de cases essayées comparés au programme compilé par Free Pascal
    —
    Ce qu'il faut retenir. Essayer toutes les façons de placer huit reines sur 64 cases demanderait d'examiner plus de 4 milliards de positions ; en en mettant une seule par ligne, il en reste 16,7 millions (88). Le retour sur trace abandonne une piste dès qu'elle est sans issue : il trouve les 92 solutions en essayant seulement 15 720 cases. Le bon algorithme compte autant que la vitesse de l'ordinateur. Pascal, avec ses procédures récursives et ses tableaux aux indices choisis (array[-7..7] pour les diagonales), permet d'écrire cet algorithme presque comme on l'explique.
    Planche 4

    Pointeurs et listes chaînées

    1970 – 1995

    Un tableau a une taille fixée à l'avance. Pour des données dont le nombre varie, Pascal offre les pointeurs : new(p) réserve en mémoire un nouvel enregistrement et range son adresse dans p ; p^ désigne cet enregistrement ; nil est le pointeur qui ne mène nulle part ; dispose(p) rend la mémoire. Avec des enregistrements qui contiennent un pointeur vers le suivant, on construit une liste chaînée. Regardez l'insertion de huit nombres dans une liste maintenue triée.

    Chaque case est un enregistrement Noeud : la valeur à gauche, le pointeur suivant à droite. La tête de liste est à gauche ; le nouveau nœud (en orange) est raccroché en changeant seulement deux pointeurs, sans déplacer les autres.
    Étape
    —
    Nœuds en mémoire / maillons parcourus
    —
    Liste
    —
    Contrôle : les 8 états successifs de la liste comparés au programme compilé par Free Pascal
    —
    Ce qu'il faut retenir. Insérer dans un tableau trié oblige à décaler tous les éléments suivants ; dans une liste chaînée, on change deux pointeurs. En contrepartie, pour trouver la bonne place, il faut parcourir la liste maillon par maillon depuis la tête. Les pointeurs de Pascal sont typés (^Noeud ne peut désigner qu'un Noeud), plus sûrs que ceux du C, mais l'oubli d'un dispose laisse de la mémoire perdue, et l'usage d'un pointeur après dispose provoque des erreurs difficiles à trouver. Les langages récents confient souvent ce travail à un ramasse-miettes.
    Planche 5 · signature

    Compiler et exécuter de vrais programmes Pascal

    2026

    Voici un petit compilateur et interpréteur Pascal, écrit pour cette page, qui suit les règles de Free Pascal (mode par défaut, où integer est un entier de 16 bits). Il vérifie les types avant d'exécuter, puis exécute : constantes, types énumérés, intervalles, tableaux à plusieurs dimensions et à bornes quelconques, enregistrements, pointeurs avec new et dispose, ensembles, chaînes ; if, case, while, repeat, for ; procédures et fonctions imbriquées et récursives, avec paramètres par valeur et par variable (var) ; write et writeln avec largeurs et décimales. Chaque exemple a aussi été compilé par Free Pascal 3.2.2 : les sorties sont comparées caractère par caractère.

    Le programme

    La sortie

    
          

    Les variables globales en fin d'exécution

    Opérations élémentaires / durée
    —
    Avertissements du compilateur
    —
    Message du compilateur
    —
    Contrôle : sortie identique à celle de Free Pascal 3.2.2 (exemple d'origine), et 966 lignes d'affichage de réels
    —
    Ce qu'il faut retenir. Un programme Pascal se compose de déclarations (const, type, var, procédures et fonctions) puis d'un bloc begin ... end. ; le point-virgule sépare les instructions, il ne les termine pas, d'où l'absence de point-virgule avant end. Les procédures peuvent être imbriquées et voient les variables des blocs qui les entourent. Dans writeln(x:10:4), 10 est la largeur et 4 le nombre de décimales. Essayez de provoquer une erreur de type, par exemple i := 2.5 dans l'exemple 1, ou de passer à 10 reines dans l'exemple 5 (en changeant les bornes des tableaux).

    Où trouve-t-on Pascal ?

    L'enseignement

    Des années 1970 aux années 1990, Pascal est le langage des cours d'informatique dans le monde entier : aux États-Unis, l'examen Advanced Placement d'informatique se passe en Pascal de 1984 à 1998 ; en France, on l'enseigne à l'université, en classes préparatoires et en IUT.

    Les micro-ordinateurs

    Turbo Pascal (Borland, 1983), écrit par Anders Hejlsberg, réunit un éditeur et un compilateur très rapide pour 49,95 dollars : il se vend à des centaines de milliers d'exemplaires. Une partie du système et des applications du Lisa et du premier Macintosh d'Apple est écrite en Pascal.

    Delphi et les applications

    Delphi (1995) ajoute à l'Object Pascal la conception visuelle de fenêtres et l'accès aux bases de données. Des logiciels connus ont été écrits avec : le premier client Skype pour Windows, Total Commander, FL Studio, et de nombreux logiciels de gestion. Delphi est 19e du classement TIOBE d'octobre 2026.

    Les logiciels libres

    Free Pascal (depuis 1993) compile Pascal pour Windows, macOS, Linux, Android et de nombreux processeurs ; l'environnement Lazarus permet de construire des applications graphiques multiplateformes. Ils ont servi à vérifier chaque exemple de cette page.

    Les héritiers

    Wirth poursuit avec Modula-2 (1978) et Oberon (1987). Ada, le langage de l'aéronautique et de la défense, reprend la syntaxe et le typage de Pascal. Anders Hejlsberg, l'auteur de Turbo Pascal et de Delphi, conçoit ensuite C# (2000) et TypeScript (2012).

    Une méthode

    Pascal a popularisé la programmation structurée, les types définis par le programmeur et l'idée qu'un programme doit d'abord être lisible. Wirth reçoit le prix Turing en 1984 ; il disparaît le 1er janvier 2024, à 89 ans.

    Frise des jalons

    Pour aller plus loin

    Les exemples, les verdicts de la planche 1 et les programmes des planches 2 à 4 ont été compilés et exécutés par Free Pascal 3.2.2 au moment de la fabrication de la page ; l'affichage des réels a en plus été comparé sur 966 lignes. Votre navigateur refait tous ces calculs et les compare.