FAQ PascalConsultez toutes les FAQ

Turbo Pascal, dans sa version gratuite, n'est pas en mesure de créer des applications Windows.

Pour créer des applications Windows, vous avez le choix entre :

• pour des programmes Win16 :
  
  - Turbo Pascal pour Windows (*),
  - Borland Pascal (*),
  - Delphi 1 (*) ;
• pour des programmes Win32 :
  
  - Turbo Delphi,
  - Delphi 2 à 5 (*),
  - Delphi 6, 7 et 2005,
  - Free Pascal,
  - Virtual Pascal,
  - GNU Pascal,
  - Lazarus,
  - TMT Pascal,
  - ...
• pour des programmes .NET :
  
  - Turbo Delphi for .NET,
  - Delphi 8 (*),
  - Delphi 2005.

Les directives de compilation sont des options que vous définissez uniquement pour votre programme ou pour une partie de votre programme. Elles sont l'équivalent des panneaux sur le bord des routes, qui vous aident à vous diriger : les directives de compilation aident le compilateur et l'éditeur de liens à se diriger dans votre programme suivant vos souhaits.
Vous reconnaîtrez aisément une directive de compilation : comme les commentaires, elles sont écrites soit entre accolades { } soit entre couples « parenthèse étoile » (* *). Toutefois, contrairement aux commentaires, elles commencent toujours par un signe dollar $.
Attention ! Vous ne devez pas mettre d'espace entre l'accolade et le dollar, sans quoi votre directive de compilation sera prise pour un simple commentaire.

• Directives à bascule
  

• Directives paramètres
  

• Directives conditionnelles
  

1
2
3
4
5
6
7
8
9
10
  
{$DEFINE Compile} 
  
{$IFDEF Compile} 
  Const                           { Ce code sera compilé } 
    Etat = 'Compilé !'; 
{$ELSE} 
  Const                           { Celui-ci ne le sera pas } 
    Etat = 'Pas compilé !'; 
{$ENDIF}

Si l'on écrit tout en bas à droite de l'écran, celui-ci défile automatiquement. Ce peut être très gênant si on désire simplement afficher un cadre ou une barre d'état.

Il existe deux manières de parer à ce problème.

• Utiliser l'unité Crt
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
  
Uses 
  Crt; 
  
Procedure WriteCorner (Ch : Char); 
Var 
  X, Y : Byte; 
Begin 
  { On sauve la position actuelle du curseur } 
  X := WhereX; 
  Y := WhereY; 
  { On agrandit "virtuellement" la fenêtre } 
  Inc(WindMax); 
  GotoXY(Lo(WindMax) - 1, Hi(WindMax)); 
  Write(Ch); 
  Dec(WindMax); 
  { On se replace à la position de départ } 
  GotoXY(X, Y); 
End;

• Écrire directement en mémoire vidéo
  

1
2
3
4
5
6
7
8
  
Type 
  TTextScreen = Array [1..25, 1..80] of Record 
    Ch : Char; 
    Color : Byte; 
  end; 
Var 
  TextScreen : TTextScreen absolute $B800:$0000;

1
2
3
4
5
6
  
Procedure WriteChar (X, Y : Byte; Ch : Char; FgColor, BkColor : Byte); 
Begin 
  TextScreen[Y, X].Ch := Ch; 
  TextScreen[Y, X].Color := (BkColor shl 4) or (FgColor and 15); 
End;

Les touches de direction et les touches de fonction font partie des touches dites étendues du clavier. Contrairement aux autres, elles renvoient un double code ASCII : d'abord le code #0 puis le code de la touche. Ainsi, pour savoir si une touche de direction a été pressée, il suffit de vérifier avec ReadKey, de l'unité Crt, si on obtient le code #0, et le cas échéant faire un second appel à ReadKey pour connaître le code de la touche.

Les touches étendues accessibles avec ReadKey sont :

• les flèches ;
• les touches de fonction F1 à F10 ;
• les touches de déplacement (origine, fin, page haut, page bas, haut, bas, gauche, droite) ;
• les touches Suppr et Inser.
  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
  
Program Fleches; 
Uses 
  Crt; 
  
Var 
  Ch : Char; 
  
Begin 
  repeat 
    Ch := ReadKey; 
    case Ch of 
    #0: case ReadKey of    { Le code est #0, on appelle à nouveau ReadKey } 
        #72: WriteLn('Haut'); 
        #80: WriteLn('Bas'); 
        #75: WriteLn('Gauche'); 
        #77: WriteLn('Droite'); 
        end; 
    end; 
  until Ch = #27;    { On quitte avec Echap } 
End.

• Il existe d'autres touches étendues, mais non accessibles avec ReadKey : les touches de contrôle (Ctrl, Alt, Maj) ou bien les touches système (Impr Ecran, Arrêt Défil, Pause). Pour celles-ci, il faut utiliser une autre méthode.
• Les touches F11 et F12 sont à part. Cela vient du fait qu'elles sont apparues sur les claviers bien après les autres. Pour les détecter, il est nécessaire de reprogrammer l'interruption clavier $9.
  

