Line
Procédure GRAPH : 4, 5, 6
Syntaxe
Line(x1, y1, x2, y2);
où x1, y1, x2 et y2 sont des expressions de type Integer.
Description
La procédure Line trace une ligne depuis le point (x1, y1) vers le point (x2, y2). Le type du trait (continu, pointillé, ou autre) et l'épaisseur de la ligne sont définis par SetLineStyle, la couleur par SetColor. Suivant la définition de la fenêtre active donnée par SetViewPort, la ligne peut ne pas être dessinée en entier, voire même ne pas être dessinée du tout. La couleur du dessin est déterminée par SetColor. La manière dont la ligne se comporte lors d'intersections avec d'autres lignes est déterminée par SetWriteMode. La procédure Line ne modifie pas la valeur du pointeur courant.
Exemple
Randomize;
For i := 1 To 100 Do
Begin
SetLineStyle (i Mod 3, 1, 3);
Line (Random (GetMaxX), Random (GetMaxY), Random(GetMaxX), Random(GetMaxY));
End;
Cent lignes sont tracées à l'écran de manière aléatoire, le type de trait est modifié à chaque tracé.
LineRel
Procédure GRAPH : 4, 5, 6
Syntaxe
LineRel (dep_x, dep_y);
où dep_x et dep_y sont des expressions entières/
Description
La procédure LineRel dessine une ligne entre la position courante du curseur et le point de coordonnées (GetX + dep_x, GetY + dep_y). Il s'agit donc d'un déplacement relatif depuis la position courante. Le type du trait (continu, pointillé, ... ) et l'épaisseur de la ligne sont définis par SetLineStyle, la couleur par SetColor. Suivant la définition de la fenêtre active donnée par SetViewPort, la ligne peut ne pas être dessinée en entier, voire même ne pas être dessinée du tout. La manière dont la ligne se comporte lors d'intersections avec d'autres lignes est déterminée par SetWriteMode. Après l'appel à LineRel la valeur du pointeur courant est l'extrémité de la ligne (GetX + dep_x, GetY + dep_y).
Exemple
Randomize;
cx := GetMaxX Div 2;
cy := GetMaxY Div 2;
Repeat
LineRel (Random (GetMaxX) – cx, Random (GetMaxY) - cy);
Until KeyPressed;
Des lignes sont dessinées de manière aléatoire jusqu'à ce que l'utilisateur pousse sur une touche. Les lignes ou parties de lignes qui sortent de l'écran ne sont pas dessinées.
LineTo
Procédure GRAPH : 4, 5, 6
Syntaxe
LineTo (x, y);
où x et y sont des expressions de type Integer.
Description
La procédure LineTo dessine une ligne entre la position
courante du curseur et le point de coordonnées
(x, y). Le type du trait (continu, pointillé, ... ) et
l'épaisseur de la ligne sont définis par SetLineStyle, la couleur par SetColor.
Suivant la définition de la fenêtre active donnée par SetViewPort, la ligne peut
ne pas être dessinée en entier, voire même ne pas être dessinée du tout. La
manière dont la ligne se comporte lors d'intersections avec d'autres lignes est
déterminée par SetWriteMode. Après l'appel à LineTo la valeur du pointeur
courant est l'extrémité de la ligne (x, y).
Exemple
Randomize;
For i := 1 To 100 Do
Begin
SetLineStyle (i MOD 3, 1, 1);
LineTo (Random (GetMaxX), Random (GetMaxY));
End;
Cent lignes sont tracées à l'écran de manière aléatoire, chacune ayant comme origine l'extrémité de la précédente. Le type de trait est modifié à chaque tracé.
Ln
Fonction : Real 3, SYS : 4, 5, 6
Syntaxe
Ln (r)
où r est une expression de type Real.
Description
La fonction Ln calcule le logarithme népérien de r, c'est-à-dire le logarithme en base e, où e vaut 2,71828182. La précision du calcul dépend de l'utilisation éventuelle des directives de compilation {$N} et {$E} et de la présence du coprocesseur arithmétique.
Remarques
· Rien n'est prévu pour calculer le logarithme en base 10.
· Pour rappel, le logarithme en une base quelconque peut être calculé par : Ln(nbre)/Ln(base).
· La fonction Exp est la fonction inverse de Ln.
Exemple
Writeln ('Entrez le nombre');
Readln (nbre);
Writeln ('Entrez la base');
Readln (base);
WriteLn (Ln(nbre)/Ln(hase));
Ce petit morceau de programme affiche le logarithme d'un nombre en une base quelconque.
Lo
Fonction : (Integer) Byte (3) SYS : 4, 5, 6
Syntaxe
Lo (i)
où i est une expression de type Integer ou Word.
Description
La fonction Lo renvoie l'octet de poids faible de l'entier ou du mot qui lui est transmis.
Remarque
En Turbo Pascal 3 Lo était de type Integer et renvoyait un Integer.
Exemple
Si j = Lo (258), alors j = 2
258 = 00000001 00000010
2 = 00000010
Si j = Lo (1058), alors j = 34
1058 = 00000100 00100010
34 = 00100010
LongFilePos
Fonction : Real 3
Syntaxe
LongFilePos (fich)
où fich est une variable de type fichier typé ou non typé.
Description
La fonction LongFilePos renvoie la position du pointeur de fichier dans le fichier fich. Le type du résultat est Real afin de pouvoir manipuler de plus longs fichiers que FilePos. Cette position est exprimée en nombre d'enregistrements comptés à partir de 0 pour le premier.
Remarques
· La fonction LongFilePos se comporte comme la fonction FilePos si ce n'est le type du résultat renvoyé. Elle est compatible avec LongFileSize et LongSeek.
· A partir de la version 4, l'unité Turbo3 contient une version de LongFilePos afin de garantir la compatibilité avec le Turbo Pascal 3.
Exemple
LongSeek (fich, LongFilePos(fich)-1);
Le pointeur de fichier est reculé d'un élément
(FilePos-1) même si on se trouve au-delà du
32 000e enregistrement.
LongFileSize
Fonction : Real 3
Syntaxe
LongFileSize (fich)
où fich est une variable de type fichier typé ou non typé.
Description
La fonction LongFileSize renvoie la taille d'un fichier exprimée sous la forme d'un réel, ceci pour permettre la manipulation de fichiers plus importants que la fonction standard. Cette taille est exprimée en nombre d'enregistrements comptés à partir de 0 pour un fichier vide.
Remarques
· La fonction LongFileSize se comporte comme la fonction FileSize si ce n'est le type du résultat renvoyé. Elle est compatible avec LongFilePos et LongSeek.
· A partir de la version 4, l'unité Turbo3 contient une version de LongFileSize afin de garantir la compatibilité avec le Turbo Pascal 3.
Exemple
Assign (fich, 'C:\DATA\CLIENT');
Writeln (' Le fichier contient ', LongFileSize (fich),' enregistrements');
Donne à l'écran le nombre d'enregistrements du fichier C:\DATA\CLIENT même s'il y en a plus de 32 000.
LongInt
Identificateur de type 4, 5, 6
Syntaxe
identv1, identv2,... : LongInt; ou identt1, identt2,... = LongInt;
où identv1, identv2,.. sont des identificateurs de variables et identt1, identt2 sont des identificateurs de types.
Description
Ce mot est utilisé lors de la déclaration de variables ou de types entiers longs. Les variables de ce type sont stockées en mémoire sous la forme de quatre octets signés; leur domaine de validité est donc –2147483648 à +2147483647. Il s'agit donc d'un sur ensemble du type Integer. Le type LongInt est compatible, dans son domaine, avec les autres types entiers. Comme aucune vérification n'est effectuée au moment de l'exécution du programme, si le nombre à stocker dans une variable de type LongInt dépasse l'intervalle de définition, il n'y a pas d'erreur d'exécution et le programme peut avoir un comportement aberrant.
Remarque
Ce type est une extension au Pascal standard.
Exemple
Type grand = LongInt;
Var num_compte, carte : LongInt;
Le type grand est déclaré comme synonyme du type LongInt et les variables num_compte et carte sont déclarées de ce type.
LongSeek
Procédure 3
Syntaxe
LongSeek(fich, nbre);
où fich est une variable de type fichier typé ou non typé et nbre une variable de type Real.
Description
La procédure LongSeek permet de placer la fenêtre de lecture/écriture sur un élément déterminé d'un fichier typé ou non typé. L'argument est de type Real afin de pouvoir manipuler de longs fichiers. Les éléments sont comptés, comme avec la procédure LongFilePos, à partir de zéro.
Remarques
· La fonction LongSeek se comporte comme la fonction Seek si ce n'est le type de l'argument utilisé. Elle est compatible avec LongFilePos et LongFileSize.
· A partir de la version 4, l'unité Turbo3 contient une version de LongSeek afin de garantir la compatibilité avec le Turbo Pascal 3.
Exemple
LongSeek (data, 51000);
La fenêtre de lecture/écriture est placée sur le 5l 001e élément du fichier data.
LowVideo
Procédure (3) CRT : 4, 5, 6
Syntaxe
LowVideo;
-- Turbo Pascal 4, 5, 6 --
Description
La procédure LowVideo soustrait 8 de la valeur de la couleur du texte : les couleurs codées de 8 à 15 deviennent de 0 à 7.
DarkGray = 8 --> Black = 0 LightBlue = 9 --> Blue = l
LightGreen = 10 --> Green = 2
LightCyan = 11 --> Cyan = 3
LightRed = 12 --> Red = 4
LightMagenta = 13 --> Magenta = 5
Yellow = 14 --> Brown = 6
White = 15 --> LightGray = 7
Remarque
Cette procédure modifie la variable prédéfinie TextAttr
dont la structure est la suivante :
bits de 0 à 3 =
couleur du texte; de 4 à 6 = couleur du fond; 7 = clignotement.
Exemple
TextColor (LightBlue);
TextBackGround (Blue);
...
LowVideo;
La couleur du texte est le bleu clair et celle du fond le bleu. L'appel à LowVideo fait disparaître le texte puisque celui-ci est de la même couleur que le fond.
-- Turbo Pascal 3 --
Description
La procédure LowVideo met le texte dans l'attribut défini comme start of LowVideo lors de l'installation.
Remarque
A partir de la version 4, l'unité Turbo3 contient une version de LowVideo compatible avec celle de Turbo Pascal 3.
Mark
Procédure 3, SYS : 4, 5, 6
Syntaxe
Mark (p);
où p est une variable de type pointeur sans type (déclarée Pointer).
Description
La procédure Mark permet de mémoriser la valeur du pointeur du tas (HeapPtr). La valeur renvoyée par p pourra, par la suite, être utilisée par Release pour détruire les Variables dynamiques qui ont été créées à une adresse supérieure à celle contenue dans p.
Remarques
· L'utilisation de Mark et Release est difficilement compatible avec celle de Dispose et de FreeMem (voir Release).
· Mark renvoie bien la valeur du pointeur du sommet du tas. En pratique, cela signifie que s'il existe des blocs mémoire libres à des adresses plus basses, ceux-ci ne seront pas pris en considération.
Exemple
New (pt_ligne1);
Mark (sommet);
New (pt_ligne2);
New (pt_ligne3);
Release (sommet);
Mark mémorise la valeur du pointeur du sommet du tas. Release détruit les Variables dynamiques pointées par pt_ligne2 et pt_ligne3 pour autant que ni Dispose ni FreeMem ne soient utilisés entre-temps.
MaxAvail
Fonction : LongInt (3) SYS : 4, 5, 6
Syntaxe
MaxAvail
Description
La fonction MaxAvail renvoie la taille du plus grand bloc de mémoire disponible dans le tas. Cette taille Indique donc la plus grande variable dynamique qui peut être créée. Il est conseillé d'utiliser MaxAvail avant l'emploi des procédures New et GetMem.
Remarques
· Turbo Pascal ne disposant pas de ramasse-miettes, MaxAvail n'Indique pas la mémoire totale disponible (voir MemAvail).
· En Turbo Pascal 3, le résultat renvoyé était de type Integer et Indiquait le nombre de paragraphes de 16 octets libres. A partir de la version 4, c'est le nombre d'octets qui est renvoyé. L'unité Turbo3 contient une version de MaxAvail se comportant comme celle de Turbo Pascal 3.
Exemple
If MaxAvail > SizeOf (enreg) Then New (reg)
Else
Begin
WriteLn ('Mémoire Insuffisante');
Halt (1);
End;
Si la mémoire disponible est suffisante, la variable dynamique est créée, sinon le programme est arrêté à l'aide de Halt.
MemAvail
Fonction : LongInt (3) SYS : 4, 5, 6
Syntaxe
MemAvail
Description
La fonction MemAvail renvoie la taille totale disponible dans le tas pour des Variables dynamiques. Cependant, dès que Dispose ou FreeMem auront été utilisés, il est vraisemblable que cette mémoire totale sera morcelée en plusieurs blocs et ne pourra pas être utilisée en une seule fois. En effet, Turbo Pascal ne dispose pas de véritable ramasse-miettes. Pour connaître la taille du plus grand bloc de mémoire disponible pour une variable dynamique, utilisez MaxAvail.
Remarques
· En Turbo Pascal 3, le résultat renvoyé était de type Integer et Indiquait le nombre de paragraphes de 16 octets libres. A partir de la version 4, c'est le nombre d'octets qui est renvoyé. L'unité Turbo3 contient une version de MemAvail se comportant comme celle de Turbo Pascal 3.
· S'il apparaît que la mémoire totale dans le tas est suffisante, mais que le bloc le plus grand est trop petit, une solution peut être de libérer la mémoire en détruisant des Variables dynamiques et de les recréer ensuite.
· Voir l'exemple de MaxAvail.
MkDir
Procédure 3, SYS : 4, 5, 6
Syntaxe
MkDir (reper);
où reper est une variable ou une Constante de type chaîne de caractères.
Description
La procédure MkDir permet de créer un répertoire depuis un programme Turbo Pascal. Le nom du répertoire, utilisé comme argument, peut comporter également le nom de l'unité sur laquelle ce répertoire doit être créé.
Remarque
Si l'unité spécifiée n'existe pas ou qu'il est impossible de créer le répertoire, une erreur est renvoyée par l'Intermédiaire de IoResult. Toutefois, pour éviter que le programme se termine prématurément, la directive de compilation {$I-} doit avoir été spécifiée.
Exemple
{SI-}
MkDir ('C:\DATA');
{$I+}
Le répertoire DATA dans la racine du disque C: est créée.
Mod
Opérateur 3, 4, 5, 6
Syntaxe
entier1 Mod entier2
où entier1 et entier2 sont des expressions de type entier.
Description
L'opérateur Mod renvoie le reste de la division entière de deux entiers : a Mod b = a - (( a Div b ) * b).
Remarques
· Cet opérateur ne peut s'appliquer qu'à deux entiers (ou apparentés : ShortInt, Integer, LongInt, Byte, Word).
· Une erreur d'opérandes est diagnostiquée lors de la compilation : Error 4I: Operand types do not match operator.
Exemple
a := 11;
b := 4;
c := a Mod b;
La variable c recevra la valeur entière 3.
Move
Procédure 3, SYS : 4, 5, 6
Syntaxe
Move (orig, dest, nbre);
où orig et dest sont des Variables d'un type quelconque et nbre une expression de type Word (Integer en Turbo Pascal 3).
Description
La procédure Move permet de déplacer un bloc de nbre octets depuis le premier octet de la variable orig vers le bloc commençant au premier octet de la variable dest.
Remarque
Aucune vérification n'est faite sur le nombre d'octets à transférer. L'utilisation de SizeOf (orig) est donc conseillée si toute la variable orig doit être déplacée.
Exemple
bool := False;
Move (bool, valeur, SizeOf(bool));
WriteLn (valeur);
Cet exemple montre que False est codé sur un octet de valeur 0.
MoveRel
Procédure GRAPH : 4, 5, 6
Syntaxe
MoveRel(dep_x, dep_y);
où dep_x et dep_y sont des expressions de type Integer.
Description
La procédure MoveRel permet de placer le pointeur courant en un point de coordonnées (GetX + dep_x, GetY + dep_y). Il s'agit donc d'un déplacement relatif. Les coordonnées sont toujours données par rapport au coin supérieur gauche de la fenêtre active. Si aucune fenêtre n'est explicitement définie, l'ensemble de l'écran est la fenêtre par défaut et ses limites sont (0, 0, GetMaxX, GetMaxY). InitGraph, SetGraphMode, SetViewPort, ClearViewPort et ClearDevice placent le pointeur courant au point de coordonnées (0, 0). MoveTo, MoveRel, LineTo, LineRel et OutText le déplacent.
Remarque
Le pointeur courant n'est pas limité par la fenêtre active. Si l'on sort de l'écran, qu'une fenêtre ait été définie ou non, il n'y aura pas d'affichage.
Exemple
For i := 1 To 10 Do
Begin
MoveRel (40,-10);
LineRel (20, 20);
End;
Dix fois, le pointeur courant est déplacé de 40 pixels vers la droite et de 10 pixels vers le haut. A partir de ce point une ligne est tracée de 20 pixels vers la droite et le bas.
MoveTo
Procédure GRAPH : 4, 5, 6
Syntaxe
MoveTo (x, y);
où x et y sont des expressions de type Integer.
Description
La procédure MoveTo permet de placer le pointeur courant
en un point de coordonnées (x, y). Les coordonnées
sont toujours données par rapport au coin supérieur gauche de la fenêtre active.
Si aucune fenêtre n'est explicitement définie, l'ensemble de l'écran est la
fenêtre par défaut et ses limites sont
(0, 0, GetMaxX,
GetMaxY). InitGraph, SetGraphMode, SetViewPort, ClearViewPort et ClearDevice
placent le pointeur courant au point de coordonnées (0, 0). MoveTo, MoveRel,
LineTo, LineRel et OutText le déplacent.
Remarque
Le pointeur courant n'est pas limité par la fenêtre active. Par exemple, il est possible, sans erreur, de lui donner une abscisse et une ordonnée négatives. Dans ce cas, si une fenêtre a été définie, l'affichage se fera ou non suivant les paramètres transmis à SetViewPort. Si l'on sort de l'écran, qu'une fenêtre ait été définie ou non, il n'y aura pas d'affichage.
Exemple
MoveTo (100, 150);
OutText (' Hello BGI ');
Le pointeur courant est placé au point (100, 150), la chaîne Hello BGI est écrite à partir de ce point.
MsDos
Procédure 3, DOS : 4, 5, 6
Syntaxe
MsDos (registres)
où registres est une variable de type Registers définissant les valeurs à donner aux principaux registres du processeur. Le type Registers est, à partir de Turbo Pascal 4, défini par l'unité Dos :
Registers = Record
Case Integer Of
0: (AX, BX, CX, DX, BP, SI, DI, DS, ES, Flags : Word);
l: (AL, AH, BL, BH, CL, CH, DL, DH: Byte);
End;
Description
Cette procédure permet de faire directement appel à l'Interruption $21 du Dos. Son fonctionnement est identique à celui de Intr.
En fait, Intr($21, reg) est identique à MsDos (reg).
Remarques
· Il n'est pas possible d'utiliser des Interruptions qui manipuleraient les registres SP et SS.
· Voir aussi Intr.
New
Procédure 3, SYS : 4, 5, 6
Syntaxe
New (p)
où p est une variable de type pointeur.
Description
La procédure New permet de créer une variable dynamique et donne à p l'adresse de cette variable. L'argument doit être déclaré du type pointeur vers le type de la variable à créer.
Remarques
· II doit y avoir assez de place dans le tas pour pouvoir créer la variable dynamique, sinon une erreur d'exécution se produit : Error 203: Heap overflow error.
· La place disponible pour créer des Variables dynamiques est accessible par la fonction MaxAvail.
Exemple
Type point = ^enreg;
enreg = Record
donnee : Array [l..1000] Of Word;
End;
Var rep : point;
Begin
If MaxAvail > SizeOf (enreg) Then New (rep);
End.
Si la mémoire disponible est suffisante pour contenir une variable de type enreg, celle-ci est créée à l'aide de New (rep), où rep est du type pointeur vers enreg.
Nil
Mot réservé 3, 4, 5, 6
Syntaxe
Varpoint := Nil;
où Varpoint est une variable de type pointeur.
Description
Cette valeur réservée permet de donner une valeur nulle (rien) à un pointeur. Elle est habituellement utilisée pour Initialiser les pointeurs. En effet, non Initialisés, les pointeurs risquent de désigner des emplacements en mémoire de manière aléatoire et de provoquer un comportement aberrant du programme. NIL est compatible avec tous les types de pointeurs.
Remarque
Le fait d'affecter une valeur Nil à un pointeur ne libère pas l'espace mémoire occupé par la variable pointée. Pour libérer cet espace mémoire il est nécessaire de faire appel soit à la procédure Dispose, soit aux procédures Mark et Release.
Exemple
pointeur := Nil;
La variable pointeur reçoit la valeur Nil.
NormVideo
Procédure 3, CRT : 4, 5, 6
Syntaxe
NormVideo;
-- en Turbo Pascal 4, 5 et 6 --
Description
La procédure NormVideo rétablit les attributs de couleurs de l'écran texte : couleur du fond et des caractères, clignotement tels qu'ils ont été lus au moment où le programme a été lancé.
Exemple
TextColor (LightBlue);
TextBackGround (Magenta);
...
NormVideo;
La couleur du texte est définie à bleu clair et celle du fond à magenta. Ensuite les attributs d'affichage de départ sont rétablis.
-- en Turbo Pascal 3 --
Description
La procédure NormVideo est identique à HighVideo qui modifie les attributs d'affichage en blanc sur fond noir pour les écrans monochromes et jaune sur fond noir sur les écrans couleur.
Remarque
A partir de la version 4, l'unité Turbo3 contient une version de NormVideo compatible avec celle de Turbo Pascal 3.
NoSound
Procédure 3, CRT : 4, 5, 6
Syntaxe
NoSound;
Description
La procédure NoSound désactive le haut-parleur du PC qui a été activé par la procédure Sound. Si aucun appel à NoSound n'est effectué, le son continue à être émis, même après la fin du programme.
Exemple
freq := 1;
Repeat
Sound (freq);
Delay (15);
freq := ((freq + 1) Mod 25) + 1500;
Until KeyPressed;
NoSound;
Un son de style sirène est émis tant que l'utilisateur ne pousse pas sur une touche. La procédure NoSound arrête la génération du son.
Not
Opérateur 3, 4, 5, 6
Syntaxe
Not exp
où exp est une expression booléenne ou entière.
Description
L'opérateur Not correspond au « non » logique (expressions booléennes) et arithmétique (expressions arithmétiques). Dans le premier cas le résultat est True (vrai) si l'expression est fausse, sinon le résultat est False (faux) Dans le second cas une Inversion bit par bit est effectuée sur l'entier.
Remarques
· Les opérateurs doivent être tous les deux de type Integer ou Boolean.
· Les erreurs de type des opérateurs sont diagnostiquées à la compilation : Error 4I: Operand types do not match operaror.
Exemples
While Not Eof (fich) Do ReadLn (fich, elem);
Le fichier fich est lu jusqu'à la fin, c'est-à-dire jusqu'à ce que la fonction Eof soit vraie.
Si nbre vaut 2 alors res := Not nbre vaudra -3 :
nbre : 0000000000000010
-----------------------
res : 1111111111111101
Odd
Fonction : Boolean 3, SYS : 4, 5, 6
Syntaxe
Odd (i)
où i est une expression de type LongInt ou Integer (uniquement en Turbo Pascal 3).
Description
La fonction booléenne Odd renvoie True si le nombre fourni est impair et False si le nombre est pair.
Remarque
En Turbo Pascal 3 l'argument fourni ne pouvait être que de type Integer, à partir de la version 4 l'entier éventuellement fourni est automatiquement converti en LongInt. Il ne devrait donc pas y avoir de problème de conversion.
Exemple
If Odd(i) Then i := i + 1;
Si la variable i est impaire elle est augmentée d'une unité.
Ofs
Fonction : (Integer) Word (3) SYS : 4, 5, 6
Syntaxe
Ofs(ident)
où ident est un identificateur de variable, procédure ou fonction. Le résultat est de type Integer en Turbo Pascal 3 et Word à partir de la version 4.
Description
La fonction Ofs renvoie la partie déplacement (Offset) dans le segment du premier octet de l'adresse d'un objet (variable, procédure ou fonction) spécifié.
Remarque
Si l'argument est un tableau, celui-ci peut être Indicé, si l'argument est un enregistrement, un champ peut être spécifié, ce qui permet de connaître l'adresse d'un élément d'une variable composée.
Exemple
WriteLn (Seg (bool), ' ', Ofs (bool));
Cette Instruction écrit le segment puis l'offset de l'adresse de la variable bool.
Or
Opérateur 3, 4, 5, 6
Syntaxe
exp1 Or exp2
où exp1 et exp2 sont des expressions booléennes ou entières.
Description
L'opérateur Or correspond au « ou » logique (expressions booléennes) et arithmétique (expressions arithmétiques). Dans le premier cas le résultat est True (vrai) si une des deux expressions au moins est vraie, sinon le résultat est False (faux). Dans le second cas, une comparaison bit par bit est effectuée entre les deux entiers.
Remarques
· Les opérateurs doivent être tous les deux de type Integer ou Boolean.
· Les erreurs de type des opérateurs sont diagnostiquées à la compilation : Error 4I: Operand types do not match operator.
· La priorité des opérateurs booléens est plus grande que celle des opérateurs de comparaison. Une expression comme " r < 34 76 Or j = 45 " donnera donc une erreur de compilation. L'emploi des parenthèses est Indispensable dans ce genre de cas.
Exemples
While (r < 34 76) Or (j = 45) Do ReadLn (r, j);
Tant que r sera plus petit que 34 76 ou que j sera égal à 45, une nouvelle lecture sera faite.
Si
entl := 2;
ent2 := 3;
res := entl Or ent2;
Alors res vaudra 3 :
entl : 00000010
ent2 : 00000011
---------------
res : 00000011
Ord
Fonction : (Integer) LongInt (3) SYS : 4, 5, 6
Syntaxe
Ord (s)
où s est une expression de type scalaire.
Description
La fonction Ord renvoie le rang de la variable scalaire qui lui est transmise comme argument. Pour rappel, les types scalaires sont : ShortInt, Integer, LongInt, Byte, Word, Char, Boolean, énumérés ainsi que les Intervalles de ces types. Le résultat de la fonction est du type de l'argument qui lui a été transmis.
Exemple
ch := 'A';
WriteLn (Ord(ch));
Le nombre 65 est écrit à l'écran.
OutText
Procédure GRAPH : 4, 5, 6
Syntaxe
OutText (ch);
où ch est une expression de type chaîne de caractères (String).
Description
La procédure OutText écrit, sur le périphérique de sortie, la chaîne de caractères qui lui est transmise en paramètre. L'écriture se fera à partir de la position du pointeur courant. Les procédures suivantes modifient la manière dont le texte est écrit à l'écran :
- SetTextJustify : position par rapport au pointeur courant;
- SetTextStyle : fonte de caractères, direction d'écriture, taille;
- SetUserCharSize : proportion de hauteur et de largeur.
L'affichage devrait se faire dans la fenêtre active (par défaut l'écran). Si une chaîne écrite dans une police définie par points (DefaultFont, par exemple) sort de la fenêtre, rien n'est écrit. Si une chaîne définie par une police vectorielle (les autres polices standard) sort de la fenêtre active, elle est tronquée aux limites de la fenêtre.
Remarque
La procédure OutText modifie la valeur du pointeur courant.
Exemple
SetTextStyle (SansSerifFont, HorizDir, 5);
MoveTo (50, 50);
OutText ('Marabout');
Le style du texte est défini comme police sans Sérif, direction horizontale, facteur d'agrandissement = 5. Le pointeur courant est placé au point (50, 50) de la fenêtre active. La chaîne 'Marabout' est écrite dans le style courant à partir de ce point.
OutTextXY
Procédure GRAPH : 4, 5, 6
Syntaxe
OutTextXY (x, y, ch);
où x et y sont des expressions de type Integer et ch de type chaîne de caractères (String).
Description
La procédure OutTextXY écrit, sur le périphérique de sortie, la chaîne de caractères qui lui est transmise en paramètre. L'écriture se fera à partir du point (x, y) qui lui est transmis en paramètre. Les procédures suivantes modifient la manière dont le texte est écrit à l'écran :
- SetTextJustify : position par rapport au pointeur courant;
- SetTextStyle : fonte de caractères, direction d'écriture, taille;
- SetUserCharSize : proportion de hauteur et de largeur.
L'affichage devrait se faire dans la fenêtre active (par défaut l'écran). Si une chaîne écrite dans une police définie par points (DefaultFont, par exemple) sort de la fenêtre, rien n'est écrit. Si une chaîne définie par une police vectorielle (les autres polices standard) sort de la fenêtre active, elle est tronquée aux limites de la fenêtre.
Remarque
La procédure OutTextXY ne modifie pas la valeur du pointeur courant.
Exemple
SetTextStyle (SansSerifFont, HorizDir, 5);
OutTextXY(100, 100, 'Marabout');
Le style du texte est défini comme police sans Sérif, direction horizontale, facteur d'agrandissement = 5. La chaîne 'Marabout' est écrite dans le style courant à partir du point (100, 100).
Overlay
Mot réservé 3 (5, 6)
Syntaxe
(Turbo Pascal 3) :
Overlay Procedure identp (param) ; Overlay Function identf (param) : typefonc;
où identp et identf sont des identificateurs de procédure et de fonction, param une liste de paramètres et typefonc le type de la fonction.
Description
En Turbo Pascal 3, ce mot réservé permet à plusieurs procédures et fonctions d'utiliser le même espace mémoire. L'espace réservé sera celui nécessaire pour le bloc le plus important. Les différentes procédures et fonctions seront chargées en mémoire depuis le disque au moment de leur appel. Il sera donc possible d'exécuter des programmes dont la taille totale est plus grande que la mémoire disponible.
Remarques
· Toutes les procédures et fonctions successives déclarées Overlay utiliseront le même espace mémoire. Si l'on désire, pour minimiser les accès disques, par exemple, réserver plusieurs espaces pour les procédures Overlay, il suffit de séparer deux groupes de procédures déclarées Overlay par une procédure qui ne l'est pas.
· Chaque suite de blocs Overlay sera stockée sur disque dans un fichier différent. Il n'est donc pas possible de compiler des fichiers Overlay en mémoire.
· Les sous-routines Overlay peuvent être imbriquées,
c'est-à-dire qu'une sous-routine Overlay peut
elle-même
contenir des sous-routines Overlay.
· Une sous-routine Overlay ne peut être déclarée Forward et ne peut effectuer des appels récursifs.
· Turbo Pascal 4 ne supporte pas la gestion des Overlay.
· Les versions 5 et 6 de Turbo Pascal supportent les recouvrements mais d'une manière totalement différente et nettement plus efficace :
- Les Units sont les plus petites unités pouvant être recouvertes (plus de recouvrement au niveau des procédures et fonctions).
- Ces unités recouvrables doivent être compilées sur disque avec les options {$0+,F+}.
- Le reste du programme et les unités non recouvrables doivent être compilés avec l'option {$F+}.
- La clause Uses doit faire mention de l'unité Overlay avant toute unité recouvrable.
- Après cette clause Uses, une directive de compilation {$0 nomunité} par unité recouvrable doit être employée.
- Enfin différentes Variables, procédures et fonctions de l'unité Overlay permettent de gérer le mécanisme de recouvrement, en particulier la procédure OvrInit permet d'Initialiser le gestionnaire de recouvrement.
- Ces différentes procédures sont : OvrInit, OvrInitEMS, OvrSetBuf, OvrGetBuf, OvrClearBuf, OvrGetRetry et OvrSetRetry.
OvrClearBuf
Procédure OVERLAY : 5, 6
Syntaxe
OvrClearBuf;
Description
Cette procédure a pour effet de vider le tampon des Overlay en mémoire centrale.
Remarque
Elle est utilisée lorsqu'il est absolument Indispensable de récupérer le maximum de mémoire, sinon elle ne sera jamais utilisée. Après l'appel à cette procédure, Turbo Pascal devra relire les fichiers Overlay sur le disque ou en mémoire étendue, ce qui provoque évidemment une perte de temps.
Exemple
OvrClearBuf;
Toute la mémoire est libérée par la suppression des fichiers recouverts en mémoire centrale.
OvrGetBuf
Fonction : LongInt OVERLAY : 5, 6
Syntaxe
OvrGetBuf
Description
La fonction OvrGetBuf renvoie la taille, exprimée en octets, de la zone mémoire allouée sur le tas comme tampon des partiels. Cette zone permet de diminuer sensiblement le temps de réaction du programme lors de l'appel d'une procédure se trouvant dans un fichier Overlay. Par défaut, celle-ci est minimale, c'est-à-dire de la taille du plus grand des fichiers de recouvrement utilisés dans le programme.
Exemple
Begin
...
OvrInit ('RECOUVERT.OVR');
If OvrResult < 0 Then Halt;
OvrSetBuf (OvrGetBuf + 65536);
...
End;
Le fichier recouvert.ovr est Initialisé comme contenant les fichiers Overlay. La taille de la mémoire tampon est ensuite augmentée de 64 Ko, soit 65 536 octets.
OvrGetRetry
Fonction : LongInt OVERLAY : 5, 6
Syntaxe
OvrGetRetry
Description
Cette fonction renvoie la taille, en octets, de la zone d'observation du tampon de fichiers de recouvrement. Cette taille a été définie au moyen de la commande OvrSetRetry. S'il n'y a pas eu d'appel à OvrSetRetry, la longueur renvoyée est égale à zéro.
Exemple
Begin
...
OvrInit ('RECOUVERT.OVR');
If OvrResult < 0 Then Halt;
OvrSetBuf (OvrGetBuf + 65536);
OvrSetRetry (OvrGetRetry + 12288);
...
End;
Le fichier recouvert.ovr est Initialisé comme contenant les fichiers Overlay. La taille de la mémoire tampon est ensuite augmentée de 64 Ko, soit 65 536 octets et celle de la zone d'observation de 12 Ko, soit 12 288 octets.
OvrInit
Procédure OVERLAY : 5, 6
Syntaxe
OvrInit(nomfich) ;
où nomfich est une variable ou une Constante de type String qui contient le nom du fichier de recouvrement.
Description
La procédure OvrInit permet d'ouvrir un fichier de recouvrement (Overlay) et d'Initialiser le gestionnaire de recouvrement des partiels. Ce fichier doit posséder l'extension OVL (Overlay). Il est Indispensable d'utiliser cette procédure avant d'utiliser une des procédures et fonctions de ce fichier.
L'utilisation de fichiers de recouvrement permet de créer des programmes plus importants que la mémoire de base disponible et, de plus, d'utiliser la mémoire étendue.
Rappelons que les Units sont les plus petits modules pouvant être recouverts en Turbo Pascal 5 et 6, qu'elles doivent être compilées sur disque avec les options {$O+, F+} et que le reste du programme et les unités non recouvrables doivent être compilées avec l'option {$F+}.
Pour utiliser des unités Overlay, la clause Uses doit faire mention de l'unité Overlay avant toute unité recouvrable. Après cette clause Uses, une directive de compilation {$O nomunité} par unité recouvrable doit être employée.
Remarques
· Le fichier contenant l'unité recouvrable doit être accessible au compilateur. La solution la plus simple consiste à Indiquer son emplacement exact (nom d'unité et de répertoire). Sinon, il peut se trouver dans le répertoire par défaut, dans le répertoire contenant le fichier .EXE ou dans un des répertoires spécifiés par la commande Path.
· Le résultat de l'opération est accessible par la variable prédéfinie Ovresult :
- OvrOk (0) : tout s'est bien passé;
- OvrError (-1) : erreur au niveau de l'Installation du mécanisme de recouvrement;
- OvrNotFound (-2) : erreur dans la recherche du fichier.
Exemple
Program recouvert;
{$F+}
Uses Overlay, mathrout, desrout;
{$O mathrout}
{$O desrout}
...
Begin
...
OvrInit ('RECOUVERT OVR');
If OvrResult < 0 Then Halt;
...
End.
Le programme recouvert utilise l'unité standard Overlay et les unités de l'utilisateur mathrout et desrout. L'Initialisation du mécanisme de recouvrement est effectuée par un appel à OvrInit en transmettant le nom Ms-Dos du fichier contenant les unités recouvrables. Enfin, un appel à OvrResult permet d'arrêter le programme si l'Initialisation ne s'est pas faite correctement.
OvrInitEMS
Procédure OVERLAY : 5, 6
Syntaxe
OvrInitEMS;
Description
Cette procédure permet de copier en mémoire étendue tous les fichiers Overlay définis par OvrInit. On observe donc une accélération considérable de l'exécution de programmes utilisant des partiels puisque les transferts se feront entre la mémoire étendue et la mémoire de base, et non entre le disque et la mémoire de base. Une opération en mémoire centrale est typiquement de 1000 à 10 000 fois plus rapide qu'une opération accédant au disque.
Remarques
· Il est nécessaire qu'une quantité de mémoire suffisante soit disponible pour charger l'ensemble des fichiers Overlay. Il n'est malheureusement pas possible de ne charger en mémoire étendue qu'une partie d'entre eux.
· Il ne suffit pas de disposer de plus de 640 Ko de mémoire pour que celle-ci soit utilisable. La mémoire doit être gérée par un procédé conforme à la norme LIM (Lotus-lntel-Microsoft), dite aussi EMS. Cette norme peut être obtenue soit par un moyen matériel (carte mémoire compatible), soit par l'utilisation de programmes d'adaptation comme HIMEM.SYS et EMM386.SYS de Microsoft.
· Les erreurs lors de l'appel à la procédure OvrInitEMS
sont rapportées par la variable prédéfinie
OvrResult :
- OvrOk (0) : Installation sans problème;
- OvrlOerror (-1) : erreur de lecture sur disque;
- OvrNoEMSDriver (-5) : gestionnaire de mémoire EMS absent;
- OvrNoEMSMemory (-6) : mémoire centrale Insuffisante.
· Une conséquence de la vitesse des transferts en mémoire centrale est que les tailles du tampon de recouvrement et de la zone probatoire ont beaucoup moins d'Influence sur la vitesse d'exécution du programme.
Exemple
Begin
...
OvrInit ('RECOUVERT.OVR');
If OvrResult < 0 Then Halt;
OvrInitEMS;
If OverResult = 0 Then WriteLn ('chargement en mémoire étendue');
...
End.
Après Initialisation à l'aide de OvrInit, un appel à OvrInitEMS permet de charger les unités en mémoire EMS. A chaque stade, un appel à OvrResult permet de vérifier l'exécution des procédures.
OvrSetBuf
Procédure OVERLAY : 5, 6
Syntaxe
OvrSetBuf(taille) ;
où taille (LongInt) est la taille, exprimée en octets, du tampon du gestionnaire de recouvrement.
Description
Afin d'accélérer le mécanisme de gestion des fichiers de recouvrement, Turbo Pascal consacre une partie de la mémoire disponible à un tampon dans lequel les derniers fichiers utilisés sont stockés. Si un deuxième appel au même fichier de recouvrement est effectué, il n'y aura pas de lecture sur disque nécessaire. Cet espace de mémoire est géré suivant une Variante du système First in First Out (premier entré, premier sorti), dans laquelle l'utilisation des fichiers de recouvrement est « observée » pour libérer l'espace mémoire occupé par les fichiers les moins appelés.
Par défaut, la taille allouée au tampon est celle du fichier recouvert le plus important.
Remarques
· La zone tampon est allouée sur le tas, ce qui a plusieurs conséquences. Le tas doit être vide, en pratique aucun appel ne doit avoir été fait aux procédures New, GetMem et InitGraph qui allouent de la mémoire sur le tas. De plus, la taille du tas doit être augmentée à l'aide d'une directive de compilation {$M}.
· Les erreurs sont rapportées par la variable prédéfinie OvrResult :
- OvrOk (0) : le succès de la procédure;
- OvrError (1) : le tas n'est pas vide;
- OvrNoMemory (-3) : pas assez de mémoire disponible sur le tas pour augmenter la taille de la zone tampon.
Exemple
Begin
...
OvrInit ('RECOUVERT.OVR');
If OvrResult < 0 Then Halt;
OvrSetBuf (OvrGetBuf*2);
...
End.
Le fichier recouvert.ovr est Initialisé comme contenant les fichiers Overlay. La taille de la mémoire tampon est doublée par rapport à la taille par défaut prévue par Turbo Pascal.
OvrSetRetry
Procédure OVERLAY : 5, 6
Syntaxe
OvrSetRetry (taille);
où taille, de type LongInt, spécifie la taille de la zone d'observation du tampon des fichiers de recouvrement.
Description
La procédure OvrSetRetry permet de spécifier, en octets, la taille de la mémoire tampon qui sera allouée à la zone d'observation.
Lorsqu'un fichier de recouvrement est appelé, il est placé dans la zone tampon de recouvrement des partiels. Ensuite, il recule progressivement dans cette zone jusqu'au moment où il atteint une zone d'observation. S'il est appelé pendant qu'il se trouve dans cette zone, il sera replacé au début du tampon. S'il n'est pas appelé et que de la mémoire est nécessaire pour un autre fichier recouvert, il sera éjecté du tampon.
Remarques
· Pour que cette possibilité ait un Intérêt, il est nécessaire que la taille de la zone tampon soit nettement plus grande que les fichiers recouverts utilisés. En pratique, cela nécessite l'emploi de la procédure OvrSetBuf.
· De nombreux paramètres Influencent la taille de la zone d'observation comme la taille de la mémoire tampon, celle des fichiers recouverts et la fréquence d'emploi des différents fichiers. Il sera probablement nécessaire de travailler par essais et erreurs sur chaque cas. Une proportion raisonnable semble se situer entre un tiers et la moitié de la mémoire tampon.
Exemple
Begin
...
OvrInit ('RECOUVERT.OVR');
If OvrResult < 0 Then Halt;
OvrSetBuf (65536);
OvrSetRetry (12288);
...
End.
Le fichier recouvert.ovr est Initialisé comme contenant les fichiers recouverts. La taille de la mémoire tampon est fixée à 64 Ko et celle de la zone d'observation à 12 Ko soit 12 288 octets.
Packed
Mot réservé 3, 4, 5, 6
Syntaxe
Type identyp = Packed typstruct; ou Var identVar : Packed typstruct;
où identyp et identVar sont des identificateurs de type ou de variable et typstruct un type structuré (tableau, ensemble, fichier ou enregistrement).
Description
En Pascal standard, le mot réservé Packed a pour effet de demander au compilateur d'utiliser le moins de mémoire possible pour stocker un type structure. Ceci est particulièrement Intéressant sur de gros ordinateurs lorsque les mots en mémoire sont plus grands que la place nécessaire pour stocker certains types de données.
En Turbo Pascal, ce mot n'a été conservé que pour des raisons de compatibilité et n'a aucun effet. Sur un PC, les mots sont relativement petits et Turbo Pascal compacte les données lorsque c'est possible.
Exemple
Var chaine : Packed Array [1..5] Of Char;
La variable chaIne est déclarée comme un tableau compacté, ce qui n'a aucun effet en Turbo Pascal.
PackTime
Procédure DOS : 4, 5, 6
Syntaxe
PackTime (heure_longue, heure_courte)
où heure_longue est une variable de type DateTime et heure_courte de type LongInt.
Description
La procédure PackTime permet de passer de la forme longue de la date et de l'heure directement lisible, à la forme courte utilisée, par exemple, par SetDate. Le paramètre heure longue doit être du type DateTime prédéfini par l'unité Dos :
DateTime = Record
Year, Month, Day, Hour, Min, Sec: word;
End;
Remarque
Les valeurs transmises n'étant pas vérifiées, le résultat peut être aberrant.
Exemple
With Split Do Begin
Year := 2010;
Month := 11;
Day := 11;
End;
PackTime (split, heure);
SetFTime (f, heure);
La date du 11 novembre 2010 est compactée et ensuite donnée au fichier f.
ParamCount
Fonction : (Integer) Word (3) SYS : 4, 5, 6
Syntaxe
ParamCount
Description
La fonction ParamCount renvoie le nombre de paramètres présents sur la ligne de commande lors de l'appel du programme. En Turbo Pascal 3, elle est de type Integer, à partir de la version 4, elle est de type Word.
Remarques
· Cette commande est essentiellement destinée aux programmes exécutés directement sous Ms-Dos et non dans l'environnement Turbo Pascal. Pour passer des arguments à un programme dans l'environnement Turbo, il est nécessaire d'utiliser l'option Run, Parameters.
· Pour lire les paramètres présents sur la ligne de commande, on utilisera la fonction ParamStr.
· Un espace ou une tabulation sont considérés comme des séparateurs suffisants pour séparer un paramètre du suivant. En d'autres termes, les paramètres ne peuvent comprendre aucun de ces caractères.
Exemple
If ParamCount <> 2 Then WriteLn ('nombre de paramètres Invalide');
Un message d'erreur est écrit si le nombre de paramètres transmis au programme est différent de 2.
ParamStr
Fonction : String 3, SYS : 4, 5, 6
Syntaxe
ParamStr(nbre)
où nbre est une expression de type Integer en Turbo Pascal 3 et Word à partir de Turbo Pascal 4.
Description
La fonction ParamStr renvoie un paramètre passé par la ligne de commande du programme. En faisant Varier nbre on a accès à chacun des paramètres.
Remarques
· Pour connaître le nombre de paramètres présents, on utilisera la fonction ParamCount.
· Cette commande est destinée aux programmes exécutés directement sous Ms-Dos. Pour passer des arguments à un programme dans l'environnement Turbo, il est nécessaire d'utiliser l'option Run, Parameters.
· Si nbre est supérieur au nombre de paramètres effectivement présents, alors une chaîne vide est renvoyée.
· Les espaces et les tabulations sont considérés comme des séparateurs suffisants. Les paramètres ne peuvent donc Comprendre aucun de ces caractères.
Exemple
If ParamCount = 2 Then
Begin
prem := ParamStr (1);
sec := ParamStr (2);
End;
Si le nombre de paramètres est égal à 2, le premier est affecté à la chaîne prem et le second à sec.
PieSlice
Procédure GRAPH : 4, 5, 6
Syntaxe
PieSlice (x, y, angle_a, angle_b, r);
où x et y sont des expressions de type Integer et angle_a, angle_b et r de type Word.
Description
La procédure PieSlice dessine un secteur de cercle dont le centre est le point de coordonnées (x, y), de rayon r, compris entre les angles angle_a et angle_b. La surface du secteur est remplie avec le motif et la couleur définis à l'aide de SetFillStyle et éventuellement de SetFillPattern. De plus, les contours sont dessinés dans la couleur définie par SetColor. Suivant la définition de la fenêtre active donnée par SetViewPort, le secteur peut ne pas être dessiné en entier.
Exemple
PieSlice (200, 200, 180, 270, 75);
Dessine le secteur du cercle de centre (200, 200), de rayon 75, compris entre les angles 180 et 270 degrés.
Pos
Fonction : Integer 3, SYS : 4, 5, 6
Syntaxe
Pos (ch1, ch2)
où ch1 et ch2 sont des expressions de type String.
Description
La fonction Pos renvoie la position qu'occupe la chaîne de caractères ch1 à l'intérieur de ch2. Le résultat renvoyé est un entier Indiquant la position du premier caractère.
Remarque
Si la chaîne ne contient pas la sous-chaîne, la valeur renvoyée est 0.
Exemple
ch1 := 'est';
ch2 := 'Ceci est un exemple';
WriteLn (Pos (ch1, ch2));
La valeur 6 est écrite à l'écran.
Pred
Fonction : Scalaire 3, SYS : 4, 5, 6
Syntaxe
Pred (s);
où s est une expression de type scalaire.
Description
La fonction Pred a pour effet de décrémenter, d'une unité, la variable scalaire qui lui est transmise comme argument. Pour rappel, les types scalaires sont : ShortInt, Integer, LongInt, Byte, Word, Char, Boolean, énumérés ainsi que les Intervalles de ces types. Le résultat de la fonction est du type de l'argument qui lui a été transmis.
Remarque
La fonction Pred est une alternative beaucoup plus rapide à une affectation comme i := i – 1. En effet, dans ce cas, l'adresse de i est calculée deux fois, tandis qu'à l'aide de Pred elle ne le sera qu'une seule fois. Dans le cas de boucles souvent utilisées, le gain de temps peut être non négligeable.
Exemple
ch := 'Z'
While ch >= 'A' Do
Begin
WriteLn (ch);
Pred (ch);
End;
A chaque tour de la boucle While, la variable ch est décrémentée et les lettres Z Y X... sont affichées.
Procedure
Mot réservé 3, 4, 5, 6
Syntaxe
Procedure identproc (param) ; corps de la procédure ;
où identproc est l'identificateur de la procédure et param la liste des paramètres formels.
Description
Ce mot est utilisé pour déclarer une procédure définie par l'utilisateur. Il sera suivi par le nom de celle-ci, le plus souvent une liste de paramètres formels (avec leur type respectif) placé entre parenthèses, le symbole « ; » et le corps de la procédure. La déclarative de procédure se termine par le symbole « ; ».
Le corps de la procédure a la même structure qu'un programme principal. Cela signifie qu'il comportera une partie déclarative et une partie exécutable et que dans cette partie exécutable on pourra trouver d'autres déclarations de procédures et de fonctions. A la différence d'une fonction, il est Interdit d'affecter, dans la partie exécutable de la procédure, le nom de celle-ci. Les procédures sont appelées en spécifiant leur nom et les paramètres effectifs. Comme les fonctions, les procédures sont récursives, c'est-à-dire qu'elles sont susceptibles de s'appeler elles-mêmes.
Remarques
· Les appels de procédure sont des Instructions simples.
· Les paramètres de type fichier doivent être transmis par variable.
· Les procédures peuvent être déclarées Forward, External ou InLine.
Exemple
Program exemproc;
Procedure racine (nom :Real; VAR rac :Real);
Begin
If nom >=0 Then rac := Sqrt(nom) Else rac :=1;
End;
Var nbre, resu : Real; Begin
ReadLn (nbre);
racine (nbre, resu);
If resu >=0 Then WriteLn ('Racine carrée', resu) Else WriteLn ('nombre négatif');
End.
Le programme exemproc déclare et appelle la procédure Racine.
Program
Mot réservé 3, 4, 5, 6
Syntaxe
Program identproc; corps du programme.
ou identproc est l'identificateur du programme.
Description
Ce mot réservé permet de définir l'en-tête d'un programme Pascal. A la différence du Pascal standard, il est Interdit de se servir de l'identificateur du programme à l'intérieur du programme.
Structure d'un programme :
Program identproc; partie déclarative; partie Instructions.
Structure de la partie déclarative :
déclaration des étiquettes; déclaration des Constantes; déclaration des types; déclaration des Variables; déclaration des procédures et des fonctions;
Remarques
· A la différence du Pascal standard, Turbo Pascal n'impose pas d'ordre particulier dans les déclaratives. La seule règle est que l'on ne peut utiliser un objet (pour en définir un autre, par exemple) qu'après l'avoir déclaré. Pour permettre la récursion mutuelle cette limitation est contournée par la clause FORWARD
Structure de la partie Instructions :
Begin
Instruction l;
Instruction 2;
...
Instruction n;
End.
· La partie Instructions d'un programme Pascal a la forme d'une Instruction composée dans laquelle les Instructions sont séparées les unes des autres par le symbole « ; » et encadrées par les mots réservés Begin et End.
Ptr
Pointer 3, SYS : 4, 5, 6
Syntaxe
Ptr (seg, ofs)
où seg et ofs sont des expressions de type Word.
Description
La fonction Ptr permet de transformer une adresse mémoire décrite à l'aide de son segment et de son déplacement en un pointeur compatible avec les autres pointeurs de Turbo Pascal. Les valeurs transmises comme arguments seront souvent obtenues par les fonctions Seg ou Ofs.
Remarque
Si l'on passe à Ptr comme arguments les résultats des fonctions Seg et Ofs sur une même variable, le résultat renvoyé est le même que celui de la fonction Addr ou de l'opérateur @.
Exemple
If Ptr (Seg(bool),Ofs(bool)) = Addr (bool) Then WriteLn ('Ok');
Cette expression est toujours vraie et Ok est toujours écrit.
PutImage
Procédure GRAPH : 4, 5, 6
Syntaxe
PutImage (x_sup, y_sup, image, op);
où x_sup et y_sup sont des expressions de type Integer, image une variable sans type et op de type Word.
Description
La procédure PutImage permet de réafficher une partie de l'écran qui a été stockée à l'aide de GetImage. Les deux premiers paramètres donnent les coordonnées (x_sup, y_sup) du coin supérieur gauche de l'affichage. Le paramètre image est une variable sans type contenant la description point par point de l'image à afficher. Sa taille totale est fournie par ImageSize. Enfin, le dernier paramètre donne la manière dont les bits de l'image doivent être traités avant l'affichage.
Les Constantes suivantes sont définies par l'unité Graph :
Nom valeur opération
NormalPut = 0 Mov
XOrput = l XOr
OrPut = 2 Or
AndPut = 3 And
NotPut = 4 Not
Exemple
PutImage (150, 150, point_image^, NormalPut);
L'image stockée dans point_image^ est affichée à partir du point (150, 150) en affichage normal.
PutPixel
Procédure GRAPH : 4, 5, 6
Syntaxe
PutPixel (x, y, coul);
où x et y sont des expressions de type Integer et coul une expression de type Word.
Description
La procédure PutPixel dessine un point aux coordonnées (x, y) de couleur coul. Les coordonnées sont calculées à partir du bord supérieur gauche de la fenêtre en cours. Les couleurs sont numérotées à partir de 0 jusqu'à une valeur qui ne peut dépasser 15. Suivant le type de matériel et le mode choisi le nombre de couleurs Varie ainsi que la signification de chaque nombre.
Remarque
Le mode graphique doit être actif, sinon une erreur BGI Error: Graphics not initialized (use InitGraph) est renvoyée par le système.
Exemple
PutPixel (Random (GetMaxX), Random(GetMaxY), 1);
Un pixel est écrit de manière aléatoire en couleur 1.
Random
Fonction : Real, Word 3, SYS : 4, 5, 6
Syntaxe
Random (max)
où max (optionnel) est un paramètre de type entier.
Description
La fonction Random renvoie un nombre aléatoire compris entre 0 et max. Si le paramètre max est présent il doit être de type Word et le résultat renvoyé par la fonction sera de type Word. Si le paramètre max est omis, le nombre renvoyé sera de type Real, toujours compris entre 0 et 1.
Remarques
· Un paramètre de type réel n'est pas autorisé.
· Les nombres générés ne sont évidemment pas aléatoires au sens mathématique du terme. On devrait plutôt parler de nombres pseudo-aléatoires.
· La fonction Random devrait toujours être Initialisée par un appel à la procédure Randomize. Sans l'emploi de Randomize, chaque appel à Random risque de donner la même valeur.
Exemple
a := Random (100);
La variable a reçoit une valeur aléatoire comprise entre 0 et 100.
Randomize
Procédure 3, SYS : 4, 5, 6
Syntaxe
Randomize;
Description
La procédure Randomize Initialise le compteur du générateur de nombres aléatoires Random. Cette Initialisation est basée sur la valeur de l'horloge du PC. Sans l'emploi de Randomize, chaque appel à Random risque de donner la même valeur.
Les nombres générés ne sont évidemment pas aléatoires au sens mathématique du terme. On devrait plutôt parler de nombres pseudo-aléatoires.
Remarque
A partir de Turbo Pascal 4, la génération du nombre aléatoire est également basée sur une variable prédéfinie : RandSeed (LongInt). Affecter une valeur à RandSeed permet de modifier la séquence de génération des nombres aléatoires, même si l'horloge est calée sur une heure donnée. Cela rend, par exemple, beaucoup plus difficile le décryptage de données confidentielles puisque l'on travaille avec deux paramètres au lieu d'un.
Exemple
Randomize;
a := Random (100);
La variable a reçoit une valeur aléatoire comprise entre 0 et 100 différente suivant l'instant auquel l'appel à Randomize a été effectué.
Read
Procédure 3, SYS : 4, 5, 6
Syntaxe
Read (fich, Var1, Var2,...);
où fich est une variable optionnelle de type fichier (typé ou Text) et Var1, Var2,... les Variables qui recevront les éléments lus.
Description
La procédure Read permet de lire dans un fichier ou sur un périphérique et de recopier les données lues dans des Variables en mémoire centrale. Si aucun nom de fichier n'est donné, le clavier sera considéré comme fichier Text par défaut.
Remarques
· Avant toute opération de lecture, les fichiers doivent être ouverts avec Assign et Reset, Rewrite ou Append.
· II doit y avoir correspondance de type entre les données qui sont lues et les Variables en mémoire.
· Si Read ne peut lire correctement, une erreur est renvoyée par l'Intermédiaire de IoResult. Toutefois, pour éviter que le programme ne se termine prématurément, la directive de compilation {$I-} doit avoir été spécifiée.
· Sur un fichier de type Text, la plus grande chaîne qui peut être lue en une fois va de la position du curseur à la fin de la ligne. Sur des fichiers non typés, utilisez BlockRead.
Exemple
Read (fich, enreg);
Read (nbre1, nbre2, nbre3);
La variable enreg est lue sur le fichier fich. Les Variables nbre1, nbre2 et nbre3 sont lues à l'écran. Remarquez que rien dans la syntaxe de l'Instruction ne permet de dissocier une lecture à l'écran d'une lecture dans un fichier. Il est donc important d'utiliser des identificateurs « parlants ».
ReadKey
Fonction : Char DOS : 4, 5, 6
Syntaxe
ReadKey
Description
La fonction ReadKey renvoie un caractère frappé au clavier sans le visualiser à l'écran. Elle est capable de diagnostiquer certains caractères spéciaux comme des frappes de touches de fonction et des combinaisons comme « Ctrl-lettre », ce que Read et ReadLn ne font pas.
Remarques
· Lorsqu'un caractère spécial est tapé au clavier, deux
caractères sont renvoyés, le premier est toujours
« #0
» et le second le code géographique de la touche
enfoncée. Ce code est dit géographique car il dépend
de sa position sur le clavier QWERTY.
· Toutes les combinaisons possibles du clavier ne sont pas reconnaissables.
Exemple
Program codecar;
Uses Crt;
Var ch1, ch2 : Char;
Begin
ch1 := ReadKey;
If ch1 = #0 Then
Begin
ch2 := ReadKey;
WriteLn ('Premier code ASCII : Ord(ch1), ' second ',Ord(ch2));
End
Else WriteLn ('Un caractère : ',ch1);
End.
Ce petit programme permet de visualiser les touches enfoncées du clavier.
ReadLn
Procédure 3, SYS : 4, 5, 6
Syntaxe
ReadLn (fich, Var1, Var2,...)
où fich est une variable de type fichier Text (optionnel) et Var1, Var2,... les Variables qui recevront les éléments lus.
Description
La procédure ReadLn permet de lire dans un fichier ou sur un périphérique et de recopier les données lues dans des Variables en mémoire centrale. Lorsque les différentes Variables sont lues, il force le passage à la ligne suivante, même s'il reste des données sur la ligne en cours. Si aucun nom de fichier n'est donné, le clavier sera considéré comme source par défaut.
Remarques
· Avant toute opération de lecture les fichiers Text doivent être ouverts avec Assign et Reset.
· ReadLn ne peut être utilisé que sur des fichiers de type Text ou associés, comme le clavier.
· Il doit y avoir correspondance de type entre les données qui sont lues et les Variables en mémoire.
· Si ReadLn ne peut lire correctement, une erreur est renvoyée par l'Intermédiaire de IoResult. Toutefois, pour éviter que le programme ne se termine prématurément, la directive de compilation {$I-} doit avoir été spécifiée.
· ReadLn utilisé seul permet de passer directement à la ligne suivante sur un fichier ou d'attendre la frappe de Enter au clavier.
Exemple
ReadLn (nbre1, nhre2, nhre3);
ReadLn (texte, ligne) ;
Les Variables nbre1, nbre2 et nbre3 sont lues à l'écran. La variable ligne est lue sur le fichier texte. Remarquez que rien dans la syntaxe de l'Instruction ne permet de dissocier une lecture à l'écran d'une lecture dans un fichier. Il est donc important d'utiliser des identificateurs « parlants ».
Real
Identificateur de type 3, 4, 5, 6
Syntaxe
identv1, identv2,... : Real; ou identt1, identt2,... = Real;
où identv1, identv2,... sont des identificateurs de Variables et identt1, identt2,... sont des identificateurs de types.
Description
Ce mot est utilisé lors de la déclaration de Variables
réelles ou de types réels au sens standard du Pascal. Une variable Real est
stockée en mémoire dans 6 octets, son domaine de validité est +/-2.9 x 10-39 à
+/-1.7 x 10+38, avec 11 à 12 décimales exactes. Le type Real est
compatible, dans son domaine de définition, avec les autres types de réels.
Remarques
· La valeur des Variables de ce type doit être comprise entre +/-2.9 x 10+39 et +/-1.7 x 10+38. Sur les nombres de type réel une vérification est effectuée en cas de surdépassement de capacité (overflow) mais pas en cas de sous-dépassement de capacité (underflow). Dans ce cas, il n'y a pas d'erreur d'exécution et le programme peut avoir un comportement aberrant.
· En Turbo Pascal 3 c'est le seul type de réel disponible, en Version 4 c'est le seul type de réel disponible si vous ne possédez pas de coprocesseur arithmétique au moment de la compilation. A partir de la version 5, vous pouvez disposer de l'émulation logicielle du coprocesseur directive de compilation {$E}.
Exemple
Type mesure = Real;
Var longueur, largeur : Real;
Le type mesure est défini comme synonyme du type Real et les Variables longueur et largeur sont déclarées de ce type.
Record
Mot réservé 3, 4, 5, 6
Syntaxe
Type identtype = Record
partie_fixe;
partie_variable;
End;
ou Var identVar : Record
partie_fixe;
partie_variable;
End;
où identtype et identver sont les identificateurs de type et de variable enregistrement, partie_fixe la liste des champs fixes de l'enregistrement et partie_variable une structure Case particulière qui permet de définir une partie variable dans l'enregistrement.
La partie fixe a la structure suivante :
Identch11, identch12,... : type1;
Identch21, identch22,... : type2;
...
Identchn1, identchn2,... : typen;
où identch11, identch12, sont les identificateurs de champs et type1, type2,... sont leurs types respectifs.
La partie variable est optionnelle et a une structure proche de celle d'une Instruction Case :
Case select : typeselec Of
et1 : (liste de champs 1);
et2 : (liste de champs 2);
... etn : (liste de champs n);
où select est l'identificateur du sélecteur, typeselec est le type du sélecteur, et1, et2, les listes de Constantes, les listes de champs entre parenthèses ont chacune la même forme qu'une partie fixe du Record.
Description
Ce mot réservé permet la déclaration de types (éventuellement de Variables) de type enregistrement. Le type enregistrement est un type structuré dans lequel les différents éléments nommés champs peuvent être de types différents (à la différence des Array).
Remarques
· Les champs peuvent être de n'importe quel type, y compris des enregistrements ou d'autres types structurés mais pas de type fichier.
· Si la déclaration comporte une partie variable, celle-ci doit être unique et placée à la fin de la déclaration.
· La structure Case ne comporte pas de End personnel. Comme elle est située à la fin de la déclarative, c'est le End de la fin du Record qui en tient lieu.
· Les champs d'un enregistrement sont accessibles en spécifiant le nom de la variable de type enregistrement, le symbole « . » et le nom du champ. Si de nombreux accès doivent être faits sur le même enregistrement, l'Instruction With permet de ne spécifier que le nom du champ.
Exemples
Var client : Record
nom, prenom : String[30];
age : Integer;
End;
Une variable client est définie de type enregistrement. Elle comporte deux champs de type String[30] : nom et prenom, et une variable entière : age.
Type resultat : Record
nom : String[30];
prenom : String[4];
Case annee : Integer Of
3 : (math1, math2, fran, all : Integer);
2 : (math, fran, all, ang :Integer);
1 : (math, fran, ang, socio : Integer);
End;
Un type résultat est déclaré comportant une partie fixe (nom, prenom et annee) et une variable. Celle-ci définit les différentes notes suivant l'année de cours suivie.
Rectangle
Procédure GRAPH : 4, 5, 6
Syntaxe
Rectangle (x_sup, y_sup, x_Inf, y_Inf);
où x_sup, y_sup, x_Inf et y_Inf sont des expressions de type Integer.
Description
La procédure Rectangle dessine les cotés d'un rectangle depuis le point supérieur gauche (x_sup, y_sup) jusqu'au point Inférieur droit (x_Inf, y_Inf). Le type du trait (continu, pointillé,... ) et l'épaisseur de la ligne sont définis par SetLineStyle, la couleur par SetColor. Suivant la définition de la fenêtre active donnée par SetViewPort, le rectangle peut ne pas être dessiné en entier. La manière dont les bords se comportent lors d'Intersections avec d'autres lignes est déterminée par SetWriteMode. La procédure Rectangle ne modifie pas la valeur du pointeur courant.
Remarque
Pour que le rectangle soit valide les deux points doivent se trouver dans l'écran et le deuxième point doit être plus bas et plus à gauche que le premier. Autrement dit :
0 <= x_sup < x_Inf <= GetMaxX
0 <= y_sup < y_Inf <= GetMaxY
Exemple
Rectangle (0, 0, GetMaxX, GetMaxY);
Un cadre est dessiné tout autour de l'écran
RegisterBGIDriver
Fonction : Integer GRAPH : 5, 6
Syntaxe
RegisterBGIDriver (point_pilote)
où point_pilote est de type Pointer.
Description
La fonction RegisterBGIDriver permet d'Intégrer, dans votre programme graphique, un pilote d'écran après sa lecture sur disque. Le paramètre point_pilote est un pointeur qui donne l'emplacement en mémoire de la fonte de caractères. Le résultat renvoyé Indique le numéro du pilote (positif) ou un code d'erreur (négatif).
Remarque
Il est nécessaire d'appeler RegisterBGIDriver après réservation d'un espace mémoire (GetMem, par exemple), après lecture sur disque (Assign, Reset et BlockRead, par exemple), avant l'appel à InitGraph.
Exemple
If RegisterBGIDriver (point_CGAVGA) >= grOk Then
Begin
WriteLn('erreur lors du chargement de "CGAVGA" ');
Halt(1);
End;
Le pilote pointé par point_CGAVGA est enregistré, la valeur retournée est utilisée pour arrêter le programme en cas d'erreur.
RegisterBGIFont
Fonction GRAPH : 5, 6
Syntaxe
RegisterBGIFont (point_fonte)
où point_fonte est de type Pointer.
Description
La fonction RegisterBGIFont permet d'Intégrer, dans votre programme graphique, une fonte de caractères après sa lecture sur disque. Le paramètre point_fonte est un pointeur qui donne l'emplacement en mémoire de la fonte. Le résultat renvoyé Indique le numéro de la police (positif) ou un code d'erreur (négatif). Cette fonction est souvent employée lors de l'utilisation de plusieurs fontes dans le même programme. En effet, pendant l'exécution du programme, la fonte est lue sur disque lors de chaque appel à SetTextStyle.
Remarque
Il est nécessaire d'appeler RegisterBGIFont : après réservation d'un espace mémoire (GetMem, par exemple), après lecture sur disque (Assign, Reset et BlockRead, par exemple), avant l'appel à InitGraph.
Exemple
If RegisterBGIFont (pointpol) > grOk Then
Begin
WriteLn('erreur lors du chargement de fonte');
Halt(1);
End;
La police pointée par poiIntpol est enregistrée, la valeur retournée est utilisée pour éventuellement arrêter le programme.
Release
Procédure 3, SYS : 4, 5, 6
Syntaxe
Release (p);
où p est une variable de type pointeur sans type (déclarée Pointer).
Description
La procédure Release a pour effet de détruire toutes les Variables dynamiques créées à une adresse supérieure à celle du pointeur transmis comme argument. L'espace mémoire est libéré et les pointeurs prennent une valeur non définie. Après l'appel à Release il n'est plus possible d'utiliser les Variables dynamiques détruites.
Remarques
· L'utilisation de Mark et Release est difficilement compatible avec celle de Dispose et de FreeMem. En effet, ces dernières procédures risquent de libérer de l'espace mémoire à des adresses Inférieures à celle qui a été renvoyée par Mark. Cet espace a pu être réutilisé pour de nouvelles Variables dynamiques, créées après l'appel à Mark. Dans ces conditions, rien ne garantit donc que toutes les Variables dynamiques créées après l'appel à Mark seront effacées.
· L'appel à Mark a pour effet d'effacer le contenu de la table des fragments. En pratique, cela signifie que s'il existe des blocs de mémoire libre sous l'adresse transmise par Mark, ceux-ci seront oubliés par le gestionnaire du tas et ne pourront plus être réutilisés par la suite.
· La variable prédéfinie HeapOrg contient l'adresse de l'origine du tas. Donc, Release (HeapOrg) détruit toutes les Variables dynamiques et libère toute la mémoire.
Exemple
New (pt_ligne1);
Mark (sommet);
New (pt_ligne2);
New (pt_ligne3);
Release (sommet);
Mark mémorise la valeur du pointeur du sommet du tas. Release détruit les Variables dynamiques pointées par pt_ligne2 et pt_ligne3 pour autant que ni Dispose ni FreeMem ne soient utilisés entre-temps.
Rename
Procédure 3, SYS : 4, 5, 6
Syntaxe
Rename (fich, nouveau_nom);
où fich est une variable fichier de type quelconque et nouveau_nom une variable ou une Constante de type chaîne de caractères.
Description
La procédure Rename permet de donner un nouveau nom, au sens de Ms-Dos, à une variable de type fichier. Elle peut porter Indifféremment sur tous les fichiers : typés, texte ou non typés. Comme les répertoires sont immédiatement mis à jour les opérations ultérieures sur la variable de type fichier porteront sur le nouveau fichier du disque.
Remarques
· Avant toute opération de lecture les fichiers doivent être ouverts avec Assign et Reset, Rewrite ou Rewrite.
· Si ReadLn ne peut lire correctement, une erreur est renvoyée par l'Intermédiaire de IoResult. Toutefois, pour éviter que le programme ne se termine prématurément, la directive de compilation {$I-} doit avoir été spécifiée.
Exemple
Rename ( fich, ' clients.bak' );
Le fichier fich portera à présent le nom de 'clients bak' .
Repeat
Mot réservé 3, 4, 5, 6
Syntaxe
Repeat
Instr1;
Instr2;
...
Instrn;
Until expbool;
où Instr1, Instr2,... sont des Instructions simples ou composées et expbool est une expression à valeur booléenne.
Description
Cette Instruction répétitive permet de répéter une série d'Instructions simples ou composées jusqu'à ce qu'une expression booléenne soit vraie (True).
L'expression booléenne peut être une variable booléenne, une opération de comparaison, une fonction de type booléen et faire appel aux opérateurs booléens (Not, And, Or, XOr).
Remarques
· Dans une boucle Repeat, les Instructions sont exécutées au moins une fois avant que l'expression booléenne ne soit évaluée. On la préférera donc à la boucle While lorsque l'évaluation de l'expression booléenne dépend des Instructions répétées.
· II est nécessaire qu'une Instruction, au moins, rende l'expression vraie, sinon la boucle s'exécute indéfiniment.
· A l'Inverse des autres structures de contrôle, c'est bien plusieurs Instructions qui pourront être répétées et non une seule simple ou composée. En pratique, cela signifie qu'un bloc Begin...End n'est pas nécessaire.
Exemple
Repeat
val1 := val1 * 1.08;
va12 := va12 * 1.1;
WriteLn (val1, va12);
Until (val1 > 45) And (val2 > 55;
Il est bien sûr nécessaire que les valeurs Initiales de val1 et de val2 soient supérieures à 1 pour que l'on puisse sortir de la boucle.
Reset
Procédure 3, SYS : 4, 5, 6
Syntaxe
Reset (fich);
où fich est une variable fichier de type quelconque.
Description
La procédure Reset permet d'ouvrir un fichier. Elle est utilisée après Assign et avant toute opération d'entrée/sortie. L'effet de Reset est différent sur des fichiers typés et non typés, d'une part et Text d'autre part. Sur des fichiers typés et non typés, après Reset, des opérations de lecture et d'écriture sont permises. Sur des fichiers Text seules les opérations de lecture sont autorisées.
Remarques
· Reset doit être précédé de l'appel à Assign afin de faire correspondre la variable de type fichier au fichier physique sur le disque.
· Après Reset, le pointeur de fichier est positionné sur le premier élément du fichier. Si le fichier est vide, Eof est vrai.
· Si le fichier était déjà ouvert (à l'aide de Reset, Rewrite ou Append) le fichier est tout d'abord fermé et ensuite rouvert. Ceci est particulièrement important pour des fichiers texte qui font nettement la différence entre l'ouverture en écriture (Rewrite ou Append) et en lecture (Reset).
· Pour les fichiers non typés, il est possible d'utiliser un second paramètre définissant la taille des enregistrements à utiliser lors des opérations d'entrée/sortie. La syntaxe est alors Reset (fich, taille) où taille est une variable ou une Constante de type Word.
· Si le fichier n'existe pas, une erreur est renvoyée par l'Intermédiaire de IoResult pour autant que la directive de compilation {$I-} ait été employée.
Exemple
Assign (fich, 'C:\DATA\CLIS');
{$I-}
Reset (fich);
If IoResult <> 0 Then Rewrite fich;
{$I+}
La variable fich est associée au fichier C:\DATA\CLIS. Une Initialisation à l'aide de Reset est effectuée, si une erreur est renvoyée par IoResult, le fichier est créé à l'aide de Rewrite.
RestoreCrtMode
Procédure GRAPH : 4, 5, 6
Syntaxe
RestoreCrtMode;
Description
La procédure RestoreCrtMode permet, à tout moment, de passer du mode graphique au mode texte. Le mode texte est celui précédant l'appel à InitGraph tel qu'il l'a détecté. Ce passage se fait sans vider de la mémoire les fichiers graphiques. La mémoire utilisée par ceux-ci n'est donc pas récupérée. SetGraphMode permet alors de revenir au mode graphique sans devoir repasser par InitGraph. Par opposition, la procédure CloseGraph est destinée à clôturer définitivement la session graphique et à libérer totalement la mémoire utilisée par les fichiers graphiques.
Remarque
Le mode graphique doit être activé, sinon le système retourne l'erreur : BGI Error: Graphics not initialized (use InitGraph).
Exemple
pilote := EGA; mode := EGAHi;
InitGraph (pilote, mode, 'C:\TP\BGI');
...
RestoreCrtMode;
...
SetGraphMode (GetGraphMode);
...
CloseGraph;
Après être passé temporairement au mode texte RestoreCrtMode, le mode graphique est rétabli par SetGraphMode dans le mode graphique déterminé par InitGraph.
Rewrite
Procédure 3, SYS : 4, 5, 6
Syntaxe
Rewrite (fich)
où fich est une variable fichier de type quelconque.
Description
La procédure Rewrite permet de créer un nouveau fichier ou de réinitialiser un fichier existant. Elle est utilisée après Assign et avant toute opération d'entrée/sortie. L'effet de Rewrite est différent sur des fichiers typés et non typés, d'une part et texte d'autre part. Sur des fichiers typés ou non typés, après Rewrite, des opérations de lecture et d'écriture sont permises. Sur des fichiers textes seules les opérations d'écriture sont autorisées.
Remarques
· Rewrite doit être précédé de l'appel Assign afin de faire correspondre la variable de type fichier au fichier physique sur le disque.
· Si le fichier existe déjà, il est effacé et ensuite recréé.
· Après Rewrite, le pointeur de fichier est positionné au début du fichier. Eof est toujours vrai.
· Si le fichier est déjà ouvert (à l'aide de Reset, Rewrite ou Append) le fichier est tout d'abord fermé et ensuite recréé. Ceci est particulièrement important pour des fichiers texte qui font nettement la différence entre l'ouverture en écriture (Rewrite ou Append) et en lecture (Reset).
· Pour les fichiers non typés, il est possible d'utiliser un second paramètre définissant la taille des enregistrements à utiliser lors des opérations d'entrée/sortie. La syntaxe est alors Reset (fich, taille) où taille est une variable ou une Constante de type Word.
· Si le fichier ne peut être créé, une erreur est renvoyée par l'Intermédiaire de IoResult pour autant que la directive de compilation {$I-} ait été employée.
Exemple
Assign (fich, 'C:\DATA\CLIENTS');
{$I-}
Reset (fich);
If IoResult <> 0 Then Rewrite fich;
{$I+}
La variable fich est associée au fichier C:\DATA\CLIENTS. Une Initialisation à l'aide de Reset est effectuée, si une erreur est renvoyée par IoResult, le fichier est créé à l'aide de Rewrite.
RmDir
Procédure 3, SYS : 4, 5, 6
Syntaxe
RmDir (reper);
où reper est une variable ou une Constante de type chaîne de caractères.
Description
La procédure RmDir permet de supprimer un répertoire depuis un programme Turbo Pascal. Le nom du répertoire, utilisé comme argument, peut comporter également le nom de l'unité sur laquelle ce répertoire doit être créé.
Remarques
· Les règles générales à observer sont les mêmes que celles en vigueur au sein de Ms-Dos. Un répertoire ne peut être effacé que s'il ne contient plus de fichier ni de sous-répertoire.
· Si l'unité spécifiée n'existe pas ou qu'il est impossible de supprimer le répertoire (voir plus haut), une erreur est renvoyée par l'Intermédiaire de IoResult. Toutefois, pour éviter que le programme ne se termine prématurément, la directive de compilation {$I-} doit avoir été spécifiée.
Exemple
{SI-}
RmDir ('A:\DATA');
{$I+}
Le répertoire \DATA de l'unité A: est effacé.
Round
Fonction : (Integer) LongInt (3) SYS : 4, 5, 6
Syntaxe
Round (r)
où r est une expression de type Real.
Description
La fonction Round renvoie l'entier le plus proche d'une expression réelle. Si cette expression contient une partie décimale celle-ci sera arrondie et non simplement tronquée. Cette fonction est proche de la fonction Int, en effet, Round (r) est égal à Int (r + 0,5) si r est positif et à Int (r - 0,5) si r est négatif.
Remarque
En Turbo Pascal 3, Round était de type Integer.
Exemples
Si res := Round (23.4) alors res = 23
Si res := Round (-23.7) alors res = -24
Si res := Round (12.5) alors res = 13
RunError
Procédure SYS : 5, 6
Syntaxe
RunError (nbre)
où nbre (paramètre optionnel) est une variable ou une Constante de type Word.
Description
Cette procédure est semblable dans son effet à la procédure Halt : elle provoque l'arrêt du programme ou du sous-programme en cours. Le paramètre nbre (optionnel) permet d'Indiquer, par exemple, le type d'erreur qui a provoqué l'arrêt du programme.
La différence avec Halt réside dans la manière dont le paramètre est traité. En fait, l'erreur provoquée est semblable à une erreur d'exécution d'un programme Turbo Pascal. Le paramètre nbre est directement affiché à l'écran et peut être utilisé par l'environnement de travail, le débogueur, comme une erreur d'exécution ordinaire.
Remarques
· Les erreurs d'exécution actuellement Installées dans le compilateur sont toutes comprises entre 0 et 255 avec de nombreux codes non définis. Le paramètre étant de type Word (de 0 à 65 535), il reste beaucoup de place pour définir ses propres erreurs d'exécution. Cependant rien ne garantit (surtout entre 0 et 255) que ces nombres ne seront pas utilisés par de futures versions du compilateur.
· II n'est pas possible de personnaliser le message qui accompagne l'erreur d'exécution provoquée. Ceci est particulièrement important si on utilise un numéro d'erreur déjà défini par Turbo Pascal ce qui est parfaitement permis.
Exemple
{SI-}
ReadLn (fich, elem);
Ok := IoResult;
If Ok <> 0 Then RunError (250);
{SI+}
Une opération de lecture est effectuée sur le fichier fich, si elle échoue le programme est arrêté par RunError et la valeur 250 est renvoyée.
Sector
Procédure GRAPH : 4, 5
Syntaxe
Sector(x, y, angle_a, angle_b, axe_x, axe_y) ;
où x et y sont de type Integer et angle_a, angle_b, axe_x et axe_y de type Word.
Description
La procédure Sector dessine un secteur d'ellipse. Le centre de l'ellipse est le point de coordonnées (x, y), la longueur de l'axe vertical par axe_x, de l'axe horizontal par axe_y. Le secteur est délimité par angle_a et angle_b. La surface est remplie avec le motif et la couleur définis à l'aide de SetFillStyle et éventuellement de SetFillPattern. De plus, les contours du secteur sont dessinés dans la couleur définie par SetColor.
Suivant la définition de la fenêtre active donnée par SetViewPort, le secteur d'ellipse peut ne pas être dessiné en entier.
Exemple
Sector (200, 200, 180, 270, 150, 50);
Un secteur d'ellipse est dessiné dont le centre est le point (200, 200), l'axe X = 150, Y = 50 et dont les limites sont 180 et 270 degrés.