FAQ PascalConsultez toutes les FAQ

Il existe plusieurs manières d'effectuer une pause dans un programme.

La plus simple consiste à demander à l'utilisateur d'appuyer sur une touche. Si on désire simplement un appui sur Entrée, on utilisera l'instruction ReadLn :

1
2
3
4
5
6
7
  
Begin 
  ... 
  Write('Appuyez sur Entrée : '); 
  ReadLn; 
  ... 
End;

1
2
3
4
5
6
7
8
9
10
  
Uses 
  Crt; 
Var 
  Ch: Char; 
Begin 
  ... 
  Ch := ReadKey; 
  ... 
End;

1
2
3
4
5
6
7
8
9
  
Uses 
  Crt; 
Begin 
  ... 
  { Attend 5 secondes, soit 5000 millisecondes } 
  Delay(5000); 
  ... 
End.

Il est souvent nécessaire de savoir détecter les erreurs que votre programme est susceptible de produire, notamment suite à une entrée imprévue par l'utilisateur.

Les erreurs les plus simples à détecter sont les erreurs d'entrée/sortie (E/S). Afin de détecter de telles erreurs, on se sert de la directive $I et de la fonction IOResult, qui renvoie le dernier code d'erreur obtenu, une valeur nulle signifiant une absence d'erreur. Il est très courant d'avoir recours à $I et de tester IOResult après chaque appel de procédure de gestion de fichiers. Mais on peut également s'en servir avec une lecture de variable au moyen de ReadLn.

• Erreurs de lecture/écriture de fichiers 
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
  
Var 
  f : Text; 
Begin 
  ... 
  {$I-}    { On désactive les erreurs } 
  
  { On ouvre un fichier et on le referme } 
  Assign(f,'FICHIER.TXT');   
  Reset(f); 
  
  {$I+}    { On réactive les erreurs }   
  
  { Si une erreur s'est produite, on affiche un message } 
  if IOResult <> 0 then 
    begin 
      WriteLn('Le fichier n''a pas pu être ouvert !'); 
      WriteLn('Appuyez sur Entrée.'); 
      ReadLn; 
    end; 
  ... 
End.

• Lecture d'une variable au clavier 
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
  
Var 
  i : Integer; 
Begin 
  ... 
  {$I-}    { On désactive les erreurs d'E/S } 
  
  { On va répéter la phase d'entrée tant qu'un nombre ne sera pas entré... } 
  repeat 
    Write('Entrez un entier : '); 
    ReadLn(i); 
  until IOResult = 0; 
  
  {$I+}    { On réactive les erreurs } 
  ... 
End.

Il est très courant qu'un programme attende des paramètres, qui lui sont transmis par la ligne de commande. Par exemple, un programme CopieFic qui attend comme paramètres le nom du fichier source et le dossier de destination : CopieFic C:\Temp\Fichier1.txt D:\.

Tout d'abord, pour tester le nombre de paramètres passés au programme, il faut se servir de la fonction ParamCount : Word;. Ensuite, la fonction ParamStr (i : Integer) : String;, renvoie le i-ème paramètre sur la ligne de commande.

Remarques

• Tous les paramètres sont des chaînes de caractères ; aussi, il faudra peut-être avoir recours à des fonctions de conversion si les paramètres attendus sont numériques.
• Deux paramètres sont séparés par au moins un espace. Par conséquent, en appelant un programme avec TEST Ceci est un test, alors il sera compté 4 paramètres : Ceci, est, un et test.
  

1
2
3
4
5
6
7
8
9
10
  
Program Exemple; 
  
Var 
  i : Integer; 
  
Begin 
  for i := 1 to ParamCount do 
    WriteLn(ParamStr(i)); 
End.

Il peut parfois être utile de connaître le nom de l'EXE correspondant à votre application. Celui-ci est stocké avec les paramètres de la ligne de commande, et possède l'indice 0. On peut le récupérer avec la fonction ParamStr :

1
2
3
4
5
6
  
Begin 
  ... 
  WriteLn('Nom de l''application : ',ParamStr(0)); 
  ... 
End;

Par défaut, il est possible de quitter une application console en appuyant sur les touches Ctrl+C ou Ctrl+Break (la touche Break est aussi notée Pause). Il peut dans certains cas être intéressant de désactiver cette fonctionnalité.
Le rôle de ces touches est défini à l'aide de la variable CheckBreak présente dans l'unité Crt.

1
2
3
4
5
6
7
8
  
Uses 
  Crt; 
  
Begin 
  { Désactive la capture de la touche Break par TP } 
  CheckBreak := False; 
  ...

1
2
3
4
5
6
7
8
9
10
11
12
13
  
Uses 
  Crt; 
  
Begin 
  ... 
  case ReadKey of 
  #3 : begin 
         WriteLn('Ctrl+Break pressé !'); 
       end; 
  end; 
  ... 
End.

• Il est possible de passer par une redéfinition des interruptions au lieu de se servir de l'unité Crt.
• Il ne faut pas confondre la désactivation de Ctrl+Break à l'intérieur d'un programme Pascal et la désactivation pour les opérations d'I/O, contrôlées à l'aide de SetCBreak dans l'unité Dos.
  

Pour basculer votre application mode texte en 80x50, il faut utiliser la procédure TextMode de l'unité Crt avec l'attribut Font8x8, comme ceci :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  
Uses 
  Crt; 
  
Var  
  AncienMode : Integer; 
  
Begin 
  AncienMode := LastMode; 
  Write('Pressez Enter pour passer en 80x50 : '); 
  ReadLn; 
  TextMode(CO80 or Font8x8); 
  Write('Pressez Enter pour repasser en 80x25 : '); 
  ReadLn; 
  TextMode(AncienMode); 
  Write('Pressez Enter pour quitter : '); 
  ReadLn; 
End.