Seek

Procédure 3, SYS : 4, 5, 6

Syntaxe

Seek(fich, nbre);

où fich est une variable de type fichier typé ou non typé et nbre une variable de type Integer en Turbo Pascal 3 et Word à partir de la version 4.

Description

La procédure Seek permet de placer la fenêtre de lecture/écriture sur un élément déterminé d'un fichier typé ou non typé. Les éléments sont comptés, comme avec la procédure FilePos, à partir de zéro. En pratique, Seek (fich, 0) a le même effet que Reset (fich) : positionner la fenêtre sur le premier élément. Seek (fich, FilePos(fich)) n'a aucun effet. Seek (fich, FileSize(fich)) positionne la fenêtre juste après la fin du fichier et seule une opération d'écriture est encore possible.

Remarques

· Seek doit être précédé de l'appel à Assign afin de faire correspondre la variable de type fichier au fichier physique sur le disque.

· Seek ne peut être utilisé sur des fichiers de texte (Text).

· Si une erreur survient, un code est renvoyé par l'Intermédiaire de IoResult pour autant que la directive de compilation {$I-} ait été employée.

Exemple

Seek (data, 20);

La fenêtre de lecture/écriture est placée sur le 21^e l'élément du fichier data.

SeekEof

Fonction : Boolean 3, SYS : 4, 5, 6

Syntaxe

SeekEof (fich) 

où fich est une variable de type fichier de texte (Text).

Description

La fonction booléenne SeekEof renvoie True si la fenêtre de lecture/écriture est positionnée juste avant la fin du fichier et toujours True le fichier est vide. Elle renvoie faux dans les autres cas. A la différence de Eof, elle ignore les blancs et les tabulations pouvant se trouver en fin de texte.

Remarques

· SeekEof doit être précédé de l'appel à Assign et à Reset, Rewrite ou Append.

· SeekEof ne peut être utilisé que sur des fichiers de texte (Text).

· Si une erreur survient, un code est renvoyé par l'Intermédiaire de IoResult pour autant que la directive de compilation {$I-} ait été employée.

Exemple

If SeekEof (donnee) Then Append (donnee); 

Le fichier texte donnee est rouvert en mode ajout s'il n'y a plus de caractère significatif à la fin du fichier.

SeekEoLn

Fonction : Boolean 3, SYS : 4, 5, 6

Syntaxe

SeekEoLn (fich) 

où fich est une variable de type fichier de texte (Text).

Description

La fonction booléenne SeekEoLn renvoie True si la fenêtre de lecture/écriture est positionnée juste avant la fin de la ligne et toujours True si le fichier est vide. Elle renvoie faux dans les autres cas. A la différence de Eoln, elle ignore les blancs et les tabulations pouvant se trouver en fin de ligne ou de texte.

Remarques

· SeekEoLn doit être précédé de l'appel à Assign et à Reset, Rewrite ou Append.

· SeekEoLn ne peut être utilisé que sur des fichiers de texte (Text).

· Si une erreur survient, un code est renvoyé par l'Intermédiaire de IoResult pour autant que la directive de compilation {$I-} ait été employée.

Exemple

