Pascal (langage)

Pour les articles homonymes, voir Pascal.

Pascal
Apparu en	1970 (évolution constante)
Auteur	Niklaus Wirth
Paradigme	générique, orientée objet, procédural, impératif
Typage	statique, safe, nominatif
Dialectes	UCSD, Borland, Turbo, Delphi, Free Pascal
Influencé par	ALGOL, Fortran
A influencé	Ada 95, Modula-2, Modula-3, Oberon
Implémentations	CDC 6000, PASCAL-P, PDP-11, PDP-10, IBM System/370, HP, GNU, Delphi, Free Pascal, Lazarus

Pascal est un langage de programmation impératif qui se caractérise par une syntaxe claire, rigoureuse et facilitant la structuration des programmes. Cette clarté et cette rigueur font que Pascal est souvent utilisé dans l'enseignement.

En dehors de la syntaxe et de sa rigueur, le langage Pascal possède de nombreux points communs avec le C (voir les pointeurs). Le langage Pascal de base était conçu à usage purement éducatif et était assez limité (pas de chaînes de caractères, par exemple), mais les développements qu'il a connus en ont fait un langage complet et efficace. Relativement récemment, la généricité a été ajoutée dans Delphi et en Lazarus.

Les versions actuelles de Pascal, utilisées hors du monde éducatif, sont des extensions telles que Turbo Pascal (mode texte), Object Pascal (programmation objet), et Delphi (fenêtré). Il existe des versions libres comme Free Pascal et Lazarus (fenêtré). On peut programmer en Pascal sous DOS, Windows, Mac OS ou encore sous Linux/Unix ou Palm OS.

Pascal est connu pour avoir permis d'élaborer des logiciels assez renommés comme TeX et une partie des premiers systèmes d'exploitation du Macintosh. Sa syntaxe a aussi été reprise par d'autres langages comme Ada, Modula-2 (puis Modula-3) ou Oberon.

Présentation et histoire

Le langage de programmation Pascal (dont le nom vient du mathématicien français Blaise Pascal) a été inventé par Niklaus Wirth dans les années 1970. Il a été conçu pour servir à l'enseignement de la programmation de manière rigoureuse mais simple, en réaction à la complexité de l'Algol 68.

Ce langage est l'un de ceux qui ont servi à enseigner la programmation structurée. Le goto ou saut n'importe où dans le programme (dit « branchement ») est fortement déconseillé dans ce langage, le programme est un assemblage de procédures et de fonctions, dans lesquels on peut utiliser des blocs conditionnels (if, case...) et répétitifs (while, for, repeat...) ayant chacun une entrée et une sortie afin de faciliter les contrôles, ce qui aboutit à des mises au point rapides et sûres.

Le langage est de plus fortement et statiquement typé, c'est-à-dire que toutes les variables doivent avoir un type défini au moment de la compilation. En revanche son manque de souplesse pour gérer les passages du type caractère au type chaîne de caractères est l'un de ses points faibles.

Il a largement pénétré le monde de l'éducation et de la recherche (universités), puis dans une moindre mesure celui de l'industrie.

Le compilateur P4 a été diffusé en source dans les universités, à un prix très réduit. Il générait du P-Code, un code pour une machine virtuelle. Les programmes Pascal étaient donc facilement portables sur une machine. Il suffisait d'écrire pour elle un interpréteur de P-Code. Il y eut donc rapidement des portages sur 6502, 8080, Z80 et DEC PDP-11, les principaux microprocesseurs de l'époque.

Le compilateur UCSD Pascal (UCSD = University of California at San Diego) eut beaucoup de succès, notamment sur des machines comme l'Apple II qui furent très diffusées.

Mais le coup de « turbo » sera donné par la société Borland, créée en 1983 qui commercialisa le compilateur Turbo Pascal pour un prix très modique (49 $ de l'époque alors que le compilateur Pascal Microsoft était à plus de 500 $ et ne possédait pas d'éditeur intégré ni de compilation in core). En fait, il y a aura bien un concurrent direct du Turbo Pascal chez Microsoft (Quick Pascal) mais il sera commercialisé bien trop tard pour inverser la tendance.

Le Pascal a fait l'objet de deux normes : ISO 7185^[1] et ISO 10206^[2].

Les fichiers sources

