FAQ PascalConsultez toutes les FAQ

Un mot réservé fait partie intégrante de la syntaxe du langage Pascal ou est une instruction spécifique au langage. Il est interdit d'utiliser un mot réservé comme nom de variable, de procédure ou de type. Vous pouvez reconnaître aisément les mots réservés dans la plupart des EDI : par défaut, ils apparaissent en contraste ou en gras.
Les principaux mots réservés du Pascal sont : begin, end, if, then, else, for, to, do, while, repeat, until, and, or, not, const, type, var, string, etc.

Les types scalaires (ordinal types en anglais) sont une catégorie de types qui définissent des ensembles de valeurs ordonnées, à l'exception des types réels (qui forment une classe à part). Pour essayer d'être plus clair, on les appelle ainsi parce qu'on peut déterminer leur rang, qui est leur valeur entière.

Les types scalaires du Pascal sont les suivants :

• Char
• Boolean
• LongBool (Free Pascal, Virtual Pascal, Delphi)
• ShortInt
• Byte
• Integer
• SmallInt (Free Pascal, Virtual Pascal, Delphi)
• Word
• LongInt
• LongWord (Free Pascal, Delphi)
• Cardinal (Free Pascal, Virtual Pascal, Delphi)
• Int64 (Delphi uniquement - voir remarque ci-dessous)
• Type énuméré
• Intervalle
  

Un type structuré est un type qui comporte plus d'un élément dans sa déclaration.

Les types structurés possibles dans le langage Pascal sont les suivants :

• Array (tableau)
• Set (ensemble)
• File (fichier)
• Record (enregistrement)
• Object (objet)
• Class (classe - Free Pascal, Virtual Pascal, Delphi)
• Interface (interface - Free Pascal, Delphi)
  

La directive packed peut préfixer n'importe quel type structuré (array, record, set...). Héritage des machines des années '70, elle provoquait un stockage plus compact des types structurés.
Toutes les versions du compilateur Turbo Pascal ignorent carrément cette directive car tous les types structurés sont automatiquement compactés. Les compilateurs Free Pascal, Virtual Pascal et Delphi, par contre, utilisent un alignement par défaut du contenu des types structurés sur 32 bits. La directive packed compacte le contenu sans tenir compte de cet alignement par défaut.

Le transtypage (typecast en anglais) est une technique permettant de demander au compilateur de considérer une variable d'un certain type comme étant d'un autre type. Il est primordial que les deux types aient la même taille, sans quoi une erreur de compilation sera déclenchée.

Voici un exemple simple : incrémenter une variable de type caractère (pour transformer un 'A' en 'B'). La 1ère version ne fonctionne pas mais la seconde oui, grâce au transtypage du caractère en byte (les types char et byte sont de même taille) :

1
2
3
4
5
6
  
Var x : Char; 
Begin 
  x := 'a'; 
  x := x + 1;   { Déclenche une erreur de compilation } 
End;

1
2
3
4
5
6
  
Var x : Char; 
Begin 
  x := 'a'; 
  Byte(x) := Byte(x) + 1;   { x contient 'B' } 
End;

1
2
3
4
5
6
7
8
9
10
11
12
13
  
Type Tab = Array [1..4] of Byte; 
     Rec = Record 
             w1, w2 : Word; 
           end; 
  
Var r : Rec; 
  
Begin 
  r.w1 := $0102; 
  r.w2 := $FEFF; 
  WriteLn(Tab(r)[1]);   { Affiche '2' } 
End;

• Tableaux
  

1
2
3
4
  
Type tTabCoord = Array [1..2,1..3] of Integer; 
  
Const Coordonnees : tTabCoord = ((0,0,24),(0,48,12));

• Enregistrements ou objets
  

1
2
3
4
5
6
7
  
Type tRecCoord = Record 
                   Nom : String [25]; 
                   x, y : Integer; 
                 end; 
  
Const Coordonnees : tRecCoord = (Nom : 'Vaisseau alien'; x : 100; y : 25);