If (SeekEoLn (donnee) And (Not SeekEof (donnee)) Then ReadLn (donnee); 

S'il n'y a plus de caractère significatif avant la fin de la ligne courante et que l'on n'est pas sur la dernière ligne du fichier donnée, un appel à ReadLn est effectué pour passer à la ligne suivante.

Seg

Fonction : (Integer) Word   (3) SYS : 4, 5, 6

Syntaxe

Seg(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 Seg renvoie la partie segment du premier octet de l'adresse d'un identificateur (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 affiche le segment puis l'offset de l'adresse de la variable bool.

Set

Mot réservé 3, 4, 5, 6

Syntaxe

Type identyp = Set Of typbase; 
Var identVar : Set Of typbase; 

où identyp et identVar sont des identificateurs de type ou de variable, et typbase un type scalaire.

Description

Ce mot réservé est utilisé dans la déclaration d'une variable ou d'un type structuré en ensemble. Un ensemble (SET) est une collection d'objets du même type : le type de base. En Turbo Pascal, le type de base ne peut accepter plus de 256 valeurs dont les bornes sont comprises dans l'Intervalle 0.. 255. Le type de base peut donc être de type Byte, Boolean Char, énuméré de moins de 256 éléments (ou un Intervalle de ceux-ci) et un Intervalle de ShortInt, Integer, LongInt et Word.

Remarques

· Comme pour toutes les autres Variables, sans Initialisation, le contenu des Variables Set est indéterminé. Lors de la déclaration, on a spécifié les éléments possibles et non le contenu de l'ensemble :

Type lettre = Set Of Char;

Var voyelles, cons, premieres :

· Une affectation à une variable de type ensemble se fait en plaçant les éléments entre crochets. Ils peuvent être cités en les énumérant (séparés par des virgules), en spécifiant un Intervalle (séparés par deux points) ou en combinant les deux méthodes.

voyelles := ['a', 'e', 'i', 'o', 'u', 'y'];
premieres := ['a'.. 'd'];
cons := ['b'..'d', 'f'..'h', 'j'..'n', 'p'..'t', 'v'..'x', 'z'];

· Un ensemble vide s'Indique en ne spécifiant pas d'éléments : hvide := [];

· Les opérateurs suivants peuvent porter sur des opérandes de type ensemble :

op.   descr         op1 op2 res 
+     union         set set set 
-     différence    set set set 
*     intersection  set set set 
=     égalité       set set bool 
<>    différence    set set bool 
<=    inclus        set set bool 
>=    comprend      set set bool 
In    appartient    él. set bool 

SetActivePage

Procédure GRAPH : 4, 5, 6

Syntaxe

SetActivePage(page);

où page est une expression de type Word.

Description

La procédure SetActivePage détermine la page vers laquelle les sorties graphiques sont envoyées. cette procédure ne doit pas être confondue avec SetVisualPage qui détermine quelle est la page graphique affichée. Sur les systèmes possédant au moins deux pages graphiques, il peut être Intéressant d'effectuer les dessins en arrière-plan, sur la page graphique qui n'est pas affichée. Le dessin terminé, on activera l'affichage de cette page.

Remarques

· Les pages graphiques sont numérotées à partir de 0.

· Tous les systèmes et tous les modes ne possèdent pas plusieurs pages graphiques, en voici les principaux :

- CGA et MGCA 1 page,

- EGA 1, 2 ou 4 pages suivant le mode,

- Hercules : toujours 2 pages,

- VGA : 4, 2 ou 1 page suivant le mode.

· La liste complète des différents pilotes, modes et nombres de pages est donnée sous la rubrique InitGraph.

Exemple

Randomize;
SetVisualPage (0); 
SetActivePage (1); 
For i := 1 To 1000 Do OutTextXY (Random (GetMaxX),
Random(GetMaxY), Chr(Random(255))); 
SetVisualPage (1); 

La page à l'écran est tout d'abord la page 0, tandis que la page active est la page 1. Mille caractères sont écrits de manière aléatoire. Ensuite, la page 1 est visualisée.

SetAllPalette

Procédure GRAPH : 4, 5, 6

Syntaxe

SetAllPalette(palette);

où palette est une variable de type PaletteType définie par l'unité Graph de la manière suivante :

Const MaxColors = 15; 

Type PaletteType = Record
  Sixe  : Byte; 
  Colors : Array[O..MaxColors] Of ShortInt; 
  End;

Description

La procédure SetAllPalette permet de modifier, en un seul appel, l'ensemble de la palette courante. Il est nécessaire de donner une valeur à une variable du type PaletteType en précisant le nombre d'éléments dans la palette et la valeur pour chaque couleur. La valeur -1 Indique que l'on ne désire pas changer, pour ce numéro, la valeur en cours.

Remarques

· La liste des Constantes de couleur est donnée sous la rubrique SetPalette.

· En mode IBM-8514 et VGA 256 couleurs, il n'est pas possible d'utiliser SetAllPalette, il est nécessaire de passer par SetRGBPalette.

Exemple

pal.Sixe := 6; 
pal.Colors[0] := Red; 
pal.Colors[1] := Green;
pal.Colors[2] := Blue; 
pal.Colors[3] := Magenta; 
pal.Colors[4] := Cyan; 
pal.Colors[5] := Yellow; 
SetAllPalette (pal); 

La palette est modifiée de la manière suivante : couleur 0 = rouge, couleur 1 = vert, couleur 2 = bleu, etc.

SetAspectRatio

Procédure GRAPH : 5, 6

Syntaxe

SetAspectRatio(num, denom);

où num et denom sont des expressions de type Word.

Description

La procédure SetAspectRatio permet de modifier la manière dont les cercles sont dessinés à l'écran. En effet dans certains cas, l'appel à la fonction Circle ne produit pas un cercle parfait au sens mathématique du terme. Les paramètres num et denom permettent d'Introduire un facteur de correction remédiant aux imperfections de nos écrans. Ce facteur de correction est donné par ratio = num/denom.

Remarque

La procédure SetAspectRatio porte sur les cercles créés par les procédures Circle, Arc et PieSlice, mais pas sur les autres formes comme Rectangle ou Ellipse. Il est toutefois possible de se servir des valeurs renvoyées par GetAspectRatio pour effectuer soi-même une correction.

Exemple

For num := l To 10 Do 
  For denom := 1 To 10 Do 
    Begin 
    SetAspectRatio (num, denom); 
    Circle (150, 150, 100); 
    Str (num, st1); 
    Str (denom, st2); 
    OutTextXY (300, 150, ' num : '+ st1 + ' denom : ' + st2); 
    ReadLn;
    ClearDevice; 
    End;

Ce petit morceau de programme vous permet de visualiser un cercle avec 10 valeurs différentes de num et de denom pour déterminer quelle est la plus appropriée dans votre cas.

SetBkColor

Procédure GRAPH : 4, 5, 6

Syntaxe

SetBkColor (couleur) 

où couleur est une expression de type Word.

Description

La procédure SetBkColor permet de choisir, dans la palette actuellement définie, la couleur utilisée pour le fond. Sauf avec le pilote IBM-8514, la palette est une table de 16 couleurs, les valeurs permises pour le paramètre vont de 0 à 15. Tous les adaptateurs graphiques ne disposent pas de 16 couleurs différentes. De plus, pour certains pilotes on peut disposer de plusieurs modes, certains privilégiant le nombre de couleurs, d'autres la définition. Dans tous les cas, le nombre de couleurs dans la palette est renvoyé par GetMaxColor.

Remarques

· Les procédures et fonctions GetMaxColor, GetPalette, GetPaletteSize, GetDefaultPalette, SetPalette et SetAllPalette sont utilisées pour accéder à la palette.

· Le pilote et le mode sont déterminés par InitGraph et SetGraphMode. La palette est déterminée par SetPalette et SetAllPalette.

Exemple

For i := 0 To GetMaxColor Do 
  Begin
  SetColor (i); 
  OutTextXY (20, 10 * i, ' Couleur ');
  End;

Le mot Couleur est écrit dans les couleurs disponibles.

SetCbreak

Procédure DOS : 4, 5, 6

Syntaxe

SetCbreak (oui_non);

où oui_non est une variable ou une Constante Boolean.

Description

La procédure SetCbreak permet, depuis l'intérieur d'un programme Pascal, de configurer la variable Break de MsDos. Lorsqu'elle est à Onla séquence Ctrl-Break est testée à chaque appel d'Interruption système, lorsqu'elle est à Off, elle n'est testée que lors des opérations d'entrée-sortie.

Remarque

La procédure GetCBreak permet de tester si Ctrl-Break est On ou Off.

Exemple

SetCbreak (cb );
If cb Then
  Begin
  WriteLn (' cb est On ') ; 
  SetCbreak (False); 
  WriteLn (' puis Off ');
  End 
Else 
  Begin 
  WriteLn (' cb est Off ') ; 
  SetCbreak (True); 
  WriteLn (' puis On '); 
  End; 

La valeur de la variable Break de Ms-Dos est récupérée par GetCBreak, affichée puis Inversée.

SetColor

Procédure GRAPH : 4, 5, 6

Syntaxe

SetColor (couleur);

où couleur est une expression de type Word.

Description

La procédure SetColor permet de choisir, dans la palette actuellement définie, la couleur utilisée pour les dessins. Sauf en mode 8514, la palette est une table de 16 couleurs, les valeurs permises pour le paramètre vont de 0 à 15. Cependant tous les adaptateurs graphiques ne disposent pas de 16 couleurs différentes. Pour certains pilotes on peut disposer de plusieurs modes, certains privilégiant le nombre de couleurs, d'autres la définition. Le nombre de couleurs est renvoyé par GetMaxColor.

Remarques

· SetColor ne concerne que les procédures de tracé de ligne : Line, LineTo, LineRel, Circle, DrawPoly, Ellipse et Rectangle. Les procédures de dessin de surface : Bar, Bar3D, FillEllipse, FillPoly, FloodFill, PieSlice ont leur couleur déterminée par SetFillStyle.

· Les procédures et fonctions GetMaxColor, GetPalette, GetPaletteSize, GetDefaultPalette, SetPalette et SetAllPalette sont utilisées pour accéder à la palette.

· Le pilote et le mode sont déterminés par InitGraph et SetGraphMode, la palette par SetPalette et SetAllPalette.

Exemple

SetColor (2); 

La couleur 2 de la palette sera celle du dessin des lignes.

SetDate

Procédure DOS : 4, 5, 6

Syntaxe

SetDate (annee, mois, jour);

où annee, mois et jour sont de type Intervalle de Word.

Description

Cette procédure permet de changer la date telle qu'elle est connue par le système. Tous les paramètres utilisés sont de type Intervalle de Word :

annee : 1980..2099 
mois  : l..12 
jour  : l..31 

Remarque

Si la date renvoyée par le système est Invalide la procédure SetDate n'a pas d'effet.

Exemple

Write (' Année ? ') ; ReadLn (annee); 
Write (' Mois ? ') ; ReadLn (mois); 
Write (' Jour ? ') ; ReadLn (jour); 
SetDate (annee, mois, Jour); 

Les valeurs de l'année, du mois et du jour sont lues au clavier et transmises au système.

SetFAttr

Procédure DOS : 4, 5, 6

Syntaxe

SetFAttr (fichier, attr);

où fichier est une variable de type File et attr une variable ou une Constante de type Word.

Description

La procédure SetFAttr permet de définir le ou les attributs d'un fichier Ms-Dos.

L'attribut du fichier (attr) peut prendre les valeurs (prédéfinies dans l'unité Dos) suivantes :

ReadOnly  = $01; {lecture seulement} 
Hidden = $02; {caché} 
SysFile  = $04; {système} 
VolumeID  = $08; {nom d'unité} 
Directory = $10; {nom de répertoire} 
Archive  = $20; {à archiver} 
anyFile  = $3F; {n'importe} 

Lorsque plusieurs attributs sont présents, les codes sont additionnés, par exemple $03 signifie un fichier caché en lecture seulement ($02 + $01).

Remarques

· La variable de type fichier doit avoir été mise en relation avec un fichier Ms-Dos à l'aide de Assign. Mais ce fichier ne peut avoir été Initialisé à l'aide de Reset, Rewrite ou Append.

· Si la procédure échoue, un code erreur est renvoyé par l'Intermédiaire de la variable prédéfinie DosError :

3 : chemin non valide

5: accès refusé

· La procédure SetFAttr peut porter sur n'importe quel type de fichier : typé, texte, ou non typé.

Exemple

Assign (f, 'C:\AUTOEXEC.BAT'); 
SetFAttr (f, $01); 
GetFAttr (f, attribut); 
WriteLn (' Attributs de Autoexec.bat : ', attribut); 

L'attribut du fichier AUTOEXEC.BAT est mis à $01 (Read-Only), il est ensuite relu et affiché.

SetFillPattern

Procédure GRAPH : 4, 5, 6

Syntaxe

SetFillPattern(dessin, couleur);

où dessin est de type FillPatternType et couleur de type Word. Le type FillPatternType est prédéfini dans l'unité Graph de la manière suivante :

FillPatternType = Array [1..8] Of Byte; 

Description

La procédure FillPattern permet à l'utilisateur de définir lui-même le motif de remplissage utilisé pour certaines formes géométriques. Sont concernés : Bar, Bar3D, FillPoly et PieSlice. Les 8 Bytes correspondent chacun à une ligne et chaque bit à un pixel qui sera allumé s'il vaut 1 et éteint s'il vaut 0.

Exemple

 motif   bits   déc.  octet
I I I     I I I  1 1 1 0 0 1 1 1  231   1
  I I I I I I    0 1 1 1 1 1 1 0  126   2
    I I I I      0 0 1 1 1 1 0 0   60   3
      I I        0 0 0 1 1 0 0 0   24   4
      I I        0 0 0 1 1 0 0 0   24   5
    I I I I      0 0 1 1 1 1 0 0   60   6
  I I I I I I    0 1 1 1 1 1 1 0  126   7
I I I I I I I I  1 1 1 0 0 1 1 1  231   8

En Turbo Pascal :

des [1] := 231;
des [2] := 126; 
des [3] := 60;
des [4] := 24; 
des [5] := 24;
des [6] := 60; 
des [7] := 126;
des [8] := 231; 
SetFillPattern (des, 1); 
Bar (10, 10, 200, 200); 

Un rectangle est dessiné dans le motif de la variable des.

SetFillStyle

Procédure GRAPH : 4, 5, 6

Syntaxe

SetFillStyle(dessin, couleur);

où dessin et couleur sont des expressions de type Word.

Description

La procédure SetFillStyle définit le motif de remplissage et la couleur utilisés pour certaines formes géométriques. Sont concernés : Bar, Bar3D, FillPoly et PieSlice.

Les motifs suivants sont prédéfinis par l'unité Graph :

EmptyFill      =  0  fond (= effacement) 
SolidFill      =  1  couleur pleine 
LIneFill       =  2  traite horizontaux 
LtSlashFill    =  3  traits obliques /// 
SlashFill      =  4  traits obliques épais /// 
BkSlashFill    =  5  traits obliques épais \\\ 
LtskSlashFill  =  6  traits obliques \\\ 
HatchFill      =  7  motif l 
XHatchFill     =  8  motif 2 
InterLeaveFill =  9  motif 3 
WideDotFill    = 10  points peu denses 
CloseDotFill   = 11  points denses 
Userfill       = 12  défini par l'utilisateur 

Le paramètre couleur permet de choisir, dans la palette actuellement définie, la couleur utilisée pour les dessins. Comme la palette est une table de 16 couleurs, les valeurs permises pour le paramètre vont de 0 à 15. cependant tous les adaptateurs graphiques ne disposent pas de 16 couleurs différentes. De plus, pour certains pilotes on peut disposer de plusieurs modes, certains privilégiant le nombre de couleurs, d'autres la définition.

Remarque

Si le dessin vaut 12 (UserFill) c'est le motif de remplissage déterminé par SetFillPattern qui est utilisé.

Exemple

For i := 1 To 11 Do 
  Begin 
  Delay (1500); 
  ClearDevice; 
  SetFillStyle (i, 1); 
  Bar (0, 0, 200, 200); 
  Str (i, st); 
  OutTextXY (250, 250, st); 
  End;

Cet exemple permet de visualiser à l'écran les 11 motifs de remplissage prédéfinis par l'unité Graph.

SetFTime

Procédure DOS : 4, 5, 6

Syntaxe

SetFTime (fichier, heure_courte);

où fichier est une variable de type File et heure_courte une variable ou une constante de type LongInt.

Description

La procédure SetFTime permet d'imposer la date et l'heure de la dernière modification d'un fichier telles qu'elles sont connues par Ms-Dos. La date doit être présentée sous forme compactée. La manière la plus pratique est d'avoir recourt à la procédure PackTime.

Remarque

Le fichier doit avoir été assigné avec Assign et ouvert avec Reset, Rewrite ou Append avant de pouvoir y accéder par GetFTime. Sinon l'heure écrite est celle du jour ! La variable prédéfinie DosError peut renvoyer 6 si le nom du fichier est Incorrect.

Exemple

Assign (f, 'C:\AUTOEXEC.BAT'); 
Reset (f); 
With Split DO 
  Begin
  Year := 2010; Month := 11; Day := 11; 
  End; 
PackTime (split, heure); 
SetFTime (f, heure); 

La valeur 11 novembre 2010 est affectée à la variable split, celle-ci est ensuite compactée dans heure. Enfin, le fichier f (C:\AUTOEXEC.BAT) reçoit cette date.

SetGraphBufSize

Procédure   GRAPH : 6

Syntaxe

SetGraphBufSize(taille_tampon);

où taille_tampon est une expression de type Word.

Description

La procédure SetGraphBufSize permet de déterminer la taille de la mémoire tampon utilisée lors des opérations de remplissage de surfaces graphiques. Bien que la valeur par défaut (4 Ko) suffise dans l'immense majorité des cas, certaines figures extrêmement complexes peuvent nécessiter l'augmentation de cette mémoire tampon.

Remarque

L'appel à SetGraphBufSize doit précéder celui à InitGraph, Sinon, il est ignoré.

Exemple

SetGraphBufSize (8000); 

La taille de la mémoire tampon de remplissage est portée à 8 Ko.

SetGraphMode

Procédure GRAPH : 4, 5, 6

Syntaxe

SetGraphMode(mode);

où mode est une expression de type Integer.

Description

La procédure SetGraphMode est utilisée dans deux cas : premièrement lorsque l'affichage est en mode graphique pour changer de mode, deuxièmement pour revenir au mode graphique lorsque l'on est passé momentanément au mode texte.

Lorsque le mode graphique est Initialisé à l'aide de InitGraph, le programmeur est obligé de choisir un des modes de fonctionnement correspondant au matériel Installé. Si, par la suite, ce mode ne paraît pas le plus approprié, la procédure SetGraphMode permet de modifier le choix de départ. Cette modification se fait sans sortir du mode graphique.

Il est possible, à tout moment, de passer du mode graphique au mode texte à l'aide de la procédure RestoreCrtMode. Ce passage se fait sans vider de la mémoire les fichiers graphiques. SetGraphMode permet alors de revenir au mode graphique sans devoir repasser par InitGraph.

Après l'appel à SetGraphMode, l'ensemble du système graphique retrouve sa configuration par défaut : position du curseur en haut à gauche de l'écran, palette, taille des caractères,...

Exemples

RestoreCrtMode; 
...
SetGraphMode (GetGraphMode); 

Après être passé temporairement au mode texte, le mode graphique est rétabli avec le mode graphique qui était en cours.

pilote := EGA; 
mode : EGAHi; 
InitGraph (pilote, mode, 'C:\TP\BGI'); 
...
SetGraphMode (0); 

Après avoir été Initialisé à EGAHi, le système est mis en mode 0, c'est-à-dire EGALo.

SetIntVec

Procédure DOS : 4, 5, 6

Syntaxe

SetIntVec (numero, adresse);

où numero est de type Byte et adresse de type pointeur.

Description

La procédure SetIntVec modifie l'adresse vers laquelle pointe le vecteur d'une Interruption de numéro donné. En fait elle modifie pour une Interruption donnée la table des vecteurs d'Interruption.

Remarque

La manipulation des Interruptions de Ms-Dos nécessite une bonne connaissance du fonctionnement Interne de celui-ci !

SetLineStyle

Procédure GRAPH : 4, 5, 6

Syntaxe

SetLineStyle (style, dessin, largeur);

où style, dessin et largeur sont des expressions de type Word.

Description

La procédure SetLineStyle permet de déterminer le style et l'épaisseur du trait des lignes utilisées par les différentes routines de dessin.

Les Constantes suivantes sont prédéfinies dans l'unité Graph :

Style

0 = SolidLn   ligne continue 
l = DottedLn  ligne pointillée 
2 = CenterLn  ligne mixte 
3 = DashedLn  ligne tiret 
4 = UserBitLn ligne définie par l'utilisateur 

Largeur

1 = NormWidth  1 pixel 
3 = ThickWidth 3 pixels 

Le paramètre dessin est ignoré si style est compris entre 1 et 3. Si style vaut 4 alors dessin représente sur 16 bits un type de trait Défini par l'utilisateur. Le trait représenté est une image bit par bit du nombre.

Remarques

· Si un des paramètres n'est pas valide, aucune modification n'est effectuée et GraphResult renvoie -11.

· Le mode graphique doit être actif, Sinon une erreur BGI Error: Graphics not Initialized (use InitGraph) est renvoyée par le système.

Exemple

For i := 1 To $FFFF Do 
  Begin 
  SetLineStyle (4, i, 3); 
  str (i, st); 
  OutTextXY (40, 40, St); 
  Line (20, 0, 20, GetMaxY); 
  Line (0,20, GetMaxX, 20); 
  Delay (250); 
  ClearDevice; 
  End; 

Ce petit morceau de programme vous permet de tester toutes les possibilités de la définition personnelle d'un dessin de trait.

SetPalette

Procédure GRAPH : 4, 5, 6

Syntaxe

SetPalette(nbre, couleur);

où nbre est une expression de type Word et couleur de type ShortInt.

Description

La procédure SetPalette permet de modifier une des couleurs de la palette utilisée. Comme la palette est une table de 16 couleurs, les valeurs possibles pour le paramètre nbre vont de 0 à 15. Pour le second paramètre, couleur, l'unité Graph a prédéfini un certain nombre de Constantes.

Constantes couleur générales

Pilotes : CGA, EGA, VGA 16 couleurs,... sauf VGA 256 couleurs et IBM8514.

Black        =  0  Noir 
Blue         =  1  Bleu 
Green        =  2  Vert 
Cyan         =  3  Cyan 
Red          =  4  Rouge 
Magenta      =  5  Magenta 
Brown        =  6  Brun 
LightGray    =  7  Gris clair 
DarkGray     =  8  Gris foncé 
LightBlue    =  9  Bleu clair 
LightGreen   = 10  vert clair 
LightCyan    = 11  Cyan clair 
LightRed     = 12  Rouge clair 
LightMagenta = 13  Magenta clair 
Yellow       = 14  Jaune 
White        = 15  Blanc

Remarque

Avec une carte IBM-8514 et VGA en mode 256 couleurs, il n'est pas possible d'utiliser SetAllPalette, il est nécessaire de passer par SetRGBPalette.

Exemple

SetPalette (1, Magenta); 

La couleur 1 de la palette reçoit la valeur Magenta.

SetRGBPalette

Procédure GRAPH : 5, 6

Syntaxe

SetRGBPalette(nbre, rouge, vert, bleu);

Description

La procédure SetRGBPalette permet de modifier la composition d'une des couleurs de la palette utilisée avec les modes VGA 256 couleurs et IBM8514. Dans ces modes, chaque couleur est définie par une certaine quantité de rouge, de vert et de bleu, codée sur 6 bits. La palette par défaut peut être modifiée en spécifiant la quantité de chaque couleur à utiliser pour l'entrée de la table.

Le paramètre nbre donne le numéro de la couleur à modifier, il peut être compris entre 0 et 15 pour le mode VGA 256 couleurs et 0 et 255 pour le pilote IBM-8514. Les paramètres rouge, vert et bleu donnent les quantités des couleurs respectives. Bien que de type Integer, seuls les 6 bits les plus significatifs de l'octet de poids faible sont pris en considération.

Par défaut, les 16 premières couleurs de la palette de ces deux modes sont définies pour être compatibles avec le mode EGA :

Nom             num  R   V   B 
EGABlack        = 0 $00 $00 $00 Noir
EGABlue         = 1 $00 $00 $FC Bleu
EGAGreen        = 2 $24 $FC $24 Vert
EGACyan         = 3 $00 $FC $FC Cyan
EGARed          = 4 $FC $14 $14 Rouge
EGAMagenta      = 5 $B0 $00 $FC Magenta
EGABrown        =20 $70 $48 $00 Brun
EGALightGray    = 7 $C4 $C4 $C4 Gris clair
EGADarkGray     =56 $34 $34 $34 Gris foncé 
EGALightBlue    =57 $00 $00 $70 Bleu clair 
EGALightGreen   =58 $00 $70 $00 Vert clair 
EGALightCyan    =59 $00 $70 $70 Cyan clair 
EGALightRed     =60 $70 $00 $00 Rouge clair 
EGALightMagenta =61 $70 $00 $70 Magenta clair 
EGAYellow       =62 $FC $FC $24 Jaune
EGAWhie         =63 $FC $FC $FC Blanc

Exemple

SetRGBPalette (4, $00, $70, $70); 

Donne à la couleur 4 (par défaut Cyan), la composition de couleur du Cyan clair ($00, $70, $70).

SetTextBuf

Procédure SYS : 4, 5, 6

Syntaxe

SetTextBuf (fich, buffer, taille);

où fich est une variable de type fichier de texte, buffer une variable de n'importe quel type, taille (paramètre optionnel) de type Word.

Description

La procédure SetTextBuf permet de Définir la mémoire tampon associée aux fichiers de type texte. Par défaut, les fichiers texte possèdent un tampon de 128 octets. Si l'on désire modifier cette valeur, la procédure SetTextBuf donne au fichier fich la variable buffer comme tampon. Si le paramètre taille est omis, tout l'espace mémoire de buffer sera utilisé comme tampon.

Remarques

· SetTextBuf doit être utilisé après Assign, avant ou immédiatement après Reset, Rewrite ou Append.

· En aucun cas, il ne peut y avoir eu d'opération d'entrée/sortie (Read, Write). La modification de la taille de la mémoire tampon risque de provoquer des pertes d'Information.

· La taille du tampon définie reste valable jusqu'au prochain appel à Assign. Il est dangereux de l'employer plusieurs fois sur le même fichier Ms-Dos.

· Un code d'erreur est renvoyé par IoResult ({$I-}).

Exemple

SetTextBuf (donnee, tamp);

La taille de la variable tamp est utilisée comme tampon.

SetTextJustify

Procédure GRAPH : 4, 5, 6

Syntaxe

SetTextJustify (j_horz, j_vert);

où j_horz et j_vert sont des expressions de type Word.

Description

La procédure SetTextJustify permet de Définir le type de justification utilisé par OutText et OutTextXY. Dans le cas de OutText, celle-ci s'effectuera par rapport au point déterminé par le pointeur courant. Dans le cas de OutTextXY, le point est déterminé par les coordonnées (x, y).

Pour la justification horizontale, les Constantes suivantes seraient définies :

LeftText   = 0 à gauche du point 
CenterText = 1 au centre du point 
RightText  = 2 à droite du point 

Pour la justification verticale :

BottomText = 0 sous le point 

CenterText = 1 centré sur le point 

TopText = 2 au-dessus du point 

Exemple

SetTextJustify(LeftText, BottomText); 

Selon le manuel de Turbo Pascal, cette Instruction devrait afficher un texte à gauche du point et sous
celui-ci. Mes essais montrent exactement l'Inverse.

SetTextStyle

Procédure GRAPH : 4, 5, 6

Syntaxe

SetTextStyle(fonte, direc, taille);

où fonte, direc et taille sont des expressions de type Word.

Description

La procédure SetTextStyle permet de déterminer les composantes principales de l'affichage des textes. Le premier paramètre Indique le choix de la fonte. Les Constantes suivantes sont définies :

DeFaultFont   = 0 fonte de base 8x8 
TriplexFont   = 1 fonte triplex 
SmallFont     = 2 fonte petite 
SansSerifFont = 3 fonte Sans sérif 
GothicFont    = 4 fonte style gothique 

Le deuxième paramètre Indique la direction d'écriture. Les Constantes suivantes sont définies :

HorizDir = 0 horizontale de gauche à droite 
VertDir  = 1 verticale de bas en haut 

Le troisième paramètre Indique le facteur d'agrandissement en x et en y par rapport à la taille de base. Il peut être compris entre 1 et 10.

Exemple

SetTextStyle (GothicFont, VertDir, 5); 

SetTextStyle définit l'affichage des caractères comme police gothique, direction verticale, facteur d'agrandissement = 5.

SetTime

Procédure DOS : 4, 5, 6

Syntaxe

SetTime (heure, minute, seconde, cent_sec);

où heure, minute, seconde et cent_sec sont des Intervalles de Word.

Description

Cette procédure permet de changer l'heure telle qu'elle est connue par le système. Tous les paramètres utilisés sont de type Intervalle de Word :

heure    : 0..23 
minute   : 0..59
seconde  : 0..59 
cent_sec : 0..59 

Remarque

Si l'heure envoyée par le système est Invalide, la procédure SetTime n'a pas d'effet.

Exemple

WriteLn ( 'Entrez l''heure : ' ); ReadLn (heure); 
WriteLn ('Entrez les minutes :'); ReadLn (minute);
WriteLn ('Entrez les secondes :'); ReadLn (seconde); 
SetTime (heure, minute, seconde, 0); 

L'heure est lue au clavier et ensuite transmise au système.

SetUserCharSize

Procédure GRAPH : 5, 6

Syntaxe

SetUserCharSize(num_x, denom_x, num_y, denom_y);

où num_x, denom_x, num_y et denom_y sont des expressions de type Word.

Description

Cette procédure permet au programmeur de modifier les proportions des polices vectorielles, c'est-à-dire TriplexFont, SmallFont, SansSerifFont et GothicFont. Les paramètres sont tous de type Word, il n'est pas possible de donner des réels. Les paramètres num_x et num_y sont des facteurs de multiplication et denom_x et demom_y sont les facteurs de division.

Exemple

SetTextStyle (SansSerifPont, HorizDir, 5); 
SetUserCharSize (4, 1, 1, 2); 
OutText('Marabout'); 

Le style du texte est Défini comme police sans Sérif, direction horizontale, facteur d'agrandissement = 5. La procédure SetUserCharSize multiplie la largeur par 4 et divise la hauteur par 2 avant l'affichage de la chaîne Marabout.

SetVerify

Procédure DOS : 4, 5, 6

Syntaxe

SetVerify (oui_non);

où oui_non est une variable de type Boolean.

Description

La procédure SetVerify permet, depuis l'intérieur d'un programme Pascal, de configurer la variable Verify de Ms-Dos. lorsqu'elle est à On, une vérification de longueur de fichier est effectuée lors de certaines commandes comme Copy, Xcopy,... lorsqu'elle est à Off, aucune vérification n'est effectuée.

Remarque

La sécurité apportée par Verify est très relative.

Exemple

GetVerify ( cb ); 
If cb Then 
  Begin 
  WriteLn (' verify est On '); 
  SetVerify (False); 
  WriteLn (' puis Off ');
  End
Else
  Begin
  WriteLn (' verify est Off '); 
  SetVerify (True); 
  WriteLn (' puis On '); 
  End; 

La valeur de la variable Ms-Dos est lue, affichée puis Inversée.

SetViewPort

Procédure GRAPH : 4, 5, 6

Syntaxe

SetViewPort (x_min, y_min, x_max, y_max, limite);

où x_min, y_min, x_max et y_max sont des expressions de type Integer et limite de type Boolean.

Description

La procédure SetViewPort permet de délimiter la fenêtre d'affichage courante. Les paramètres sont l'abscisse et l'ordonnée du Coin supérieur gauche et l'abscisse et l'ordonnée du Coin Inférieur droit de la fenêtre. Ils sont exprimés d'une manière absolue entre 0 et GetMaxX et 0 et GetMaxY. Le dernier paramètre détermine si l'affichage sera limité à la fenêtre déterminée. Il peut être déterminé à l'aide d'une valeur booléenne ou à l'aide des Constantes prédéfinies de l'unité Graph : ClipOn = True et ClipOff = False. Lorsqu'une fenêtre a été déterminée, la plupart des commandes qui font appel à des coordonnées d'écran utilisent le Coin supérieur gauche de celle-ci comme origine (0, 0). Si aucune fenêtre n'a été Définie, l'écran est la fenêtre (0, 0, GetMaxX, GetMaxY, True).

Exemple

Randomize; 
SetViewPort (50, 50, 200, 200, True); 
For i := 1 To 1000 Do 
OutTextXY (Random (GetMaxX), Random(GetMaxY), Chr(Random(255))); 

Une fenêtre est Définie à l'écran avec limitation de l'affichage. 1000 caractères sont écrits mais seuls ceux qui se trouvent à l'intérieur de la fenêtre apparaissent.

SetVisualPage

Procédure GRAPH : 4, 5, 6

Syntaxe

SetVisualPage(page);

où page est une expression de type Word.

Description

La procédure SetVisualPage détermine quelle est la page graphique affichée à ne pas confondre avec SetActivePage, qui détermine la page vers laquelle les sorties sont envoyées. Sur les systèmes possédant au moins deux pages graphiques, il peut être Intéressant d'effectuer les dessins en arrière-plan, sur la page graphique qui n'est pas affichée. Le dessin terminé, on activera l'affichage de cette page.

Remarques

· Les pages graphiques sont numérotées à partir de 0.

· Tous les systèmes et tous les modes ne possèdent pas plusieurs pages graphiques, voici les Principaux :

CGA et MGCA 1 page, 
EGA l, 2 ou 4 pages suivant le mode, 
Hercules : toujours 2 pages, 
VGA : 4, 2 ou 1 page suivant le mode. 

· La liste complète des différents pilotes, modes et nombre de pages est donnée sous la rubrique InitGraph.

Exemple

For i := 1 To 10 Do 
  Begin 
  Delay (500); SetVisualPage (i Mod 2); 
  End; 

Deux pages graphiques sont visualisées alternativement.

SetWriteMode

Procédure GRAPH : 5, 6

Syntaxe

SetWriteMode(mode);

où mode est un paramètre de type Integer.

Description

La procédure SetWriteMode détermine comment les lignes se comporteront par rapport à ce qui se trouve déjà à l'écran. Les deux modes possibles sont : 0 = CopyPut et 1 = XOrPut.

Dans le mode CopyPut la ligne est écrite telle quelle sur l'écran, sans tenir compte de ce qui s'y trouve. Autrement dit, elle ne sera pas nécessairement visible. Dans le mode XOrPut, un ou exclusif est effectué entre la couleur de tracé et la couleur de ce qui est à l'écran. La ligne sera nécessairement visible.

Remarque

SetWriteMode n'affecte que les lignes tracées avec Line, LineRel, LineTo, DrawPoly et Rectangle.

Exemple

SetWriteMode(1); 
Line (100, 100, 100, 300); 
For i := 1 To 10 Do Line (50, (20*i)+80, 200, (20*i)+80); 

Le mode d'écriture est mis à 1 (XOrput) à l'aide de SetWriteMode. Une ligne verticale et 10 lignes horizontales sont tracées. Les Intersections des lignes seront dans la couleur Inverse (au sens de XOr) de la couleur du trait.

ShL

Opérateur   3, 4, 5, 6

Syntaxe

exp1 ShL exp2 

où exp1 et exp2 sont des expressions entières.

Description

Cet opérateur permet le décalage vers la gauche (Shift Left) de exp2 bits de la valeur de exp1. Les deux nombres doivent être de type entier. Le résultat est du même type entier que exp1.

Remarque

Les opérandes doivent être d'un type entier, soit ShortInt, Integer, LongInt, Byte ou Word. Sinon une erreur est diagnostiquée à la compilation : Error 41: Operand types do not match operator.

Exemple

Program Shift_left; 

Var i, j : Byte; 

Begin 
i:= 2; 
j := i ShL 3; 
WriteLn (j); 
End.

Si i : 00000010 = 2 alors j : 00010000 = 16

ShortInt

Identificateur de type   4, 5, 6

Syntaxe

     identv1, identv2,... : ShortInt; 
ou   identt1, identt2,... = ShortInt; 

où identv1, identv2,... sont des identificateurs de Variables et identt1, idenrt2,... sont des identificateurs de types.

Description

Ce mot est utilisé lors de la déclaration de Variables entières courtes ou de types entiers courts. Le type ShortInt est un Intervalle du type Integer dont les bornes sont -128..+127; les Variables de ce type sont stockées en mémoire sous la forme d'un octet signé. Il est compatible, dans son domaine, avec les autres types entier.

Remarques

· La valeur des Variables de ce type doit être comprise entre -128 et +127. 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 ShortInt dépasse l'Intervalle de définition, le programme peut avoir un comportement aberrant.

· Ce type est une extension au Pascal standard.

Exemples

Type compteur = ShortInt; 
Var tol, lut : ShortInt; 

Le type compteur est Défini comme synonyme du type ShortInt, les Variables tol et lut sont déclarées de ce type.

ShR

Opérateur   3, 4, 5, 6

Syntaxe

exp1 ShR exp2 

où exp1 et exp2 sont des expressions entières.

Description

Cet opérateur permet le décalage vers la droite (Shift Right) de exp2 bits de la valeur de exp1. Les deux nombres doivent être de type entier. Le résultat est du même type entier que exp1.

Remarque

Les opérandes doivent être d'un type entier soit ShortInt, Integer, LongInt, Byte ou Word. Sinon une erreur est diagnostiquée à la compilation : Error 41: Operand types do not match operaror.

Exemple

Program Shift_right; 

Var i, j : Byte; 

Begin 
i := 64; 
j := i ShR 3; 
WriteLn (j); 
End.  

Si i : 01000000 = 64 alors j : 00001000 = 8

Sin

Fonction : Real   3, SYS : 4, 5, 6

Syntaxe

Sin (r) 

où r est une expression de type Real.

Description

La fonction Sin renvoie le sinus d'un angle r.

Remarque

Comme dans la plupart des langages de programmation, les fonctions trigonométriques travaillent en radians et non en degrés.

Pour rappel:

angle en degrés = 180 / pi angle en radians 
angle en radians = pi / 180 angle en degrés 

Exemple

res := Sin ((Pi/180) * angle); 

Grâce au facteur de conversion Pi/180, res contiendra le sinus de angle exprimé en degrés.

Single

Identificateur de type   4, 5, 6

Syntaxe

     identv1, identv2,... : Single; 
ou   identt1, identt2,... = Single; 

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 simples ou de types réels simples, il est exploitable par le coprocesseur arithmétique. Une variable Single est stockée en mémoire dans 4 octets, son domaine de validité est +/-1.5 x l0^-45.. +/-3.4 x 10⁺³⁸, avec de 7 à 8 décimales exactes. Le type Single est compatible, dans son domaine de définition, avec les autres types réels.

Remarques

· En Turbo Pascal 4 vous devez posséder un coprocesseur au moment de la compilation pour accéder au type Single. Dans les versions 5 et 6, vous pouvez utiliser une émulation logicielle, mais celle-ci sera plus lente que les opérations sur les Real et que si le coprocesseur est physiquement présent (directive de compilation {$N}).

· Ce type est une extension au Pascal standard.

· La valeur des Variables de ce type doit être comprise entre +/-1.5 x 10^-45 et +/-3.4 x 10⁺³⁸. Sur les nombres de type réel une vérification est effectuée en cas de dé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.

Exemple

Type mesure = Single; 
Var longueur, largeur : Single; 

Le type mesure est Défini comme synonyme du type Single et les Variables longueur et largeur sont définies de ce type.

SizeOf

Fonction : (Integer) Word   (3) SYS : 4, 5, 6

Syntaxe

SizeOf(Var) 

où Var est un identificateur de variable ou de type.

Description

La fonction SizeOf renvoie, exprimée en octets, la taille d'une variable. Cette fonction est souvent utilisée lorsque l'occupation d'une variable en mémoire centrale est critique. Son emploi est fréquent avec les fonctions et procédures : BlockWrite, FillChar, GetMem, MaxAvail, Move, New...

Exemple

FillChar (tab, SizeOf(tab), 0); 

La fonction SizeOf est utilisée pour transmettre à FillChar la taille de la variable tab. Cette variable peut alors être Initialisée.

Sound

Procédure 3, CRT : 4, 5, 6

Syntaxe

Sound (freq);

où freq est une expression de type Integer en Turbo Pascal 3 et Word à partir de la version 4.

Description

La procédure Sound adresse le haut-parleur du PC pour émettre un son dont la fréquence, transmise en paramètre, est exprimée en Hertz. Le son est émis jusqu'à ce qu'un appel à NoSound soit effectué ou jusqu'à ce qu'un nouvel appel à Sound vienne modifier la fréquence du son émis.

Exemple

freq := 0; 
Repeat 
  Sound (freq); 
  Delay (10); 
  WriteLn (freq); 
  freq : freq + l; 
Until KeyPressed; 
NoSound; 

Un son de fréquence croissante est émis par le haut-parleur du PC jusqu'à ce que l'utilisateur appuie sur une touche quelconque du clavier. La fréquence est affichée à l'écran pendant le déroulement de la boucle afin que vous puissiez le contrôler. La boucle terminée, un appel à NoSound permet de désactiver le haut-parleur, Sinon le son continue à être généré même après la fin du programme.

SPtr

Fonction : Word SYS : 4, 5, 6

Syntaxe

SPtr

Description

La fonction renvoie le contenu du registre SP (Stack Pointer). Le résultat est le déplacement de l'adresse du Pointeur de pile par rapport à l'adresse de base du segment de pile renvoyée par SSeg.

Au début du programme, le Pointeur de pile pointe en haut du segment de pile. Suivant les besoins du programme la pile croît vers le bas. Lorsque SPtr vaut zéro, la pile est pleine et le programme peut s'arrêter faute de mémoire.

La taille par défaut (16 Ko) du segment de pile peut être modifiée par la directive {$M} mais ne peut dépasser 64 Ko.

Remarque

Si la place est Insuffisante dans la pile, pour un appel de fonction ou de procédure, on obtient l'erreur Error 202: Stack overflow error. Lors d'appels récursifs, le programmeur devrait faire appel à SPtr pour vérifier la place mémoire encore disponible.

Exemple

Program mem; 

Function memoire : Byte; 
  Var tab : Array [l..1000] Of Byte; 

  Begin 
  WriteLn ('SS ', SSeg, 'SPtr =', SPtr); 
  memoire := memoire; 
  End; 

Begin 
memoire;
End. 

Ce petit programme est destiné à montrer comment évoluent l'adresse de base et le Pointeur du segment de pile. Il se termine nécessairement par une erreur : Error 202: Stack overflow error.

Sqr

Fonction : Type de paramètre 3, SYS : 4, 5, 6

Syntaxe

Sqr (x) 

où x est une expression d'un type numérique.

Description

La fonction Sqr renvoie le carré de l'argument qui lui est transmis. Le résultat est du même type que l'argument et ses possibilités dépendent donc de la version de Turbo Pascal et éventuellement du mode de traitement des Variables compatibles 80x87 utilisé.

Exemples

Si res := Sqr (-3) alors res = 9
Si res := Sqr (2.3) alors res = 5.29

Sqrt

Fonction : Real   3, SYS : 4, 5, 6

Syntaxe

Sqrt (r) 

où r est une expression de type Real.

Description

La fonction Sqrt renvoie la racine carrée de l'argument qui lui est transmis. Le résultat est toujours de type réel.

Remarque

Il est de la responsabilité du programmeur de s'assurer que l'argument transmis est bien positif. Sinon on aura une erreur lors de l'exécution : Error 207 : invalid floating Point operation.

Exemples

Si res := Sqrt (2.3) alors res = 1.5165750 
Si res := Sqrt (100) alors res = 10.0

SSeg

Fonction : (Integer) Word   (3) SYS : 4, 5, 6

Syntaxe

SSeg 

Description

La fonction renvoie le contenu du registre SS (Stack Segment). Le résultat est la partie segment de l'adresse du segment de pile. Ce registre n'est pas modifié durant l'exécution d'un programme. Le segment de pile contient les Variables locales, les résultats Intermédiaires lors de l'évaluation des expressions et sert à passer les paramètres aux procédures et aux fonctions. Sa taille par défaut (16 Ko) peut être modifiée par la directive de compilation {$M} mais ne peut dépasser 64 Ko.

Remarque

En Turbo Pascal 3, la valeur renvoyée est un Integer, à partir de la version 4, elle est de type Word.

Exemple

Program mem; 

Function memoire : Byte; 
  Var tab : Array [1..1000] Of Byte; 

  Begin 
  WriteLn ('SS =', SSeg, 'SPtr =', SPtr); 
  memoire := memoire; 
  End; 

Begin 
memoire;
End. 

Ce petit programme est destiné à montrer comment évoluent l'adresse de base et le Pointeur du segment de pile. Il se termine nécessairement par une erreur : Error 202: Stack overflow error. Voir la fonction SPtr.

Str

Procédure 3, SYS : 4, 5, 6

Syntaxe

Str (nbre:format, ch);

où nbre est une expression numérique, format (optionnel) un format d'écriture de nombres et ch une expression de type String.

Description

La fonction Str a pour effet de convertir un nombre entier ou réel nbre en une chaîne de caractères ch suivant un format donné. Pour les entiers le format est du type :t, où t est le nombre de caractères demandés. Pour les réels, le format est :t:d, où t est le nombre total de caractères et d le nombre de décimales. Si aucun format n'est spécifié, c'est le format par défaut de Turbo Pascal qui sera utilisé.

Remarques

· La procédure Write fait exactement le même travail lorsqu'elle affiche un nombre à l'écran.

· Si le nombre de caractères demandés est supérieur au nombre de caractères nécessaires, le nombre sera justifié à droite.

· La procédure Str compense la pauvreté de Turbo Pascal en formats d'affichage en permettant au programmeur de travailler la chaîne correspondant au nombre.

Exemple

r := Pi / 4; 
Str (r:10:3, ch); 
WriteLn ('***', ch, '***'); 

Affiche à l'écran '*** 0.785***'.

string

Identificateur de type   3, 4, 5, 6

Syntaxe

     identv1, identv2,... : String; 
ou   identv1, identv2,... : String [n]; 
ou   identt1, identt2,... = String; 
ou   identt1, identt2,... = String [n];

où identv1, identv2,... sont des identificateurs de Variables; identt1, identt2,... sont des identificateurs de types et n un entier compris entre 1 et 255.

Description

Ce mot est utilisé pour déclarer des Variables chaînes de caractères ou des types chaînes de caractères. Les chaînes de caractères peuvent être vues comme des tableaux de caractères auxquels des fonctions particulières sont applicables. Chaque élément doit donc faire partie des 256 caractères du code ASCII étendu de l'IBM PC. La définition de la chaîne peut Intégrer la longueur maximale qu'elle pourra atteindre. Si celle-ci n'est pas Définie, elle reçoit la valeur la plus grande autorisée, soit 255.

Une variable de ce type est représentée en entourant les caractères d'apostrophes
(exemple : 'AZERETYUIOP'). Le caractère apostrophe lui-même sera représenté en le doublant
(exemple : 'l "espoir').

Une chaîne de n caractères sera stockée en mémoire sur n+1 octet; soit n octets pour les n caractères plus un octet pour retenir la longueur de la chaîne effectivement utilisée.

Remarques

· Les chaînes de caractères ne peuvent dépasser la valeur maximale qui leur a été attribuée lors de leur définition. Lors de l'appel d'une fonction ou d'une procédure, la longueur exacte de la chaîne peut être vérifiée ou non suivant la directive de compilation {$R }.

· Si la chaîne dépasse la longueur maximale, celle-ci sera coupée à droite. Lors de l'appel d'une procédure ou d'une fonction, s'il n'y a pas correspondance de longueur des chaînes, une erreur d'exécution peut survenir suivant la directive de compilation {$R} utilisée.

Exemple

Type phrase = String; 
  nom_de_famille = String [15]; 
Var remarque : String; 
  prenom  : String [18]; 

Le type phrase est Défini comme synonyme du type String (implicitement de 255 caractères); le type nom_de_famille comme synonyme du type String [15] (15 caractères). La variable remarque est déclarée de type String (255 caractères); la variable prenom de type String [18] (18 caractères).

Succ

Fonction : scalaire 3, SYS : 4, 5, 6

Syntaxe

Succ (s);

où s est une expression de type scalaire.

Description

La fonction Succ a pour effet d'incré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 Succ 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 Succ 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 := 'A';
While Ch <= Z' DO 
  Begin 
  WriteLn (ch); 
  Succ (ch);
  End; 

Cette boucle affiche, à l'écran, l'alphabet dans l'ordre croissant.

Swap

Fonction : Integer ou Word 3, SYS : 4, 5, 6

Syntaxe

Swap (i) 

où i est une expression de type Integer ou Word.

Description

La fonction Swap Inverse les octets de poids fort et de poids faible de son argument entier ou mot. Le type du résultat renvoyé correspond au type de l'argument fourni : de type Integer si l'argument est un Integer, de type Word si l'argument est de type Word.

Remarque

En Turbo Pascal 3 fonction et argument étaient nécessairement de type Integer.

Exemples

Soit la variable j de type Word :

Si j = Swap (256) alors j := 1 
256 = 00000001 00000000 
  1 = 00000000 00000001 

Si j = Swap (2) alors j := 512 
  2 = 00000000 00000010 
512 = 00000010 00000000

SwapVectors

Procédure DOS : 5, 6

Syntaxe

SwapVectors;

Description

Cette procédure a pour effet d'échanger la table des pointeurs d'Interruption courante avec sa copie qui en est réalisée par Turbo Pascal.

Lorsqu'un programme Pascal est lancé, les vecteurs sont recopiés automatiquement et le programme peut modifier les vecteurs d'Interruption. A la fin du programme, les vecteurs originaux sont restaurés. SwapVectors devrait être utilisé avant et après l'exécution d'un programme externe. Utilisé avant, SwapVectors a pour effet de restaurer l'environnement Initial. Réutilisé après, il permet de restaurer la table d'Interruption Définie par le programme. De la sorte, on sera certain qu'il n'y a pas d'Interaction entre la table des vecteurs utilisée par le programme Pascal et le programme externe.

Exemple

SwapVectors; 
Exec ('prog1.exe',''); 
SwapVectors; 

Permute les vecteurs d'Interruption avant et après l'exécution du programme externe Prog1.exe.

Text

Identificateur de type   3, 4, 5, 6

Syntaxe

Type nomtyp = Text; 
Var nomvar : Text; 

où nomtyp et nomvar sont respectivement des identificateurs de type et de variable.

Description

Ce mot est utilisé pour déclarer des Variables de type fichier de texte et des types fichier de texte. Un fichier est, en Pascal, une suite ordonnée d'éléments du même type. Les fichiers Text sont des fichiers de caractères auxquels des règles particulières sont applicables. Ils peuvent être ouverts soit en écriture à l'aide de Rewrite ou Append, soit en lecture à l'aide de Reset. Certaines fonctions ou procédures leur sont propres comme ReadLn, WriteLn, Eoln,... et d'autres fonctionnent d'une manière légèrement différente que sur les autres types de fichiers comme Read et Write.

Remarques

· Avant toute utilisation d'une variable de type fichier, celle-ci doit être associée à un fichier sur disque à l'aide de la procédure Assign. Ensuite, il est nécessaire d'Initialiser la fenêtre de lecture-écriture à l'aide de Reset, Rewrite ou Append.

· Après l'utilisation d'un fichier, il est conseillé de fermer celui-ci à l'aide de la procédure Close. En effet, lors de l'écriture dans un fichier, le transfert physique des données passe par des tampons en mémoire centrale qui réduisent les accès au disque. En cas de fin anormale du programme une partie des données peut ne pas avoir été transférée sur disque et Induire des pertes de données.

· En Turbo Pascal 3, la taille du tampon associé à un fichier Text est Définie lors de la déclaration du fichier, par exemple Var rapport : Text [1024]; définit le fichier rapport avec une mémoire tampon de 1024 octets. A partir de la version 4 la procédure SetTextBuf réalise le même travail.

Exemple

Var rapport, donnee : Text; 

Les fichiers rapport et donnee sont déclarés de type Text.

TextBackGround

Procédure 3, CRT : 4, 5, 6

Syntaxe

TextBackGround (teinte);

où teinte est soit une expression de type Byte, soit une Constante de couleur prédéfinie.

Description

La procédure TextBackGround permet de Définir la couleur du fond de l'écran.

Couleurs : 
  Black     = 0 
  Blue      = 1 
  Green     = 2 
  Cyan      = 3 
  Red       = 4 
  Magenta   = 5 
  Brown     = 6 
  LightGray = 7 
  DarkGray  = 8 

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

TextBackGround (7); 
TextBackGround (LightGray); 

Ces deux appels donnent au fond de l'écran la couleur gris clair (LightGray).

TextColor

Procédure 3, CRT : 4, 5, 6

Syntaxe

TextColor (teinte);

où teinte est soit une expression de type Byte, soit une Constante de couleur prédéfinie.

Description

La procédure TextColor permet de Définir la couleur d'affichage du texte.

Remarques

· Tous les types de cartes couleur ne supportent pas toutes les couleurs définies par Turbo Pascal. D'autre part, certaines cartes offrent plus de couleurs qui ne sont pas accessibles.

Couleurs : 
  Black        =  0 
  Blue         =  1 
  Green        =  2 
  Cyan         =  3 
  Red          =  4 
  Magenta      =  5 
  Brown        =  6 
  LightGray    =  7 
  DarkGray     =  8 
  LightBlue    =  9 
  LightGreen   = 10 
  LightCyan    = 11 
  LightRed     = 12 
  LightMagenta = 13 
  Yellow       = 14 
  White        = 15

  Attribut de clignotant : 
    Blink = 128 (16 en version 3).

L'attribut de clignotant doit être rajouté à la valeur de la couleur.

· 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 (Magenta + Blink); 
TextColor (133); 

Ces deux appels ont le même effet : un texte clignotant en magenta.

TextHeight

Fonction : Word   GRAPH : 4, 5, 6

Syntaxe

TextHeight (ch) 

où ch est une expression de type Chaîne de caractères.

Description

La fonction TextHeight renvoie, sous la forme d'un entier de type Word, la hauteur, exprimée en pixels, d'une chaîne de caractères. Les facteurs qui déterminent le résultat renvoyé sont :

– la fonte de caractères utilisée,

– le facteur d'agrandissement (déterminé par SetTextStyle).

L'utilisation de TextHeight permet de ne pas devoir refaire ce calcul lors de la modification d'un de ces paramètres. Elle est utile, par exemple, pour placer un texte à l'écran, ou pour déterminer s'il peut être affiché en tenant compte du pilote et du mode courant.

Exemple

SetTextStyle (SansSerifFont, HorizDir, 10); 
w := TextHeight ('Marabout'); 

Sur mon ordinateur, utilisant une carte de type Hercules, la variable w vaut 128.

TextMode

Procédure 3, CRT : 4, 5, 6

Syntaxe

TextMode (md); 

où md est une expression de type Integer ou une Constante de mode d'affichage Prédéfinie.

-- Turbo Pascal 4, 5, 6 --

Description

La procédure TextMode permet de changer le mode d'affichage des caractères à l'écran. L'écran entier est effacé et affecté à la fenêtre courante. Il est donc nécessaire de faire appel à TextMode avant d'utiliser Window, Suivant les possibilités de l'écran sur lequel le programme se déroule, les arguments peuvent être :

BW40 = 0 : Carte couleur 40x25 monochrome 
CO40 = 1 : Carte couleur 40x25 couleur 
BW80 = 2 : Carte couleur 80x25 monochrome 
CO80 = 3 : Carte couleur 80x25 couleur 
Mono = 7 : Carte monochrome 80x25 
Font8x8 = 256 : EGA/VGA 43 et 50 lignes 

Pour la compatibilité avec la version 3 les Constantes

suivantes sont définies :

C40 = CO40 
C80 = CO80 

L'attribut FontSx8 doit être rajouté aux autres attributs BW80 ou CO80.

La variable LastMode reçoit la valeur du mode Initial au début du programme et ensuite le mode courant après un appel à TextMode, DirectVideo qui contrôle l'écriture directe à l'écran sans passer par Ms-Dos vaut True ainsi que CheckSnow qui vérifie si l'écran n'est pas neigeux.

Exemples

TextMode(C080 + Font8x8); 
TextMode(259); 

Ces deux Instructions ont le même effet : passer en affichage 43 x 80 sur un écran EGA et 50 x 80 pour les écrans VGA.

-- Turbo Pascal 3 --

Description

BW40 = 0 : Carte couleur 40x25 monochrome 
C40 = 1 : Carte couleur 40x25 couleur 
sw80 = 2 : Carte couleur 80x25 monochrome 
CBO  = 3 : Carte couleur 80x25 couleur 

En version 3, si aucun argument n'est utilisé, le mode sélectionné est celui Défini avant l'appel précédant TextMode.

exemple

TextMode(C40); 
TextMode(1); 

Ces deux Instructions (toujours exécutables dans les versions plus récentes) passent en mode couleur 40 colonnes.

TextWidth

Fonction : Word GRAPH :4, 5, 6

Syntaxe

TextWidth ( ch ) 

où ch est une expression de type chaîne de caractères.

Description

La fonction TextWidth renvoie, sous la forme d'un entier de type Word, la largeur, exprimée en pixels, d'une chaîne de caractères. Les facteurs qui déterminent le résultat renvoyé sont :

– la longueur de la chaîne en nombre de caractères,

– la fonte de caractères utilisée,

– le facteur d'agrandissement (déterminé par SetTextStyle).

L'utilisation de TextWidth permet de ne pas devoir refaire ce calcul lors de la modification d'un de ces paramètres. Elle est utile, par exemple, pour centrer un texte ou pour déterminer s'il peut être affiché avec le pilote et le mode courant.

Exemple

SetTextStyle (SansSerifFont, horizDir, 10); 
w : TextWidth ('Marabout'); 

Sur mon ordinateur, utilisant une carte de type Hercules, la variable w vaut 548.

Trunc

Fonction : (Integer) LongInt (3) SYS : 4, 5, 6

Syntaxe

Trunc (r) 

où r est une expression de type Real.

Description

La fonction Trunc renvoie la partie entière d'une expression réelle. Si cette expression contient une partie décimale, celle-ci sera simplement tronquée et non arrondie (voir Round). A la différence de la fonction Int, le résultat est un entier.

Remarques

· En Turbo Pascal 3, le résultat était entier.

· Le nombre réel doit être dans l'Intervalle de Définition des Integer en version 3 et des LongInt en version 4 et au-delà.

Exemples

Si res : Trunc (23.7) alors res = 23 
Si res : Trunc (-23.7) alors res = -23

Truncate

Procédure SYS : 4, 5, 6

Syntaxe

Truncate (fich);

où fich est une variable de type fichier de tout type.

Description

La procédure Truncate a pour effet de couper le fichier à la position courante. La fonction Eof devient vraie, ce qui signifie que l'enregistrement courant est perdu sur les fichiers typés et non typés et que la suite du fichier est perdue sur les fichiers texte.

Remarques

· Si une erreur survient, un code est renvoyé par l'Intermédiaire de IoResult pour autant que la directive de compilation {$I-} ait été employée.

· Avant l'appel à Truncate les fichiers doivent être ouverts avec Assign puis Reset ou Rewrite.

Exemple

Seek (fich, FileSize(fich)-1); 
Truncate (fich); 

Le dernier enregistrement de fich est effacé.

Type

Mot réservé 3, 4, 5, 6

Syntaxe

Type identyp = descrtype; 

où identyp est l'identificateur du type et descrtype sa description.

Description

Le mot réservé Type débute la partie définition de types définis par l'utilisateur.

En Turbo Pascal. on peut classer les types en deux grandes catégories :

– standard (connus par le compilateur) :

– types scalaires : ShortInt, Integer, LongInt, Byte, Word, Char et Boolean;

– types réels : Real, Single, Double, Extended et Comp;

– types chaînes de caractères : String ;

– définis par le programmeur :

– types énumérés et Intervalles;

– types tableaux : Array;

– types enregistrements : Record;

– types ensembles : Set;

– types fichiers : File, Text;

– types objets : Object;

– types pointeurs : ^, Pointeur;

– types sous-programmes : Procédure et Function.

Le type String pouvant être soit utilisé tel quel, soit précisé par le programmeur.

Remarque

Le Pascal standard impose un ordre strict aux différentes déclaratives, il ne peut donc y avoir qu'une seule partie de Définition de types. En Turbo Pascal, la seule règle est que l'on ne peut se servir d'un objet qu'après l'avoir déclaré, en conséquence, on peut trouver dans le même bloc plusieurs déclarations de type.

Exemple

Type numero = Set Of Char; 
     dates  = Record 
       jour, mois, annee : Word; 
       End;
     saisons ('hiver', 'printemps', 'ete', 'aut'); 

Trois nouveaux types sont définis par l'utilisateur : numero (ensemble), dates (enregistrement) et saisons (énumération).

Unit

Mot réservé 4, 5, 6

Syntaxe

Unit identunit; 

où identunit est l'identificateur d'unité.

Description

Ce mot réservé est utilisé pour Définir l'en-tête d'une unité. La structure générale d'une unité est :

Unit identunit; {en-tête de l'unité}

Interface {début de la partie publique}
...

Implementation   {début de la partie privée}
...

Begin   {début de l'Initialisation}
...
End.   {fin de l'unité}

La partie Interface d'une unité est accessible (à l'aide de Uses) depuis le programme Principal ou l'unité qui l'appelle, comme si elle faisait partie de ce programme ou de cette unité. Dans cette partie publique nous trouvons habituellement :

- Les appels publics à d'autres unités.

- Les déclarations de type et de variable qui seront accessibles dans le programme Principal.

- Les en-têtes de procédures et de fonctions.

La partie implémentation décrit la partie privée de l'unité. Cette partie est Inaccessible depuis le programme Principal ou l'unité appelante. Dans cette partie privée nous trouverons habituellement :

- Des appels privés à d'autres unités.

- Des déclaratives locales utilisables uniquement dans les procédures et les fonctions de l'unité.

- Le corps des procédures et fonctions définies dans la partie INTERFACE. L'en-tête de celles-ci sera simplement rappelé et ne comportera plus de paramètres.

- Une partie Initialisation, optionnelle, qui reprend les Instructions à exécuter lors de l'emploi de l'unité avant les Instructions du programme Principal.

La partie Implementation se Termine nécessairement par « END. » qui détermine la fin de l'unité.

Remarque

Le nom Ms-Dos des unités est formé de l'identificateur d'unité et de l'extension .TPU (Turbo Pascal Unit).

Exemple

Unit math;   {En-tête de l'unité}

Interface {Début de l'Interface}

Uses Crt; (Appel "public" à l'unité Crt}
Procedure divise (Var i, j : Integer); 
Function Racine ( r : Real) : Real; 

Implementation   (début de l'implémentation}

Procedure divise;   {Corps de "divise"}
  Begin
  If j > 0 Then i := i Div j Else i:= 0;
  End;

Function Racine; {Corps de "Racine"}
  Begin 
  If r >= 0 Then Racine : Sqrt (r); 
  End; 

Begin {début de l'Initialisation}
Clrscr; 
End.   {fin de l'unité}

UnPackTime

Procédure DOS : 5, 6

Syntaxe

UnPackTime (h_courte, h_longue);

où h_courte est une variable ou une Constante de type LongInt et h_longue une variable de type DateTime.

Description

La procédure UnPackTime permet de passer de la forme courte de la date et de l'heure, utilisée par exemple par GetDate, à la forme longue directement lisible. 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 à UnPackTime n'étant pas vérifiées, le résultat peut être aberrant.

Exemple

Assign ( f, 'C:\AUTOEXEC. BAT' ); 
Reset (f); 
GetFTime (f, heure); 
UnPackTime (heure, split); 
WriteLn (split.Year, ' ',split.Month,' ',split.day); 

La date et l'heure du fichier AUTOEXEC.BAT sont lues par GetFTime, décompactées par UnPackTime et ensuite affichées.

UpCase

Fonction : Char 3, SYS : 4, 5, 6

Syntaxe

UpCase (ch) 

où ch est une expression de type caractère.

Description

La fonction UpCase convertit le caractère transmis en sa majuscule. Cependant, ne sont traitées que les lettres de l'alphabet ordinaire (de 'a' à 'z'), mais pas les caractères accentués de la langue française.

Remarque

Les caractères qui sortent de l'Intervalle ASCII 'a' .. 'z' ne sont pas traités et sont renvoyés tels quels.

Exemple

For i : = l To Length (chaine) Do chaîne [i] : UpCase (Chaîne [i] ); 

La variable chaîne est convertie en majuscules.

Uses

Mot réservé 4, 5, 6

Syntaxe

Uses unit1, Unit2,... ; 

où unit1, unit2,... sont les unités utilisées dans le programme.

Description

La clause Uses permet d'Indiquer les unités qui seront utilisées dans le programme. Les noms des unités seront séparés par le symbole « , » et la clause elle-même terminée par « ; ».

Remarques

· L'unité doit être accessible au compilateur. Par défaut, son nom est celui de son identificateur suivi de l'extension .TPU. Le compilateur commence par chercher s'il s'agit d'une unité résidante en mémoire lors de la compilation. Ces unités sont regroupées dans le fichier Turbo.tpl; à l'aide de l'utilitaire Tpumover, il est possible d'ajouter ou de retirer des unités résidantes. S'il ne les y trouve pas, il cherche ensuite sur disque, successivement dans le répertoire par défaut puis dans les répertoires Indiqués dans la rubrique Options, Directories, Unit de l'environnement Intégré.

· Il est possible de modifier ce comportement en utilisant la directive de compilation {$U nom_de_fichier} juste avant le nom de l'unité pour Indiquer que le compilateur doit chercher l'unité dans un autre répertoire ou qu'elle ne porte pas un nom standard.

· Si l'unité est Introuvable, le compilateur affiche un message comme : Error 15: File not found (MONUNIT.TPU).

· Lors de la compilation, Turbo Pascal ne récupère dans les unités que les procédures et fonctions effectivement appelées par le programme. Il ne faut donc pas avoir peur de se servir d'unités, même si elles comportent de nombreuses parties Inutiles pour le programme en cours.

Exemple

Program demo; 
Uses Crt, Graph, ($U MALIB) perslib; 

Le programme demo utilise les unités Crt, Graph et perslib; cette dernière se trouve dans le fichier Ms-Dos, MALIB.

Val

Procédure 3, SYS : 4, 5, 6

Syntaxe

Val (ch, nbre, err);

où ch est une expression de type String, nbre une variable numérique et err une variable Integer.

Description

La procédure Val convertit une chaîne de caractères ch en une valeur numérique. De plus, elle fournit un code d'erreur err qui Indique si l'opération s'est déroulée correctement. Si le code d'erreur vaut 0 c'est qu'il n'y a pas eu de problème de conversion, si sa valeur est différente de 0 elle Indique le premier caractère fautif.

Remarque

A la différence de la lecture directe des valeurs numériques à l'aide de Read, la procédure Val ne provoque pas d'erreur d'exécution en cas de format numérique Incorrect. Elle est donc largement utilisée lorsque l'on désire rendre un programme imperméable aux erreurs de frappe des nombres.

Exemple

Repeat 
  ReadLn (ch); 
  Val (ch, i, err); 
  If err <> 0 Then WriteLn ('erreur au caractère ', err); 
Until err = 0; 

La lecture de la variable ch est répétée jusqu'à ce que le format numérique soit correct.

Var

Mot réservé 3, 4, 5, 6

Syntaxe

Var ident11, ident12,... : type1; 
    ident21, ident22,... : type2; 

Description

Ce mot réservé marque le début d'une partie déclaration de variable d'un programme, procédure, fonction ou d'une unité. Le Pascal standard impose un ordre strict aux différentes déclaratives, il ne peut donc y avoir qu'une seule partie de Définition de types. En Turbo Pascal, la seule règle est que l'on ne peut se servir d'un objet qu'après l'avoir déclaré, en conséquence, on peut trouver dans le même bloc plusieurs déclarations de Variables et de types. Le Point le plus important est que l'on ne peut se servir que de types déjà connus du compilateur, qu'ils soient standard ou préalablement définis par l'utilisateur

Remarque

Pour éviter l'effet de bord qui est la modification accidentelle d'une variable globale par une sous-routine, on peut déclarer les Variables du programme Principal après les déclarations de procédures et de fonctions.

Exemple

Var i, j, k : Integer; 
  nom : String [25]; 
  tableau : Array [1..15] Of Byte;

Les Variables i, j et k sont déclarées de type Integer, la variable nom de type String [25] et la variable tableau comme un Array de 1 à 15 d'octets.

WhereX, WhereY

Fonction : Byte   3, CRT : 4, 5, 6

Syntaxe

WhereX 
WhereY 

Description

Les fonctions WhereX et WhereY renvoient respectivement le numéro de ligne et de colonne sur lesquelles se trouve le curseur. Les lignes et les colonnes sont numérotées par rapport au Coin supérieur gauche de la fenêtre utilisée. Si aucune fenêtre particulière n'a été Définie à l'aide de Window, elles sont numérotées respectivement de 1 à 25 et de 1 à 80.

Exemple

ligne := WhereX; 
colonne := WhereY; 
If ligne > 3 Then ligne := ligne - l; 
If colonne > 4 Then colonne := colonne - 1; 
GotoXY (ligne, colonne); 
WriteLn (ligne, colonne); 

Le curseur est déplacé d'une ligne vers le haut et d'une colonne vers la droite s'il se trouve dans une ligne supérieure à 3 et une colonne supérieure à 4.

While

Mot réservé 3, 4, 5, 6

Syntaxe

While exp Do instr;

où instr est une Instruction simple ou composée et exp 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 tant qu'une expression booléenne est 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 While, l'expression booléenne est évaluée avant que l'Instruction simple ou composée ne soit exécutée. On la préférera donc à la boucle Repeat lorsque l'Instruction ne doit pas nécessairement être exécutée ou lorsqu'il est dangereux qu'elle le soit.

· Il est nécessaire qu'une Instruction répétée, au moins, rende l'expression fausse, Sinon la boucle s'exécute indéfiniment.

· L'Instruction à répéter peut être simple ou composée, en pratique, cela signifie que s'il y en a plusieurs un bloc Begin..End est nécessaire.

· On peut montrer que la boucle For est un cas particulier de la boucle While. Bien que nécessitant un peu plus de programmation, la boucle While permet d'utiliser des réels comme variable de contrôle, et de placer l'incrémentation de cette variable où on le désire.

Exemple

r := 0.3l;
While r < z Do 
  Begin 
  r := r + 0.5; 
  val1 := val1 * 1.08; 
  val2 := val2 * 1.1; 
  WriteLn (val1, val2); 
  End; 

La boucle While est utilisée comme une boucle For à la différence que l'Incrément est de type réel.

Window

Procédure 3, CRT : 4, 5, 6

Syntaxe

Window (c_sup, l_sup, c_Inf, l_Inf);

où c_sup, I_sup, c_Inf et I_Inf sont des expressions de type Byte.

Description

La procédure Window redéfinit la fenêtre de lecture et d'écriture à l'écran. La fenêtre par défaut, en mode 80 colonnes, est l'écran tout entier, soit (1, 1, 80, 25). A partir du moment où une fenêtre est Définie, toutes les commandes qui portent sur l'écran, comme ClrScr, ne portent plus que sur l'espace Défini comme fenêtre. Toutes les lectures et les écritures se feront à L'intérieur de celle-ci jusqu'à Définition d'une autre fenêtre.

Remarques

· La fenêtre ne peut dépasser les limites de l'écran. En mode 80 colonnes, la fenêtre la plus grande est donc (1, 1, 80, 25).

· Tout appel dont les arguments seraient non valides (coordonnées hors des limites de l'écran, par exemple) est simplement ignoré.

Exemple

Window (10, 5, 25, 15) ; 
ClrScr; 

Crée et puis efface une fenêtre dont le Coin supérieur gauche est en 10^e colonne de la 5^e ligne et le Coin Inférieur droit sur la 25^e colonne de la 15^e ligne.

With

Mot réservé 3, 4, 5, 6

Syntaxe

With Indentrec Do instr ;

où identrec est un identificateur d'enregistrement et instr une Instruction simple ou composée.

Description

Ce mot réservé permet l'accès direct aux champs d'un enregistrement sans devoir préciser pour chaque accès le nom de la variable de type enregistrement. Plusieurs niveaux d'imbrication des Instructions WITH sont possibles.

Remarque

A L'intérieur d'une Instruction With le compilateur fait toujours référence au nom des champs de l'enregistrement. S'il existe une variable simple homonyme, celle-ci est Inaccessible.

Exemple

Var client : Record
      nom : String[25];
      prenom : String[10];
      adresse : String[50];
      End;
...

Begin
...
With client Do
  Begin
  ReadLn (nom); ReadLn (prenom);
  ReadLn (adresse)
  End;
End.

With est utilisé pour pouvoir lire les différents champs de client sans devoir le spécifier pour chaque opération.

Word

Identificateur de type   4, 5, 6

Syntaxe

     identv1, identv2,... : Word; 
ou   identt1, identt2,... = Word; 

où identv1, identv2,... sont des identificateurs de Variables et identt1, idenrt2,... sont des identificateurs de types.

Description

Ce mot est utilisé lors de la déclaration de Variables ou de types. Les Variables de ce type sont stockées en mémoire sous la forme de deux octets non signés; leur domaine de validité est donc 0..+65535. Il s'agit donc d'un Intervalle du type LongInt. Le type Word est compatible, dans son domaine, avec les autres types entiers.

Remarques

· La valeur des Variables de ce type doit être comprise entre 0 et +65535. 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 Word, 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.

· Ce type est une extension au Pascal standard.

Exemple

Type nbre = Word; 
Var alti, long : Word; 

Le type nbre est Défini comme synonyme de Word et les Variables alti et long sont définies de ce type.

Write

Procédure 3, SYS : 4, 5, 6

Syntaxe

Write (fich, Var1, Var2,...);

où fich est une variable de type fichier typé ou Text (optionnel) et Var1, Var2,... les Variables à écrire.

Description

La procédure Write permet d'écrire, dans un fichier ou sur un périphérique, des Variables en mémoire centrale. Si aucun nom de fichier n'est donné, l'écran sera considéré comme destination de type Text par défaut.

Remarques

· Avant toute opération d'écriture les fichiers doivent être ouverts avec Assign et Reset, Rewrite ou Append.

· Il doit y avoir correspondance de type entre les données qui sont écrites et le type de fichier (fichiers typés).

· Si Write ne peut écrire 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 {$I-} doit avoir été spécifiée.

· Sur des fichiers non typés, utilisez BlockWrite.

Exemple

Write (fich, enreg); 
Write (nbre1, nbre2, nbre3); 

La variable enreg est écrite sur le fichier fich. Les Variables nbre1, nbre2 et nbre3 sont écrites à l'écran. Rien dans la syntaxe ne permet de dissocier une écriture à l'écran d'une écriture dans un fichier. Il est donc important d'utiliser des identificateurs « parlants ».

WriteLn

Procédure 3, SYS : 4, 5, 6

Syntaxe

WriteLn (fich, Var1, Var2,...);

où fich est une variable de type fichier Text (optionnelle) et Var1, Var2,... les Variables à écrire.

Description

La procédure WriteLn permet d'écrire 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 écrites, elle force le passage à la ligne suivante, en ajoutant un caractère de fin de ligne (CR). Si aucun nom de fichier n'est donné, l'écran sera considéré comme destination par défaut.

Remarques

· Avant toute opération d'écriture les fichiers doivent être ouverts avec Assign et Rewrite ou Append.

· WriteLn ne peut être utilisé que sur des fichiers de type Text ou associés comme l'écran, l'imprimante...

· Si WriteLn 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 {$I-} doit avoir été spécifiée.

· WriteLn utilisé seul permet de passer à la ligne suivante sur un fichier ou à l'écran.

Exemple

WriteLn (nbre1, nhre2, nbre3); 
WriteLn (texte, ligne); 

Les Variables nbre1, nbre2 et nbre3 sont écrites à l'écran.

XOr

Opérateur   3, 4, 5, 6

Syntaxe

exp1 XOr exp2 

où exp1 et exp2 sont des expressions booléennes ou entières.

Description

L'opérateur XOr correspond au « ou exclusif » logique (expressions booléennes) et arithmétique (expressions arithmétiques). Dans le premier cas le résultat est True (vrai) si une et une seule des deux expressions 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 et une expression comme " r < 34.76 XOr j = 45 " donnera donc une erreur de compilation. L'emploi des parenthèses est Indispensable dans ce genre de cas.

Exemples

IF (r < 34.76) XOr (j = 45) Then ReadLn (r, 3);

Si r est plus petit que 34.47 ou j est égal à 45, mais que ces deux conditions ne sont pas remplies simultanément une opération d'écriture est effectuée.

Si

ent1 := 2; 
ent2 := 3; 
res  := ent1 XOr ent2; 

alors res vaudra 1:

entl : 00000010 
ent2 : 00000011 
---------------
res  : 00000001 

mentions légales . références . xhtml 1.0 . css2 . haut de page

copyleft 2000-3057 . Cédric Céline Éléana Dorian Amélien . France . All lefts reserved to all, simply inform us.