Voici un guide de traduction d'un algorithme impératif en Pascal.

Le Squelette

Pour le squelette de l'algorithme :

 1Algorithme mon_algo
 2
 3Constantes
 4
 5Types
 6
 7Variables
 8
 9Début
10
11Fin

On traduit ainsi :

 1program mon_programme;
 2
 3Const
 4
 5Type
 6
 7Var
 8
 9begin
10
11end. (* notez ce point *)

Commentaires

Les commentaires notés

(* un commentaire *)

s'écrivent de la même façon

(* un commentaire *)

Types

Voici l'équivalence des types

• Les valeurs booléennes sont true et false.
• Les parties entière et décimale d'un réel sont séparées par un point et non une virgule.
• les chaînes sont déclarées entre deux apostrophes ' pour échapper un caractère on le double.

Exemple sur ce dernier point : pour inclure une apostrophe dans une chaîne,

writeln('l''apostrophe s''est échappée')

affiche

l'apostrophe s'est échappée

Constantes et variables

Les constantes et les variables ont des identifiants qui doivent respectées une syntaxe précise.

• l'identifiant ne peut comporter que des caractères alpha-numériques (de A à Z, de a à z et de 0 à 9) et des tirets-bas ou underscore : _.
• le premier caractère est une lettre.

les variables sont déclarées dans le Lexique du programme délimité par sa partie Var. Chaque déclaration est de la forme

identifiant : type;

Ainsi le lexique

Lexique
  un_reel : réel                     (* un réel quelconque *)
  une_chaine : chaîne de caractères  (* une chaîne quelconque *)

se traduit

Var
  un_reel : real;       (* un réel quelconque *)
  une_chaine : string;  (* une chaîne quelconque *)

Les identifiants des constantes respectent les même règles. Par convention, on préfèrera les noter en majuscules. La déclaration d'une constante a pour syntaxe

 identifiant = valeur;

Ceci

Constantes
  PI = 3,14
  G = 9,81

s'écrit en pascal :

Const
  PI = 3.14;
  G = 9.81;

Instructions et blocs d'instructions

Pour exécuter une instruction (assignation, appel de fonction ou procédure) il suffit de l'écrire. Les paramètres sont précisés entre parenthèses et séparés par des virgules.

Les bloc d'instructions débutent par un begin et se terminent par un end. Les instructions du bloc sont séparées par des point-virgules. On gardera la convention algorithmique préférant une instruction par ligne.

Voici une ligne comportant une instruction unique :

une_instruction

Voici un bloc de k d'instructions :

begin
  instruction_1;
  instruction_2;
  (* ... *)
  instruction_k
end

Remarquez qu'aucun point-virgule ne ponctue la dernière instruction. En effet le ';' est un séparateur : il sépare les instructions entre elles. Il n'y a donc pas de point-virgule après la dernière instruction, pas plus qu'il n'y en a avant la première. Cela explique également pourquoi lorsqu'on écrit une seule instruction, elle n'est pas suivie d'un point-virgule.

Il est souvent affirmé à tort que « toutes les instructions se terminent par un point-virgule ». Ce n'est pas tout à fait vrai, comme nous venons de le voir. Cependant, cette croyance répandue a été prise en considération par les développeurs des compilateurs qui ignorent cette erreur.

Il convient de remarquer que le programme principal est un bloc d'instructions ponctué d'un point, ni plus ni moins.

Lecture et Écriture (affichage)

L'affichage s'effectue à l'aide de la procédure write. Elle peut prendre de un à plusieurs paramètres de n'importe quel type de base. Elle affiche tous les paramètres les uns après les autres (résultat identique à celui d'une concaténation).

Il existe une variante de write ayant la même spécification mais effectuant un retour à la ligne à la fin : il s'agit de la procédure writeln. On peut également appeler la procédure writln sans préciser de paramètres, cela effectue un retour à la ligne.

La lecture se fait à l'aide de la fonction read() qui prend en paramètre l'identifiant de la variable qui sera assignée.

readln est indentique à read() mais fait un retour à la ligne une fois la donnée lue.

Exemple

begin
  write('abc');
  write('def');
end

affiche

abcdef

alors que

begin
  writeln('abc');
  write('def');
end

affiche

abc
def

Assignation

L'assignation est une instruction et à ce titre elle doit respecter les règles sur les instructions (points-virgules...)

L'opérateur d'assignation est := (et non = qui est le test d'égalité)

La syntaxe de l'assignation est (espaces facultatifs) :

identifiant := expression

Il va sans dire que le type de l'expression doit être compatible avec celui de la variable assignée.

Exécution conditionnelle

On rappelle qu'une exécution conditionnelle est une instruction. Elle ne comporte pas de point-virgule sauf si elle est à l'intérieur d'un bloc. On suppose ici que l'instruction est au sein d'un bloc.

si condition alors instruction

donne

if condition then instruction;

si il y a plusieurs instructions, et bien on utilise un bloc :

if condition then begin
  instruction_1;
  instruction_2;
  instruction_k;
end;

if condition
  alors instruction_1
  sinon instruction_2

se traduit

if condtion
  then instruction_1
  else instruction_2;

De même on peut utiliser des blocs :

if condition then begin
  instruction_1;
  instruction_2;
  instruction_k;
  end
else begin
  instruction_3;
  instruction_4;
  instruction_l;
end;

Structures itératives

POUR i de deb à fin faire instruction

donne

for i:=deb to fin do instruction;

on peut toujours utiliser un bloc comme instruction

for i:=deb to fin do begin
  instruction_1;
  instruction_2;
  instruction_k;
end;

De même,

repeat
  instruction
until condition;

while condition do
  instruction
end;

Tableaux

lexique
  tab : tableau de deb à fin de T

donne :

var
  tab : array [deb..fin] of T;

Par exemple

  tab : array [1..10] of integer;

Procédures et fonctions

Le type enregistrement

type T = enregistrement
  champ : type_champ
fin

donne

type T = record
  champ : type;
end;