Les procédures et les fonctions permettent toutes deux de regrouper plusieurs instructions se répétant dans un programme , pour éviter d'avoir à réécrire un même code plusieurs fois. Elles permettent aussi d'automatiser des tâches, et surtout de clarifier et donc simplifier votre code.
Mais les fonctions font une chose que les procédures ne font pas : elles renvoient un résultat.

Prenons deux exemples. Si vous voulez calculer la somme de deux nombres, vous attendez un résultat : vous utiliserez une fonction. Si vous voulez effacer l'écran, vous attendez seulement que l'écran soit effacé, donc pas de résultat concret à traiter : vous utiliserez plutôt une procédure.

1
2
3
  
Function Exemple1 : Integer;  { On renvoie un résultat de type Integer } 
Procedure Exemple2;           { On ne renvoie aucun résultat }

Lorsque deux procédures doivent s'appeler mutuellement, il faut choisir dans quel ordre les déclarer.
A supposer que la procédure Proc1 doive appeler la procédure Proc2 et réciproquement, doit-on délarer Proc1 avant Proc2 ou bien l'inverse ?
Il suffit de faire l'essai pour se rendre compte qu'aucune des deux versions ne fonctionnera. Ainsi, le code suivant provoquera une erreur à la compilation :

1
2
3
4
5
6
7
8
9
10
  
Procedure Proc1 (n : Integer); 
Begin 
  if n > 0 then Proc2(n - 1); 
End; 
  
Procedure Proc2 (n : Integer); 
Begin 
  if n > 0 then Proc1(n - 1); 
End;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
  
{ On délare en tant que forward, comme on le ferait dans une unité - partie interface } 
Procedure Proc2 (n : Integer); forward; 
  
Procedure Proc1 (n : Integer); 
Begin 
  if n > 0 then Proc2(n - 1); 
End; 
  
{ On complète la déclaration, comme on le ferait dans une unité - partie implementation } 
Procedure Proc2 (n : Integer); 
Begin 
  if n > 0 then Proc1(n - 1); 
End;

Il est tout-à-fait possible de faire en sorte qu'une unité U1 fasse appel à des routines de l'unité U2 et que cette dernière fasse appel à des routines de l'unité U1. Le tout est d'éviter l'erreur de compilation 68 "circular unit reference".
Pour ce faire, il faut tout simplement que la clause uses d'une des deux unités ne se trouve pas dans la partie interface de l'unité, mais bien dans la partie implémentation.

Exemple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  
Unit U1; 
  
Interface 
  
Procedure Proc1; 
  
Implementation 
  
Uses U2; 
  
Procedure Proc1; 
Begin 
  Proc2; 
  WriteLn('Proc 1'); 
End; 
  
End.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
  
Unit U2; 
  
Interface 
  
Uses U1; 
  
Procedure Proc2; 
Procedure Proc3; 
  
Implementation 
  
Procedure Proc2; 
Begin 
  WriteLn('Proc 2'); 
End; 
  
Procedure Proc3; 
Begin 
  Proc1; 
  WriteLn('Proc 3'); 
End; 
  
End.

1
2
3
4
5
6
7
8
9
10
  
Program UX; 
  
Uses WinCRT, U1, U2; 
  
Begin 
  Proc1; 
  Proc2; 
  Proc3; 
End.

Il existe quatre modes de transmission d'un paramètre à une procédure ou fonction. Un exemple concret permettra de mieux les comprendre :

1
2
  
Procedure MaProc (a : Integer; var b : Integer, const c : Integer; out d : Integer);

• Le paramètre a est transmis par valeur : sa valeur est déposée sur la pile pour être utilisée dans la procédure. Même si la valeur de a est modifiée à l'intérieur de la procédure, elle restera inchangée pour le programme appelant.
• Le paramètre b est transmis par adresse : c'est non pas sa valeur mais son adresse qui est déposée sur la pile de sorte que, si sa valeur est modifiée au sein de la procédure, elle est également modifiée pour le programme appelant.
• Le paramètre c est transmis comme constante : si sa taille est inférieure ou égale à la taille d'un pointeur, il est transmis par valeur; sinon, il est transmis par adresse. Dans l'exemple, c est de type entier, donc sa taille égale celle d'un pointeur : c est donc transmis par valeur. La valeur d'un paramètre transmis comme constante ne peut être modifiée au sein de la procédure ou fonction.
• Le paramètre d est transmis comme output : il est en fait transmis par adresse mais sa valeur initiale est ignorée par la procédure. Par contre, s'il reçoit une valeur au sein de la procédure, elle sera prise en compte par le programme appelant.
  