Le code source brut d'un programme Pascal peut porter l'extension .pas, la plus courante, .p ou encore .pp, ces deux dernières extensions apparaissant surtout dans les systèmes UNIX.

Les fichiers de code source sont catégorisés suivant différentes possibilités :

• les fichiers sources pour les programmes principaux commencent par le mot-clé program. Ils sont compilés et liés avec les unités qu'ils utilisent en un fichier exécutable (extension .exe sous Windows ; attribut exécutable sous systèmes Unix) ;
• les fichiers de bibliothèques (qui sont apparus plus tard dans le langage avec Delphi 1 sous Windows et avec FPC sous Unix) commencent par le mot-clé library. Ils sont compilés en une bibliothèque (extension .dll sous Windows, extension .so sur système Unix, etc.) ;
• les fichiers d'unités commencent par le mot-clé unit. Ils sont inclus dans des programmes ou des bibliothèques, compilés sous forme de fichier objet standard (extension .o ou .obj) ou dans un format particulier (.dcu pour les compilateur Borland).

De nos jours, l'utilisation des environnements fenêtrés a entraîné l'apparition de nouvelles extensions :

• les fichiers de descriptions de fenêtres (.dfm avec Delphi; .lfm avec Lazarus; etc.) qui décrivent le design de chaque fenêtre c'est-à-dire les widgets (boutons, case à cocher, etc.) et leurs propriétés.
• les fichiers de ressources, principalement utilisés sous Windows (extension .rc si non compilé et/ou extension .res une fois compilé) qui contiennent des images, icônes, curseurs, textes, etc. Sur système Unix, la plupart des ressources ne sont traditionnellement pas intégrées aux exécutables.
• tous les autres types de fichier de ressources spécifiques (images, sons, curseur, etc.), ce système est très utilisé sous Unix, car les ressources sont chargées à la demande par des accès à des fichiers séparés qui ne sont généralement pas nécessaires au fonctionnement du programme (par exemple si une image manque, le programme peut s'exécuter correctement).

Avant l'apparition des bibliothèques, Turbo Pascal permettait d'utiliser des overlay. Sous Unix leur utilisation était impossible. Sous DOS, il s'agissait de fichiers séparés du fichier exécutable principal et qui pouvaient être chargés ponctuellement, mais en totalité. Concernant les bibliothèques, il était bien évidemment possible de créer des bibliothèques en Pascal avant l'apparition de Delphi ou de FPC, l'apparition du mot clé library ne constituant qu'une facilité. Cette technique est d'ailleurs toujours utilisable, et utile dans certains cas particuliers.

Il est possible d'inclure du code dans un programme autrement qu'en écrivant une unité et ce en faisant simplement un include, c'est-à-dire en indiquant au compilateur d'inclure le texte d'un fichier dans un programme avec la directive $I :

program test;
 
uses Crt, Dos; { utilisation habituelle des unités }
 
{$I outil.inc} { utilisation directe de code externe }
 
begin
    { utiliser les fonctions du fichier outil.inc }
end.

Toutefois, cette méthode n'est pas recommandée au regard des inconvénients qu'elle présente (notamment si un identificateur est déclaré plusieurs fois dans des fichiers différents) et du manque de contrôle du compilateur sur ce type de fichiers. Ceci étant leur utilisation peut se révéler dans certain cas indispensable en particulier pour la création de bibliothèques multi-plateforme.

Le Turbo-Pascal

Le Turbo Pascal avait été écrit par Anders Hejlsberg (il s'appelait avant TP, Compass Pascal puis Poly Pascal). Très compact (12 K octets) et très rapide car travaillant essentiellement en RAM, il compilait en une passe et produisait du code machine (x86 sous DOS) et non plus du P-Code. Il était livré avec un environnement complet (un éditeur de texte et une aide en ligne, innovation à l'époque, particulièrement compacte grâce à un système de substitution). Au fil des différentes versions, Turbo Pascal apporta son lot d'innovations qui ne cesseront de combler en partie certaines lacunes du langage original.

C'est ainsi qu'en 1987 la version 4 apparaît avec un vrai EDI (Environnement de Développement Intégré), en 1989 la version 5.5 introduit les objets, en 1990 la version 6 permet la programmation de fenêtres (dans la console DOS), les prémices de l'événementiel. Et puis 1993, la dernière version, la 7, pour DOS et pour Windows.

Un exemple de code : Hello World

program HelloWorld(output);
begin
writeln ('Hello World');
readln;
end.

Le paramètre Output qui suit le nom du programme est aujourd'hui facultatif (il n'était obligatoire qu'avec les premières versions des implémentations Pascal). De nos jours, il est absent la plupart du temps.

Contrairement au C, le Pascal n'est pas sensible à la casse, c'est-à-dire que les mots réservés (comme begin) ou les identificateurs (comme write ou la variable a) peuvent être indifféremment écrits en majuscules ou en minuscules.

Toujours contrairement au C, les déclarations (var dans l'exemple ci-dessus) se font dans une partie clairement séparée du code. Les déclarations locales sont faites en début de procédure ou de fonction, les déclarations globales, elles, étant faites n'importe où avant le programme principal. Ceci ajoute de la clarté au langage au prix d'un certain manque de souplesse. On ne peut pas déclarer de variable au beau milieu d'une fonction. Notons qu'en Pascal, les déclarations doivent précéder toute utilisation ; il est notamment interdit d'utiliser une procédure ou une fonction qui n'a pas encore été déclarée.

Enfin, la distinction entre procédures et fonctions, présente dans le Pascal constitue cette fois un avantage par rapport à la plupart des autres langages (y compris le C) car elle rend impossible certaines erreurs de programmation (par défaut, car une directive de compilation de Delphi permet d'activer une syntaxe "étendue" qui offre le même laxisme d'utilisation que les C-like).

Delphi et la programmation fenêtrée

En 1995, pour contrecarrer Microsoft et la programmation visuelle du Visual Basic, Borland sort Delphi qui est, lui, un vrai compilateur qui produit du code machine. Ce langage emprunte clairement certaines caractéristiques du langage C++ en ajoutant, par exemple, le support des classes et, par conséquent, un système de programmation objet bien plus complet. On voit également apparaître la bibliothèque VCL servant d'interface aux bibliothèques Win32 de Windows, facilitant grandement le développement. Enfin, grâce à Delphi, pour la première fois, le Pascal devient un langage évènementiel.

En 2001, Borland produit Kylix, l'équivalent de Delphi pour le monde Linux.

Lazarus, une version open-source légèrement différente, permet de compiler sur n'importe quelle plateforme.

Exemple de source Lazarus

Voici un exemple de fichier Pascal associé à une fenêtre (Form1: TForm1) contenant un label (un texte). Ce fichier est généré automatiquement et sert de structure de base pour programmer. C'est-à-dire qu'on peut le modifier, le compléter etc. Les petits points sont des repères lors de l'édition. Ils sont invisibles à l'exécution. Le source et les fenêtres Delphi sont très semblables.

unit Unit1;
 
    {$mode objfpc}{$H+}
 
interface
 
uses
    Classes, SysUtils, LResources, Forms, Controls, Graphics, Dialogs, StdCtrls;
 
type
    { TForm1 }
 
    TForm1 = class (TForm)
         Label1: TLabel; { le label "Hello world!" posé sur la fenêtre }
    private
         { private declarations }
    public
         { public declarations }
    end;
 
var
    Form1: TForm1; 
 
implementation
 
initialization
    {$I unit1.lrs}
 
end.

Petite explication : la directive {$I unit1.lrs} permet de lier la classe TForm1, décrivant une fenêtre, au fichier de ressource unit1.lrs qui contient le design de la fenêtre. Avec Lazarus le fichier lrs est un fichier intermédiaire créé automatiquement par le compilateur à partir des informations du fichier lfm et des directives de compilation (notamment la possibilité de choisir la bibliothèque de Widget). Avec Delphi la directive équivalente aurais été {$R unit1.dfm} et il n'y a pas de fichier intermédiaire. Par ailleurs elle aurait été placée dans la partie interface.

Compilateurs

Liste des compilateurs les plus répandus

• Free Pascal (compatible avec le Pascal Objet de Borland) est un bon exemple de compilateur. Un environnement de développement visuel, accompagné de bibliothèques LGPL, permet au Free Pascal d'émuler Delphi (voir Lazarus). Free Pascal existe sur un grand nombre de plateformes facilitant le portage d'un programme d'un environnement à un autre.
• GNU Pascal, dont la particularité est d'être écrit en C, c'est donc un compilateur qui ne se compile pas lui-même ce qui est devenu assez rare aujourd'hui.
• Borland France autorise maintenant le téléchargement gratuit de Turbo Pascal 7.0 : Télécharger Borland Turbo Pascal 7.0 (DOS)
• Il est d'ailleurs possible de télécharger une version de Delphi et de Kylix, qui est utilisable gratuitement sous réserve de ne produire que des logiciels open-source; pour produire des logiciels payants, il faut s'acquitter d'une licence. Télécharger l'édition personnelle gratuite de Borland : Delphi 6, Delphi 2005 (Windows)

Compatibilité

Delphi ne fonctionne que sur Windows. Kylix, son équivalent officiel, tourne sous Linux et Unix. Malheureusement si Delphi continue à évoluer, le développement de Kylix a été stoppé. Par conséquent les versions supérieures à 7 de Delphi sont moins compatibles avec Kylix. Par ailleurs, la compatibilité Delphi/Kylix n'est possible qu'avec les applications utilisant la bibliothèque CLX. Les applications utilisant la VCL ne sont pas utilisables avec Kylix.

En ce qui concerne Free Pascal et Delphi/Kylix, de grands progrès ont été réalisés au niveau de la compatibilité des compilateurs. Aujourd'hui c'est près de 99 % de code compatible^{[réf. nécessaire]}. Toutefois, un certain nombre de remarques sont à faire :

• L'EDI de Free Pascal, Lazarus utilise un format différent pour les descriptions de fenêtres et boites de dialogue, il faut donc recréer une grande partie de l'interface. Toutefois l'équipe de développement actuelle travaille sur un convertisseur automatique.
• Les composants Delphi/Kylix n'utilisent pas les mêmes moyens techniques que les composants Lazarus. Ils sont donc soumis à une moins bonne compatibilité que les applications en elles-mêmes, même si là encore de grands progrès ont été réalisés, notamment sur les fonctionnalités qui ne sont pas directement associées aux bibliothèques Win32.
• Un certain nombre de composants Delphi/Kylix sont absents de Lazarus/Free Pascal, les bibliothèques Lazarus/Free Pascal ne sont pas encore achevées.
• 1 % de code non compatible peut demander beaucoup de travail sur de grosses applications...

Le projet GNU Pascal est assez peu populaire chez les amateurs de Pascal (il lui est souvent reproché par les puristes d'être écrit en C^{[réf. nécessaire]} et non en Pascal comme les autres). Bénéficiant de moins de contributeurs eux-mêmes moins concernés (ils font du C), le projet ne peut se vanter des mêmes avancées que Free Pascal. Il est relativement compatible avec les anciens programmes Turbo Pascal mais n'est fourni qu'avec les bibliothèques de base, et donc limité en mode graphique. Les amateurs de fenêtres sous Lazarus ou Delphi/Kylix auront beaucoup de travail pour porter leurs programmes sous GNU Pascal.

Pour résumer si vous faites un programme compatible avec Turbo Pascal (en mode texte plus particulièrement), vous pourrez le compiler sans trop de difficultés avec le compilateur de votre choix. L'apparition des modes graphique et des fenêtres a complexifié les bibliothèques rendant la compatibilité plus difficile, mais pas impossible. Quoi qu'il en soit, plus vous utiliserez des techniques logicielles récentes, plus la compatibilité entre compilateurs (et les possibilités de portage) sera compromise.

Portage

Le portage d'application d'un système à un autre est une tâche assez difficile en Pascal. C'est la principale raison du manque de popularité de ce langage, malgré un grand nombre de qualités^{[réf. nécessaire]}.

L'utilisation d'un compilateur disponible sur plusieurs plateformes facilite cette tâche. L'utilisation de fonctions spécifiques à un système est à éviter mais si c'est indispensable on peut s'inspirer du code suivant :

procedure Special(Param1, Param2: TypeParam);
begin
    {$IFDEF Linux}
      {Code sprécifique à linux}
    {$ELSEIF} {$IFDEF Win32}
      {Code spécifique à Windows 32 bits}
    {$ELSEIF}
      Plateforme non supportée (texte clair non-commenté générant une erreur)
    {$ENDIF}
    {Code commun}
end;

Le couple Delphi/Kylix constitue une bonne solution simple de portage Windows/Linux mais elle reste limitée à ces deux seuls systèmes, et impose l'utilisation des bibliothèques CLX. Le portage d'applications VCL vers des applications CLX est simple mais fastidieux car cela nécessite de redessiner complètement l'interface. Enfin Kylix n'étant plus développé, son usage est aujourd'hui déconseillé.

Lazarus est aujourd'hui la meilleure solution pour le développement multi-plateforme^{[non neutre]}. Son compilateur, le Free Pascal compiler, est capable de générer des exécutables pour quasiment toutes les plateformes actuelles^{[réf. nécessaire]} (c'est un compilateur croisé), Lazarus s'exécutant lui-même sur toutes ces plateformes. Hors utilisation de fonctions spécifiques à un système (appels directs aux bibliothèques Win32 par exemple, ou utilisation de l'assembleur), il compilera le code sans aucun problème quel que soit le système hôte et le système destinataire. Un inconvénient tout de même, Lazarus utilise, par défaut, la bibliothèque GTK en version 1.x (assez ancienne donc) en ce qui concerne les interfaces graphiques sous Linux, ce qui impose d'installer cette bibliothèque au préalable, alors qu'elle est considérée comme obsolète. Cela dit, des versions basés sur Qt 4 seront bientôt disponibles, le support de Qt 4 ayant considérablement avancé. Il est, par ailleurs, tout à fait possible de recompiler Lazarus pour qu'il utilise GTK 2 au lieu de GTK 1. La version Windows utilise directement les bibliothèques Win32 pour son affichage mais on peut aussi recompiler Lazarus pour qu'il utilise GTK 1 ou 2, ou Qt.

Aspects techniques

Récursivité

On peut écrire des fonctions récursives en Pascal. Par exemple cette fonction illustre bien cette possibilité :

FUNCTION factorielle (n : shortint) : integer;
BEGIN
  IF n <= 1 THEN
    factorielle := 1;
  ELSE
    factorielle := n * factorielle (n - 1);
END;

Remarque : le nombre d'appels récursifs est limité (de même que pour de nombreux langages) par la pile d'appel.

Généricité

Il est possible de définir des types génériques, c'est-à-dire pouvant être utilisés avec différent types possibles sans pour autant avoir à réécrire le code entier. Voilà un exemple en FreePascal :

type 
  { On définit un objet qui permet d'additionner deux éléments et multiplier un élément par un entier strictement positif }
 
  { TAnneauGenerique }
  generic TAnneauGenerique<T> = class
    function Somme(a, b: T): T;
    function Multiple(n: integer; a: T): T;
  end;
 
  { On crée deux versions spécialisées, s'appliquant aux nombre réels et aux chaines de caractères }
  TAnneauReel = specialize TAnneauGenerique<Real>;
  TAnneauChaine = specialize TAnneauGenerique<String>;
 
{ TAnneauGenerique }
 
function TAnneauGenerique.Somme(a, b: T): T;
begin
  result := a + b;
end;
 
function TAnneauGenerique.Multiple(n: integer; a: T): T;
var i: integer;
begin
     { On ne gère que le cas où n >= 1 }
     result := a;
     for i := 2 to n do result := result + a;
end;      
 
var
  r: TAnneauReel;
  c: TAnneauChaine;     
 
begin
  r := TAnneauReel.Create;
  writeln('Avec des réels :');
  writeln('4.1 + 5.2 = ', FloatToStr( r.Somme(4.1, 5.2) ));
  writeln('3 x 5.1 = ', FloatToStr( r.Multiple(3, 5.1) )); 
  r.free;
 
  writeln;
 
  c := TAnneauChaine.Create;
  writeln('Avec des chaines :');
  writeln('bon + jour = ', c.Somme('bon', 'jour'));
  writeln('10 x a = ', c.Multiple(10, 'a'));
  c.free;
 
  readln; 
end;

Note : en Delphi, il ne faut pas ajouter les mots-clés generic et specialize.

Dépendances mutuelles des unités

Il est possible que les différentes unités du programmes s'utilisent mutuellement, mais il y a une limitation. En effet, en Pascal, on peut faire référence à une autre unité à deux endroits possibles, à savoir dans l'interface et à l'implémentation. Si deux unités font référence l'une à l'autre dans leur interface, on obtient une erreur de dépendance circulaire. On peut contourner ce problème en utilisant une troisième unité qui servira de base aux deux autres, et/ou en utilisant des types plus abstraits au niveau des interfaces. Cette limitation n'existe pas en Visual Basic.

Avantages^{[non neutre]}

Le principal avantage du code Pascal est sa clarté^{[réf. nécessaire]}, ce qui facilite sa lecture. Cet avantage est particulièrement parlant avec les fonctions de tests. Faciles à lire en Pascal elles peuvent donner des maux de tête avec certains autres langages.^{[non neutre]} Par ailleurs, la structure du code renforce cette clarté : des sections précises pour les déclarations, la notion interface/implémentation rendant inutile la création d'un fichier d'interface, la distinction procédure/fonction... Le mot-clé "with" - qui évite de re-décrire toute la hiérarchie d'une structure de données utilisée dans un bloc begin/end - a largement contribué à la lisibilité du code:

with damier[ligne,colonne] do 
begin 
     piece=fou; 
     couleur=noir; 
end;

Un autre avantage du Pascal est sa rigueur : au contraire du Visual Basic, les passages d'un type à un autre se font selon des règles précises, les variables sont obligatoirement typées. Cette rigueur permet d'éviter nombres d'erreur de programmation, mais confère un certain manque de souplesse. Toutefois il est possible d'utiliser le type Variant qui permet de stocker autant un nombre qu'une chaîne de caractères (à utiliser avec précaution tout de même).

Pour le reste, beaucoup des inconvénients que l'on attribuait au langage il y a 10 ou 20 ans^[Quand ?], ne sont plus d'actualité. Par exemple, le manque de souplesse pour les passages chaîne - caractère a été corrigé dès les premières versions de Turbo Pascal. Les objets ont fait leur apparition avec la notion d'héritage, plus récemment les classes, et même la technique .net... Les optimisations apportées depuis Turbo Pascal 5.0 ont permis de générer des exécutables aux performances équivalentes à leurs homologues issus du C^{[réf. nécessaire]} mais le vieux mythe continue malheureusement d'exister^{[non neutre]}.

Dernier avantage du Pascal : la rapidité de compilation. Compiler 10 Mo de code ne demande en Pascal que quelques secondes contre plusieurs minutes en C^{[réf. nécessaire]}. Delphi 6 a même été jugé le compilateur le plus rapide de tous les temps^{[Par qui ?]}, capable de compiler une centaine de mégaoctets de code en moins d'une minute. Cette rapidité est due à la structure claire et explicite du langage avec, par exemple, la distinction procédure/fonction qui permet au compilateur d'éviter les tests permettant d'effectuer cette distinction ou encore l'absence de déclarations dans le code, l'obligation de déclarer les variables et les routines avant de les utiliser et enfin l'interface qui se trouve dans le même fichier que le code (un seul fichier ".pas" contre un fichier ".h" et un fichier ".c" en C). D'autre part, les fichiers .h du C doivent être relus à chaque fichier source compilé, alors qu'en Pascal, les unités ne sont compilées qu'une seule fois, et l'interface est enregistrée dans le code-objet.

Jusqu'à récemment^[Quand ?] un inconvénient majeur du langage était l'absence de support d'une technique de généricité. Cela a été rajouté aussi bien dans Delphi que dans Lazarus. On peut donc désormais faire des templates, c'est-à-dire du code dont on ne définit pas un type T qui sera remplacé plus tard par n'importe quel type voulu^[évasif].

Voir aussi

Sur les autres projets Wikimedia :

• « Pascal (langage) », sur Wikiversity (communauté pédagogique libre)
• « la programmation en Pascal », sur Wikibooks (livres pédagogiques)

Articles connexes

• Ada
• C
• Delphi
• Oberon
• Object Pascal
• Modula
• Java
• MIDletPascal

Liens externes

• (fr) Pour en savoir plus sur Turbo Pascal
• (fr) Cours et tutoriels sur Pascal
• (fr) Liste de compilateurs Pascal
• (fr) Pascal pour Palm Compilateur gratuit, en PRC.
• (fr) Installer un compilateur Pascal sous Linux

Notes et références

1. ↑ ISO 7185 sur le site de Karl Kleine
2. ↑ ISO 10206 sur le site de Karl Kleine