FAQ PascalConsultez toutes les FAQ

Nombre d'auteurs : 9, nombre de questions : 348, dernière mise à jour : 17 janvier 2015  Ajouter une question

 

Bienvenue dans la F.A.Q. Pascal !

Celle-ci rassemble les réponses aux questions les plus fréquemment posées sur le langage Pascal et tous ses outils de programmation. Si elle n'a pas pour vocation de répondre à toutes les interrogations possibles, elle reste une bonne base de connaissances sur le Pascal, et ne demande qu'à être enrichie par vos expériences personnelles.

Nous vous invitons à proposer vos propres questions/réponses directement dans la FAQ ou, si vous souhaitez apporter une modification à une question/réponse existante, à la poster dans le fil de discussion renseigné ci-dessous.

Nous vous souhaitons une bonne lecture !

L'équipe Pascal.

Commentez


SommaireLes différents compilateursTurbo PascalTurbo Pascal Généralités (12)
précédent sommaire suivant
 

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 programmes suivis de (*) ne sont disponibles que sous licences disponibles auprès de leurs éditeurs, et donc payants. Les autres sont soit gratuits, soit disponibles dans une version gratuite ou bien personnelle (leur usage commercial est alors interdit).

Mis à jour le 23 mars 2004 Eric Sigoillot

Compilateurs et environnements de développement Pascal

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

Les directives à bascule activent ou désactivent des options du compilateur, selon le signe (+ ou -) qui suit le nom de la directive.
Voici les plus courantes :

Directive Usage
{$A+} {$A-} Alignement sur un word pour les variables et constantes typées - par défaut {$A+}
{$B+} {$B-} Force une évaluation booléenne complète (non optimisée) - par défaut {$B-}
{$F+} {$F-} Force un appel FAR (intersegment) - par défaut {$F-}
{$I+} {$I-} Provoque une erreur d'exécution en cas d'erreur d'entrée/sortie ({$I- permet d'intercepter l'erreur et d'utiliser IOResult) - par défaut {$I+}
{$Q+} {$Q-} Génère des tests de débordement (overflow) dans certaines fonctions arithmétiques entières - par défaut {$Q-}
{$R+} {$R-} Génère des tests de domaine de validité (longueurs de chaînes, intervalles) - par défaut {$R-}
{$S+} {$S-} Génère un contrôle de l'espace disponible dans la pile pour la réservation des variables locales - par défaut {$S+}
{$V+} {$V-} Effectue des contrôles sur la taille effective des chaînes de caractères - par défaut {$V+}
{$X+} {$X-} Active la syntaxe étendue (utilisation de fonctions comme procédures et de chaînes à zéro terminal comme strings) - par défaut {$X+}

  • Directives paramètres

Les directives paramètres servent à définir des paramètres qui influent sur la compilation.
En voici les principales :

Directive Usage
{$I CONST.INC} Indique l'usage d'un fichier include (CONST.INC)
{$L MESPROCS} Indique que l'éditeur de liens doit lier le fichier MESPROCS.OBJ
{$M 65520,0,655360} Spécifie les paramètres d'allocation mémoire (taille de la pile et du tas)
{$R RESSOURC} Indique qu'il faut insérer les ressources contenues dans le fichier RESSOURC.RES dans l'exécutable (uniquement BPW et TPW, pour Windows et DPMI)

  • Directives conditionnelles

Les directives conditionnelles permettent de définir des blocs de texte source, dont la compilation dépendra de certaines conditions.
Voici les plus courantes :

Directive Usage
{$DEFINE Condition} Émettre une condition
{$UNDEF Condition} Supprimer une condition
{$IFDEF Condition} Si Condition vérifiée alors compiler le bloc qui suit
{$IFNDEF Condition} Si Condition non vérifiée alors compiler le bloc qui suit
{$ELSE} Définit un bloc else après une condition {$IFDEF} ou {$IFNDEF}
{$ENDIF} Termine un bloc conditionnel {$IFDEF} ou {$IFNDEF}
{$IFOPT Directive_à_bascule} Si Directive_à_bascule dans l'état + ou - alors compiler le bloc qui suit
{$MSDOS} Si DOS mode réel alors compiler le bloc qui suit
{$DPMI} Si mode DOS protégé alors compiler le bloc qui suit
{$VER70} Si n° de version de Turbo Pascal = 7.0 alors compiler le bloc qui suit
Code delphi : Sélectionner tout
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}

Mis à jour le 3 janvier 2007 Alcatîz Eric Sigoillot

Type Intervalle Nombre d'octets
ShortInt -127 .. 128 1
Byte 0 .. 255 1
Integer -32 768 .. 32 767 2
Word 0 .. 65 535 2
LongInt -2 147 483 648 .. 2 147 483 647 4

Mis à jour le 10 janvier 2007 Alcatîz

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