Il arrive que le compilateur transforme une transmission par valeur d'un paramètre à une procédure ou fonction en transmission par adresse.

Free Pascal, Virtual Pascal, Delphi :

• Entiers sur 1 octet : dépôt sur la pile d'un double-mot (octet de poids faible du double-mot);
• Entiers sur 2 octets : dépôt sur la pile d'un double-mot (mot de poids faible du double-mot);
• Entiers sur 4 octets : dépôt sur la pile d'un double-mot;
• Entiers sur 8 octets : dépôt sur la pile de 2 doubles-mots;
• Char : dépôt d'un double-mot sur la pile (le caractère étant l'octet de poids faible);
• Boolean : dépôt d'un double-mot sur la pile (le booléen étant l'octet de poids faible);
• LongBool : dépôt d'un double-mot sur la pile;
• Enuméré : dépôt d'un double-mot sur la pile (octet de poids faible si maximum 256 valeurs);
• Single : dépôt d'un double-mot sur la pile;
• Real, double, comp : dépôt de 2 doubles-mots sur la pile;
• Extended : dépôt de 3 doubles-mots sur la pile (les 10 octets de poids faible);
• Pointeurs : dépôt d'un double mot (offset);
• String : dépôt de l'adresse de la chaîne (donc, d'un pointeur);
• Set : dépôt de l'adresse (pointeur);
• Array : dépôt sur la pile si taille <= 8 octets. Sinon dépôt de l'adresse;
• Record : dépôt sur la pile si taille <= 8 octets. Sinon dépôt de l'adresse.
  

• Entiers : dépôt sur la pile d'un ou 2 mots (entier sur 1 octet : octet de poids faible du mot déposé);
• Char : dépôt d'un mot sur la pile (le caractère étant l'octet de poids faible);
• Boolean : dépôt d'un mot sur la pile (le booléen étant l'octet de poids faible);
• Enuméré : dépôt d'un mot sur la pile (octet de poids faible si maximum 256 valeurs);
• Real : dépôt de 6 octets sur la pile;
• Single, double, extended, comp : chargement dans la pile du coprocesseur;
• Pointeurs : dépôt d'un double mot (segment puis offset);
• String : dépôt de l'adresse de la chaîne (donc, d'un pointeur);
• Set : dépôt de l'adresse (pointeur);
• Array : dépôt sur la pile si taille <= 4 octets. Sinon dépôt de l'adresse;
• Record : dépôt sur la pile si taille <= 4 octets. Sinon dépôt de l'adresse.
  

Lorsque c'est possible, il faut privilégier le mode de transmission d'un paramètre à une procédure ou à une fonction comme constante plutôt que par valeur. Ce principe est surtout valable pour des types de grande taille.

Pourquoi ?
Lorsqu'un paramètre est transmis par valeur, le compilateur réserve dans la pile un espace de la taille du paramètre et réalise une copie de celui-ci. Tandis que, lorsque le paramètre est transmis comme constante, seule son adresse est déposée sur la pile, exactement comme lors d'une transmission par adresse.

La réponse dépend du compilateur utilisé : alors que Free Pascal et Virtual Pascal permettent sans problème à une fonction de retourner un résultat de type structuré (un record, par exemple), Turbo Pascal ne peut retourner qu'un type simple.
Pour contourner cette limitation, dans un programme Turbo Pascal, on utilisera un paramètre par adresse.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
  
Var Date : tDateTime; 
  
Function DATE_DU_JOUR : tDateTime; 
Var JourSemaine : Word; 
Begin 
  GetDate(Result.Year,Result.Month,Result.Day,JourSemaine); 
End; 
  
Begin 
  Date := DATE_DU_JOUR; 
  WriteLn(Date.Day,'-',Date.Month,'-',Date.Year); 
  ReadLn; 
End.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
  