Parfois, lorsqu'un programme attend une réponse au clavier par l'utilisateur, il est crucial d'être certain qu'aucune touche pressée auparavant ne soit prise en compte. Cela peut arriver, par exemple, lorsqu'un programme exécute une opération longue et que l'utilisateur appuie sur les touches du clavier.

Il faut alors vider le tampon (le buffer) du clavier. Voici trois méthodes.

• Utiliser les procédures standard du Pascal
  
  On se servira de l'unité Crt et de KeyPressed et ReadKey, comme ceci :
  

1
2
3
4
5
6
7
8
9
10
11
  
Uses 
  Crt; 
  
Procedure ClearKbdBuffer; 
Var 
  Ch : Char; 
Begin 
  while KeyPressed do 
    Ch := ReadKey; 
End;

• Utiliser les variables internes du clavier :
  
  En plus du tampon, le clavier dispose d'autres variables en mémoire. Parmi celles-ci, on trouve la position de la prochaine touche à lire dans le tampon ainsi que la position du premier emplacement libre dans le tampon. Pour vider le tampon, il suffit d'indiquer au clavier que la prochaine touche à lire est un emplacement libre.
  La position de la prochaine touche à lire se trouve à l'adresse 0040:001A et celle du prochain emplacement libre à 0040:001C (ce sont deux Word). D'où le code :
  

1
2
3
4
5
  
Procedure ClearKbdBuffer; 
Begin 
  MemW[Seg0040:$001A] := MemW[Seg0040:$001C]; 
End;

• Faire appel à la fonction 0Ch de l'interruption 21h
  
  Cette fonction vide en effet le buffer clavier.
  

1
2
3
4
5
6
7
8
9
10
11
  
Uses 
  Dos; 
  
Procedure ClearKbdBuffer; 
Var 
  Regs : Registers; 
Begin 
  Regs.ax := $0C00; 
  MsDos(Regs); 
End;

Pour imprimer du texte très facilement, on peut se servir de l'unité Printer qui définit le périphérique de sortie Lst, à utiliser comme n'importe quel autre fichier avec Write/WriteLn :

1
2
3
4
5
6
7
8
  
Uses 
  Printer; 
Begin 
  ... 
  WriteLn(Lst,'Ceci va sortir sur l''imprimante !'); 
  ... 
End.

Pour imprimer du texte mis en forme, il est nécessaire de faire appel aux codes d'échappement des imprimantes.
Ceci consiste à envoyer des codes à l'imprimante, codes commençant par le caractère #27 (ECHAP, d'où leur nom de codes d'échappement), lui indiquant comment le texte à imprimer doit être mis en forme.

Ceci serait d'une extrême simplicité si les codes ne différaient pas suivant la marque de l'imprimante ! Heureusement, les imprimantes actuelles tendent à être compatibles avec les standards des années 80 concernant leurs codes d'échappement, à savoir les imprimantes Epson, PostScript ou encore Hewlett-Packard.

Afin d'en apprendre plus, reportez-vous au code source PRNFLTR.PAS fourni avec Turbo Pascal 7 dans le répertoire \BIN. Ceux qui ne l'auraient pas le trouveront en téléchargement ci-dessous.

Voici quelques exemples de codes d'échappement reconnus sur la plupart des imprimantes :

Turbo Pascal seul n'est pas très évolué du côté du son. Il vous permet seulement d'émettre un son depuis le haut-parleur interne du PC, à une fréquence donnée. Aucune unité n'est fournie pour gérer une quelconque carte son.

Pour émettre un son, utilisez la procédure Sound (Freq : Word) de l'unité Crt, où Freq représente la fréquence du son à émettre.
Attention toutefois : le son ne s'arrête pas de lui-même ! Et ce, même après la fin de votre programme... Pour stopper le son, vous devrez appeler la procédure NoSound. Il est à noter que si vous appelez deux fois de suite Sound avec deux fréquences différentes, alors le deuxième appel annule le premier et la nouvelle fréquence est émise en continu.

Bien entendu, il est nécessaire d'introduire une temporisation lors de l'émission d'un bip par le haut-parleur, car sinon, sitôt le bip émis, celui-ci serait coupé par NoSound. On préfèrera généralement l'utilisation de Delay (Ms : Word) où Ms est le nombre de millisecondes à attendre, indépendante du PC, à une boucle de temporisation, dont la durée varie en fonction de l'ordinateur utilisé.

1
2
3
4
5
6
7
8
  
Uses 
  Crt; 
begin 
  Sound(2000); 
  Delay(1000);    { On attend une seconde } 
  NoSound; 
End.