L'unité Crt déclare plusieurs variables pour stocker la taille de l'écran : WindMin et WindMax, correspondant respectivement aux coins supérieur gauche et inférieur droit. Ce sont deux Words dont l'octet de poids faible correspond à la coordonnée X et l'octet de poids fort à la coordonnée Y.
Afin de « tromper » Crt, il suffit de lui faire croire que l'écran possède une colonne de plus, en incrémentant la valeur de WindMax :
Code delphi : Sélectionner tout
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

On peut écrire directement dans la mémoire vidéo à la position souhaitée. Il convient alors de connaître non seulement l'adresse exacte de la mémoire vidéo, à savoir B800:0000 pour un adaptateur couleur, mais aussi la structure de données attendue. On peut ainsi déclarer les éléments suivants, pour un écran de 80x25 :
Code delphi : Sélectionner tout
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;
Par la suite, il suffit d'écrire directement dans la variable TextScreen pour placer un caractère sur l'écran :
Code delphi : Sélectionner tout
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;

Mis à jour le 5 juin 2004 Eric Sigoillot

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.

Le tableau suivant recense les codes associés à ces touches étendues :
Touche Codes ASCII
F1 .. F10 #00, #59 .. #68
Origine (Home) #00, #71
Flèche haut #00, #72
Page haut #00, #73
Flèche gauche #00, #75
Flèche droite #00, #77
Fin (End) #00, #79
Flèche bas #00, #80
Page bas #00, #81
Inser (Ins) #00, #82
Suppr (Del) #00, #83

L'exemple suivant teste l'appui sur les touches de direction et affiche le résultat à l'écran. On quitte le programme en appuyant sur Echap (code #27) :

Code delphi : Sélectionner tout
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.
Remarques
  • 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.

Mis à jour le 29 mars 2004 Eric Sigoillot

Comment détecter l'appui sur les touches de contrôle ?
Comment détecter l'appui sur les touches F11 et F12 ?

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 :

Code delphi : Sélectionner tout
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 :

Code delphi : Sélectionner tout
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.

Code delphi : Sélectionner tout
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;

Mis à jour le 5 juin 2004 Eric Sigoillot

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 :

Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
  
Uses 
  Printer; 
Begin 
  ... 
  WriteLn(Lst,'Ceci va sortir sur l''imprimante !'); 
  ... 
End.
Seules les imprimantes parallèles sont supportées par Turbo Pascal. Il est très difficile pour ne pas dire impossible d'imprimer sur une imprimante USB. Pour y parvenir, il serait nécessaire de prendre en compte tout le protocole USB manuellement.

Mis à jour le 10 mai 2005 Eric Sigoillot

Comment imprimer du texte mis en forme ?
Est-il possible d'utiliser une imprimante USB ?

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 :

Codes d'échappement Effet Codes pour annuler
#27#45#1 Texte souligné #27#45#0
#27#52 Texte italique #27#53
#27#71 Texte gras (double frappe) #27#72
#27#83#0 Texte en exposant #27#84
#27#83#1 Texte en indice #27#84
#27#87#1 Texte en double largeur #27#87#0

Mis à jour le 10 mai 2005 Alcatîz Eric Sigoillot

Comment imprimer du texte ?
PRNFLTR.PAS

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)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é.

Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
  
Uses 
  Crt; 
begin 
  Sound(2000); 
  Delay(1000);    { On attend une seconde } 
  NoSound; 
End.
Remarques
  • 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 gérer votre carte son, alors il faudra avoir recours à une unité externe. Attention ! Toutes les cartes sons sont spécifiques, et aucune ne se gère de la même manière. Si la plupart tendent à être compatibles SoundBlaster, ce n'est pas une règle. Vous devez donc vous procurer la documentation système de votre carte son avant de vous lancer dans sa programmation.

Mis à jour le 29 mars 2004 Eric Sigoillot

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 :

Code delphi : Sélectionner tout
1
2
3
4
5
6
7
  
Var 
  GraphDriver, GraphMode : Integer; 
  
Begin 
  GraphDriver := Detect; 
  ...
Dans certains cas, il peut être intéressant de spécifier soi-même quel mode graphique utiliser. Il faudra alors définir à la fois GraphDriver et GraphMode :

Code delphi : Sélectionner tout
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) } 
  ...
Différentes valeurs sont possibles. Seules les valeurs pour le pilote VGA sont listées ci-dessous, les autres étant tombés en désuétude totale :