Var Date : tDateTime; 
  
Procedure DATE_DU_JOUR (var Result : tDateTime); 
Var JourSemaine : Word; 
Begin 
  GetDate(Result.Year,Result.Month,Result.Day,JourSemaine); 
End; 
  
Begin 
  DATE_DU_JOUR(Date); 
  WriteLn(Date.Day,'-',Date.Month,'-',Date.Year); 
  ReadLn; 
End.

Une imbrication de blocs de cette forme :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  
if X = A  
   then  
     DoA 
   else  
     if X = B  
        then  
          DoB 
        else  
          if X = C  
             then  
               DoC 
             else  
               if X = D  
                  then  
                    DoD 
                  else  
                    DoE;

1
2
3
4
5
6
7
8
9
  
case X of 
  A : DoA; 
  B : DoB; 
  C : DoC; 
  D : DoD: 
else 
  DoE;   
end;

L'absence de point-virgule juste avant un end est définie dans la syntaxe standard du Pascal. Par exemple :

1
2
3
4
  
  ... 
  i := 2 
end;

Bien qu'elle soit conspuée dans toutes les écoles de programmation (du moins, dans les cours utilisant le Pascal), l'instruction goto existe depuis les débuts du Pascal et est rencontrée de loin en loin. Son impopularité vient du fait qu'elle est souvent considérée comme un échec de logique dans la conception d'un programme. Sans prendre parti, voici son fonctionnement.

Très important : une instruction goto ne peut référencer un label situé en dehors du même bloc de code.
Grâce à une directive label, souvent située au début du source, on déclare les labels utilisés dans le programme (s'il y en a plusieurs, ils seront séparés par des virgules). Un label peut être un identificateur ou une constante numérique. A l'intérieur du code, le label est inséré avant une instruction. Il est suivi de deux points (:), comme en Assembleur.
Exemple :

1
2
3
4
5
6
7
8
9
10
11
12
  
Program TestGoto; 
  
Label Fin; 
  
Begin 
  ... 
  goto Fin; 
  ... 
Fin: 
  Halt(0); 
End;

Il peut être bien pratique d'indiquer au compilateur qu'il doit, sous certaines conditions, compiler ou pas certaines parties du source. On peut soit définir soi-même des symboles et tester leur existence durant le processus de compilation, soit utiliser des symboles prédéfinis.

Symboles

Pour définir soi-même un symbole, on utilise la directive {$DEFINE} :

1
2
  
{$DEFINE MaCondition}

1
2
3
4
5
6
  
{$DEFINE MaCondition} 
  
... 
  
{$UNDEF MaCondition}

1
2
3
4
5
6
  
{$IFDEF MaCondition} 
... 
{$ELSE} 
... 
{$ENDIF}

1
2
3
4
  
{$IFNDEF MaCondition} 
... 
{$ENDIF}

1
2
3
4
  
{$IFOPT I+} 
... 
{$ENDIF}

L'Assembleur est le langage de programmation le plus proche de la machine qui puisse être compris relativement simplement par l'homme. Contrairement au Pascal, qui appartient aux langages dits de "haut niveau", l'Assembleur est un langage de "bas niveau".
Relativement obscur pour les néophytes, l'Assembleur est néanmoins le seul outil existant pour pallier aux lacunes du Pascal. En effet, le Pascal, bien que très polyvalent, ne sait pas tout faire, et il est parfois nécessaire de faire appel à un langage plus spécialisé, tel l'Assembleur, pour accéder au coeur de la machine. Un bon exemple est l'inclusion d'instructions 32 bits dans un programme Turbo Pascal.
L'Assembleur peut aussi être utilisé dans les routines dites "critiques", autrement dit qui nécessitent des performances accrues.

Pour ajouter de l'assembleur dans votre programme, vous pouvez soit ajouter un bloc asm...end; soit créer une procédure en assembleur, en ajoutant la directive assembler à sa déclaration :

1
2
3
4
5
6
7
8
  
Begin 
  ... 
  asm 
    ... 
  end; 
  ... 
End;

1
2
3
4
5
  
Procedure TestAsm; assembler; 
asm 
  ... 
end;