• Il peut être utile de créer un petit programme ne contenant que l'instruction NoSound. En effet, à supposer que votre programme plante alors qu'un son est en train d'être émis par le haut-parleur, alors celui-ci ne s'arrêtera pas ! Le recours à ce programme pourrait ainsi épargner vos oreilles...
• L'oreille humaine n'est capable d'entendre des sons que dans une certaine plage de fréquences allant grossièrement de 100 Hz à 200 kHz. Inutile de tenter des fréquences allant au-delà de ces limites. De plus, le haut-parleur est lui-même bridé : en deçà ou au-delà d'une certaine fréquence, aucun son n'est émis.
  

Si vous désirez effectuer quelques tracés sans grande prétention, alors la BGI (Borland Graphics Interface) est faite pour vous ! La BGI est le système graphique fourni avec Turbo Pascal. Capable de fonctionner avec de vieux systèmes, on retiendra surtout la possibilité d'effectuer des tracés dans un mode 640x480 en 16 couleurs (VGA), et ce de manière aisée.

Pour vous servir de la BGI, vous devez d'une part utiliser l'unité Graph, et d'autre part avoir à disposition les pilotes de la BGI. En règle générale, seul EGAVGA.BGI suffit. À ceci vous devrez ajouter les éventuelles polices de caractères si vous désirez écrire du texte à l'écran. Chaque police porte l'extension .CHR. Rassurez-vous toutefois : tous ces fichiers sont fournis avec Turbo Pascal et doivent avoir été installés avec le reste. Ils se trouvent dans le répertoire \TP7\BGI.

Pour initialiser un mode graphique, il faut vous servir de InitGraph (var GraphDriver, GraphMode : Integer; Path : String). GraphDriver et GraphMode sont des variables qu'il faut déclarer. Elles vont caractériser le mode graphique utilisé. La plupart du temps, on laissera Turbo Pascal détecter tout seul le mode graphique le plus adapté à votre configuration. Pour cela, il suffit d'affecter la valeur Detect à GraphDriver, sans toucher à GraphMode :

1
2
3
4
5
6
7
  
Var 
  GraphDriver, GraphMode : Integer; 
  
Begin 
  GraphDriver := Detect; 
  ...

1
2
3
4
5
6
7
8
  
Var 
  GraphDriver, GraphMode : Integer; 
  
Begin 
  GraphDriver := VGA;  { On utilise le pilote VGA } 
  GraphMode := VGAHi;  { On choisit le mode haute résolution (640x480 16 couleurs) } 
  ...

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
  
Uses 
  Graph; 
  
Var 
  Gd, Gm : Integer; 
  
Begin 
  Gd := Detect; 
  InitGraph(Gd,Gm,'C:\TP7\BGI'); 
  if GraphResult <> grOk then 
  begin 
    WriteLn(GraphErrorMsg(GraphResult); 
    WriteLn; 
    Halt; 
  end; 
  ... 
  CloseGraph; 
End.

Il peut parfois être nécessaire, au sein d'un programme Pascal, d'appeler un programme externe. Par exemple, on peut vouloir lancer l'interpréteur de commandes MS-DOS, COMMAND.COM. Pour ce faire, il faut avoir recours à la procédure Exec (Programme,Parametres), présente dans l'unité Dos (qu'il faudra ajouter à votre clause uses).

Pour commencer, votre programme peut définir ses propres vecteurs d'interruption. De fait, en exécutant un programme externe, vous prenez le risque de corrompre ces vecteurs d'interruption. Pour vous prémunir de ceci, il vous suffit d'appeler la procédure SwapVectors avant et après l'appel de Exec. Cette procédure va se charger d'échanger les vecteurs d'interruption par défaut et les vôtres :

1
2
3
4
  
SwapVectors; 
Exec('COMMAND.COM',''); 
SwapVectors;

1
2
3
4
5
6
7
8
9
10
11
  
Program Exemple; 
{$M 16384,0,204800} 
  
Begin 
  ... 
  SwapVectors; 
  Exec('COMMAND.COM','') ; 
  SwapVectors; 
  ... 
End.

1
2
3
4
5
6
7
  
... 
SwapVectors; 
Exec('COMMAND.COM',''); 
SwapVectors; 
if DosError <> 0 then ... 
...

• Remarque
  

1
2
  
Exec(GetEnv('COMSPEC'),'');

Pour modifier l'apparence du curseur texte, il faut faire appel à la fonction 01h de l'interruption 10h :

1
2
3
4
5
6
7
8
9
10
11
  
Uses 
  Dos; 
Var 
  Regs : Registers; 
Begin 
  Regs.ax := $0100;   { Fonction 01h } 
  Regs.cl := $20;     { Ligne de départ (0 à 31, 32 éteint) }    
  Regs.ch := $20;     { Ligne de fin (0 à 31, 32 éteint) } 
  Intr($10, Regs);    { Appel de l'interruption } 
End;