GraphDriver GraphMode Résolution
0 = Detect (non défini) La meilleure possible
9 = VGA 0 = VGALo 640x200
9 = VGA 1 = VGAMed 640x350
9 = VGA 2 = VGAHi 640x480
Une fois ces variables définies, il ne reste plus qu'à appeler InitGraph, en indiquant le chemin d'accès au driver BGI (\TP7\BGI la plupart du temps).
Il y a néanmoins un élément à prendre en compte : il se peut que l'initialisation du mode graphique échoue (vous avez indiqué un répertoire erroné, vous manquez de mémoire, le pilote choisi n'est pas compatible, etc.). Vous devez donc vérifier que tout s'est bien déroulé comme prévu à l'aide de la fonction GraphResult, qui renvoie le dernier code d'erreur reçu par le système graphique. S'il n'y a pas eu d'erreur, alors vous recevrez le code grOk.
Pour plus d'information, vous pouvez aussi faire appel à la fonction GraphErrorMsg, qui renverra le message d'erreur associé à un code d'erreur donné.

N'oubliez pas, après avoir fini de travailler avec le mode graphique, de faire appel à CloseGraph, qui permet de retrouver le mode texte précédent.

Pour résumer tout cela 

Code delphi : Sélectionner tout
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.

Mis à jour le 6 mars 2004 Eric Sigoillot

Comment produire des graphismes haute résolution ?

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 :

Code delphi : Sélectionner tout
1
2
3
4
  
SwapVectors; 
Exec('COMMAND.COM',''); 
SwapVectors;
Autre point à prendre considération : la mémoire. En effet, un programme externe a besoin de mémoire pour pouvoir se lancer. Or, par défaut, un programme créé avec Turbo Pascal s'attribue toute la mémoire libre disponible à son lancement, n'en laissant aucune pour un autre programme supplémentaire.
La solution la plus simple consiste alors à indiquer à Turbo Pascal de ne réserver qu'une partie de la mémoire libre. Pour ce faire, il faut utiliser la directive de compilation {$M TaillePile,TasMini,TasMaxi}, où TaillePile représente la taille de la pile (16384 par défaut), TasMini représente la taille minimale du tas (0 par défaut) et TasMaxi la taille maximale du tas (655360 par défaut). De fait, si vous n'avez pas modifié les options par défaut de Turbo Pascal (dans Options --> Memory sizes...), tout programme est déclaré implicitement avec la directive {$M 16384,0,655360}.
Votre programme, comme tous les programmes Dos en mode réel, ne peut accéder qu'aux 640 Ko de mémoire conventionnelle basse, à savoir 655360 octets. Par conséquent, en laissant la valeur par défaut pour TasMaxi, votre programme va tenter d'allouer toute la mémoire disponible. Pour laisser de la mémoire pour d'autres programmes, il convient de réduire cette valeur. Il faut donc trouver un juste milieu entre la mémoire que vous désirez laisser libre aux autres applications et la mémoire dont votre programme a besoin (la mémoire dynamique ici, dont vous avez besoin lors de l'utilisation de Newou GetMem).
On peut, par exemple, décider de s'allouer 200 Ko de mémoire, on aura alors :

Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
  
Program Exemple; 
{$M 16384,0,204800} 
  
Begin 
  ... 
  SwapVectors; 
  Exec('COMMAND.COM','') ; 
  SwapVectors; 
  ... 
End.
La variable DosError reçoit le résultat de la procédure Exec : toute valeur différente de zéro indique alors une erreur. Les erreurs les plus courantes sont :

Code d'erreur Signification
2 Fichier non trouvé
3 Répertoire incorrect
5 Accès refusé
8 Mémoire insuffisante
Code delphi : Sélectionner tout
1
2
3
4
5
6
7
  
... 
SwapVectors; 
Exec('COMMAND.COM',''); 
SwapVectors; 
if DosError <> 0 then ... 
...
  • Remarque

Nous avons utilisé ici comme programme d'exemple COMMAND.COM. Il s'agit de l'interpréteur de commandes de Dos et de Windows 9x. Toutefois, avec Windows 2000 et XP, si cet interpréteur n'a pas disparu, il a toutefois changé de nom, et se nomme CMD.EXE.
Par conséquent, si on désire faire un programme capable de fonctionner sur n'importe quel système d'exploitation compatible MS-DOS, il convient de prendre en compte ce problème. Comment faire alors ? C'est simple, le système d'exploitation se doit de définir la variable d'environnement COMSPEC, qui contient le nom de l'interpréteur de commandes. Pour lire une variable d'environnement, il faut se servir de la fonction GetEnv (NomVarEnv) :

Code delphi : Sélectionner tout
1
2
  
Exec(GetEnv('COMSPEC'),'');

Mis à jour le 7 mars 2004 Eric Sigoillot

Comment réduire la mémoire utilisée par un programme ?
Quelles sont les directives de compilation ?

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

Code delphi : Sélectionner tout
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;
Pour le curseur, 32 lignes sont disponibles (de 0 à 31). Si jamais vous indiquez une valeur supérieure à 31, alors le curseur disparaît.

Mis à jour le 5 juin 2004 Eric Sigoillot

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2016 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsable bénévole de la rubrique Pascal : Alcatîz -