MICRO-INFORMATIQUE

GUIDE RAPIDE

TURBO PASCAL

Mise en œuvre • Eléments du

langage • Structure générale
d'un programme • Déclarations
• Types scalaires, types réels
• Types structurés • Pointeurs
• Fonctions et procédures •
Accès aux ressources de la
machine • Gestion des réper­
toires • Versions 5.0 et 5.5 •
Programmation orientée objet

PRESSES V POCKET
GUIDE RAPIDE
TURBO PASCAL
MICRO INFORMATIQUE

BÉNÉDICTE HUDAULT

GUIDE RAPIDE
TURBO PASCAL

PRESSES V POCKET

I
AVERTISSEMENT

Turbo Pascal est une marque déposée de Borland

International Inc.
Turbo Pascal est un produit de la société Borland
International Inc. qui en détient le copyright à l'échelon
mondial.
Ce livre n'est pas un manuel du logiciel Turbo Pascal et son
contenu n'engage pas la société Borland International Inc.
Nous vous rappelons, par ailleurs, les termes de l'article 57
de la loi du 3 juillet 1985
"Toute reproduction autre que l'établissement d'une copie
de sauvegarde par l'utilisateur, ainsi que toute utilisation
d'un logiciel non expressément autorisée par I 'auteur ou
ses ayants droit, est passible des sanctions prévues par la
loi."

Toutes les autres marques citées dans cet ouvrage sont

des marques déposées.

©P.S.I.
1989

Pour la présente édition

© Presses Pocket/P.S.I.
1989

ISBN 2-266-03523-1
ISSN : 1150-305X
 Sommaire

1. INTRODUCTION......................................... 10
Principales caractéristiques................................ 10
Contenu des disquettes....................................... 11
Extension des fichiers
créés sous Turbo Pascal................................... 12
2. MISE EN ŒUVRE DE TURBO................... 13
Menu principal.................................................... 13
Menu File fichier.............................................. 15
Commande Edit l'éditeur.................................. 16
Commande Run • exécution............................... 18
Menu Compile compilation.............................. 18
Menu Options...................................................... 19
3. ÉLÉMENTS DU LANGAGE........................ 23
Mots clés............................................................. 23
Identificateurs...................................................... 24
Symboles de ponctuation................................... 24
Séparateurs.......................................................... 25
Opérateurs........................................................... 25
4. STRUCTURE GÉNÉRALE
D’UN PROGRAMME........ 1................... 27
5. DÉCLARATIONS......................................... 28
Etiquettes LABEL............................................ 28
Constantes CONST.......................................... 28
Types TYPE...................................................... 29
Variables VAR................................................... 30
Fonctions et procédures...................................... 31
6. ENTRÉES/SORTIES..................................... 31
READ.................................................................. 31
READLN............................................................. 31
 WRITE................................................................
WRITELN...........................................................
Paramètres d'écriture..........................................
Organes logiques................................................
7. DÉROULEMENT DU PROGRAMME........
Branchement inconditionnel..............................
Alternative...........................................................
Aiguillage multiple.............................................
Boucles conditionnelles......................................
Boucle compteur................................................
Fonctions et procédures relatives au
déroulement du programme...........................
8. TYPES SCALAIRES, TYPES RÉELS.........
Types prédéfinis.................................................
Types définis par l'utilisateur.............................
Fonctions et procédures scalaires......................
Fonctions arithmétiques.....................................
Fonctions de transfert.........................................
Fonctions et procédures diverses.......................
9. TYPES STRUCTURÉS.................................
Chaînes. STRING.............................................
Tableaux • ARRAY OF..................................
Enregistrements • RECORD. END;...............
Ensembles SET OF..........................................

10. FICHIERS....................................................
Déclarations de fichiers......................................
Fonctions et procédures sur les fichiers
FILE OF et TEXT...........................................
Fonctions et procédures sur les fichiers
FILE OF...........................................................
Fonctions et procédures sur les fichiers
TEXT................................................................
Fichiers sans type FILE....................................
Vérification des entrées/sorties.........................
Représentation interne des fichiers...................

6
11. POINTEURS................................................ 58
Déclaration d'un pointeur................................... 59
Procédures pour créer une variable
dynamique........................................................ 59
Procédures pour récupérer de l'espace
dans le tas......................................................... 60
Opérateurs autorisés entre pointeurs
de type identique............................................. 61
Connaître l'espace disponible du tas................. 62
Fonctions et opérateurs d'adresse...................... 62
Structure de liste chaînée.................................... 62
12. FONCTIONS ET PROCÉDURES............... 64
En-tête d’une fonction........................................ 65
En-tête d'une procédure...................................... 65
Appel de fonction ou procédure........................ 65
Passage de paramètres........................................ 65
Exemples de fonctions et procédures................ 67
Procédure FORWARD....................................... 68
Sous-programmes externes................................ 68
Fichiers inclus..................................................... 70
13. ACCÉDER AUX RESSOURCES
DE LA MACHINE....................................... 71
Variables absolues.............................................. 71
Fonctions et variables d'adresse absolue........... 72
Allocation de la mémoire................................... 74
Gestion directe des pointeurs............................. 75
Insertion du code machine.................................. 76
Procédures INLINE............................................ 76
Accès direct à la mémoire........ ......................... 77
Accès direct aux ports d'entrées/sorties
du microprocesseur......................................... 77
14. GESTION DES RÉPERTOIRES................. 78

15. FICHIERS UNIT......................................... 79

Définition............................................................ 79
Bibliothèque [Link]................................. 79

7
 Unit [Link].............................................. 80
Structure d'un unit.............................................. 80
Utilisation d'units............................................... 81
Un unit, pour quoi faire ?................................... 82
Exemples d'units et de leur utilisation............... 83
Utilitaire TPUMOVER...................................... 84
16. L’UNIT CRT : GESTION
DE L'ÉCRAN ET SON,
L'UNIT PRINTER : GESTION
DE L'IMPRIMANTE .................................. 86
Constantes, types et variables (unit CRT)........ 86
Procédures et fonctions de gestion de l'écran
(unit CRT)........................................................ 88
Le son (unit CRT)............................................... 91
Gestion de l'imprimante (unit PRINTER)........ 91

17 UNIT DOS.................................................... 92
Constantes, types et variables............................. 92
Interruptions logicielles...................................... 94
Date et heure........................................................ 95
Etat du disque...................................................... 96
Procédures fichiers............................................. 96

18. UNIT GRAPH.............................................. 97

Constantes et types............................................. 97
Utiliser GRAPH.......................................... 100
Routines de mise en route de GRAPH.............. 101
Principales routines graphiques......................... 102

19. VERSIONS 5.0 ET 5.5................................. 111

Quelles modifications apportées aux
programmes de la version 4.0 ?...................... 111
Contenu des disquettes Turbo Pascal 5.5.......... 111
Mise en œuvre du logiciel.................................. 112
Environnement intégré....................................... 112
Débogueur intégré.............................................. 113
Directives de compilation................................... 113

8
 Type sous-programme........................................ 115
Lesoverlays......................................................... 116
20. PROGRAMMATION ORIENTÉE
OBJETS........................................................ 118
Type OBJECT..................................................... 119
L'héritage............................................................. 120
Méthodes virtuelles............................................ 122
A propos d'obj ets................................................ 127
ANNEXE 1 : Directives de compilation............. 132
Directives interrupteurs...................................... 132
Directives paramètres......................................... 134
Directives conditionnelles.................................. 135

ANNEXE 2 : Erreurs......................................... 137

Erreurs à la compilation..................................... 137
Erreurs à l'exécution........................................... 146

INDEX............................................................... 149

CONVENTIONS

Trois points de suspension " " dans la syntaxe indi­

quent que la séquence peut être répétée plusieurs fois.
Des guillemets introduits dans le texte ou les commen­
taires désignent des identificateurs définis par l'utilisa­
teur. Les mots en italique marquent les notions impor­
tantes. Pascal ne fait pas de distinction entre majuscules
et minuscules. Par souci de clarté, mots clés et identifi­
cateurs standard seront en majuscules alors que les iden­
tificateurs définis par l'utilisateur seront en minuscules.

9
 AVANT-PROPOS

Le nouvel aide-mémoire sur Turbo Pascal est résolu­

ment tourné vers l'avenir le lecteur n'y apprendra plus à
convertir des programmes de la version 3.0 vers la ver­
sion 4.0 mais de la version 4.0 vers les versions 5.0 et
5.5.
Le dernier chapitre consacré à la Programmation
Orientée Objets a été rédigé avec un grand souci de clar­
té, de simplicité et de concision. Le lecteur déjà averti
de ces techniques ne devra donc pas s'étonner de ne pas
y rencontrer les mots de "polymorphisme", "encapsula­
tion", "instanciation" et autres termes philosophiques qui
ont été délibérément bannis de notre propos.

1. Introduction
Principales caractéristiques
• Configuration minimale requise 384 Ko pour l'envi­
ronnement intégré et 256 Ko pour la ligne de com­
mande.
• Environnement de programmation intégré.
• Version "ligne de commande" du compilateur.
• Accès au DOS sans quitter Turbo.
• Nouveaux types d'entiers et de réels.
• Compilation de modules séparés (units).
• Remise en place lors du lancement dans le dernier
programme utilisé.
® Adaptation aux cartes graphiques EGA, CGA,
VGA, MCGA, Hercules, AT&T 400 line et 3270 PC.
• Limites exprimées en nombre de segments de 64 Ko.
• Un segment de code objet par programme ou unit. Le
nombre d'units utilisés par un programme n'est pas

10
 limité. La seule limite à la taille du programme exé­
cutable est liée à celle de la mémoire.
- Un segment pour les données.
- Un segment pour la pile.
- Plusieurs segments pour le tas.
- Un segment pour le code source géré par l'éditeur.

Contenu des disquettes

La disquette 1 :
- [Link] compilateur, éditeur intégrés (version
la plus utilisée).
- [Link] librairie contenant les fichiers units
SYSTEM, CRT, DOS, PRINTER, TURBO3,
GRAPH3.
- [Link] écrans d'aide à l'utilisateur.
- [Link] autre compilateur 4.0 (ligne de comman­
de) sans environnement intégré.
- LISEZMOI dernières corrections du système.
- [Link] affiche le contenu de LISEZ-
MOI.
La disquette 2 :
- des exemples de programmes en Turbo Pascal .PAS.
- des utilitaires .EXE ou .COM.
- des fichiers de documentation utilisateur .DOC en
ASCII.
La disquette 3 :
- l'unit [Link] (routines graphiques).
- les fichiers graphiques .BGI utilisés par GRAPH
pour l'initialisation d'un mode graphique.
- les fichiers .CHR qui contiennent diverses polices de
caractères utilisables avec GRAPH.
- le fichier de documentation graphique [Link]
- des exemples .PAS.
- un fichier archive [Link] (ensemble
d’exemples graphiques) accompagné d'un utilitaire
de désarchivage [Link] (Version 4.0 uni­
quement).

11
Principaux programmes Pascal
- [Link] liste un programme Turbo sur l’impri­
mante. Les fichiers .PAS sont en ASCII, les com­
mandes DOS COPY fichier PRN ou PRINT fichier
permettent également de lister les programmes Turbo
sur l'imprimante.
- les fichiers [Link] se rapportent à une partie de
Turbo. Ils sont à étudier par l'utilisateur en difficulté
sur le thème.
Exemple
[Link] utilisation des routines de [Link].
Principaux utilitaires
- [Link] installation du terminal.
- [Link] convertit les programmes TPM en
.MAP Les programmes .MAP peuvent être suivis à
la trace par un débogueur (Périscope, par exemple).
Cela nécessite d'être familiarisé avec l'assembleur.
- [Link] regroupe les fichiers TPU utili­
sateurs en une bibliothèque TPL, ou les ajoute à la
bibliothèque [Link].
- [Link] aide à la conversion de pro­
grammes Turbo version 3.0, en programmes version
4.0 (Version 4.0 uniquement).
- [Link] convertit (et réciproquement) un
fichier de configuration TP, créé sous TURBO
(environnement intégré) en un fichier de configura­
tion [Link] utilisable sous le compilateur TPC
(ligne de commande).
- [Link] gestionnaire de projets, ne travaille
qu'avec la ligne de commande [Link].
- [Link] mise à jour de la date et de l'heure
d'un ou plusieurs fichiers.

Extension des fichiers créés sous Turbo Pascal

.PAS donnée par défaut aux programmes créés sous
Turbo. L'utilisateur peut définir une extension de son

12
choix ou pas d'extension (le nom du fichier doit alors se
terminer par un point).
.BAK affectée par Turbo à la version primitive du pro­
gramme lors d'une nouvelle sauvegarde.
.EXE code objet (programme compilé) exécutable sous
MS-DOS.
.TPU code objet d'un unit.
.TPL bibliothèque Turbo Pascal.
.TPM généré par l'option de compilation {$T+}.
.PCK état de l'environnement intégré quand l'utilisateur
quitte [Link].
.TP et .CFG configurations du système pour les deux
compilateurs TURBO et TPC.

2. Mise en œuvre
de TURBO
Taper à partir du système d'exploitation TURBO EJ

Menu principal
L'écran suivant est généré
File Edit Run Compile Options
------------ Edit ---------------------------------
Line 1 Col 1 Insert Indent A:[Link]

A>Turbo
(
Fl-Help F2-Save F3-Load F5-Zoom F6-Edit F9-Make FlO-Main menu

13
L'écran est divisé en deux fenêtres Edit (éditeur) et
Output (Entrées/sorties du programme), le tout surmonté
de la ligne portant les mentions
File Edit Run Compile Options
Les options File, Compile et Options déroulent un sous-
menu, Edit active la fenêtre d'édition, Run exécute le
programme en cours d'édition.
On active un sous-menu depuis le menu principal ou une
option d'un sous-menu, soit
- en déplaçant le pointeur lumineux sur l'option choi­
sie, puis en enfonçant Retum.
en tapant la première lettre de l'option.
La dernière ligne de l'écran donne la signification des
touches fonctions
Fl Affiche une aide à l'utilisateur.
F2 Sauve le programme en cours d'édition sur le
disque.
F3 Charge un nouveau fichier dans l'éditeur.
F5 Agrandit la fenêtre active à tout l'écran.
F6 Change de fenêtre active (la fenêtre active est sur­
montée d'un double trait).
F9 Compile et lie le programme en cours d'édition, le
transformant en un programme objet directement
exécutable.
F10 Retour au menu principal.

A tout moment, il est possible d'activer directement un

sous-menu, sans retourner sous le menu principal en
pressant simultanément Ait ou F10 et la première lettre
de l'option choisie.
La touche Esc permet de quitter le menu actif pour
retourner au menu de niveau supérieur. Sous l'éditeur,
elle est inactive, sous le menu principal, Esc active l'édi­
teur.
Les touches Ait et Ctrl combinées à certaines touches
permettent d'activer diverses commandes. Pour

14
connaître ces possibilités, maintenez la touche Ait
enfoncée un moment, la dernière ligne de l'écran affi­
chera leurs significations.
Signalons toutefois
Ait Fl réaffiche le dernier écran d'aide (il est possible
de remonter jusqu'à 20 niveaux antérieurs).
Ait X retour sous DOS.
Ctrl-Fl aide sur le langage dans l'éditeur.
Il existe trois sortes de commandes dans l'environne­
ment intégré
- les commandes pour accomplir une tâche . compiler,
exécuter
- les commandes interrupteurs • On/Off
- les commandes pour transmettre des informations au
compilateur répertoires, configuration de la mé­
moire.

Menu File : fichier

Fila Edit Run Compile Options

------------ ;---------- Edit ----------------------------
Load--------------- Col 1 Insert Indent A:[Link]
Pick
New
Save
Write to
Directory
Change dir
OS shell
Quit

Load
Charge un fichier en mémoire. Il est possible d'utiliser
un masque du DOS, puis de choisir un fichier dans la
liste, ou de spécifier directement un nom de fichier.
Pick
Affiche la liste des huit derniers fichiers chargés dans
l'éditeur, le premier de la liste est celui qui est dans l'édi­
teur. Pour charger un des fichiers de la liste en mémoire,
placer le pointeur lumineux sur celui-ci puis enfoncer
Return.
15
New
Vous place dans l'éditeur pour un nouveau fichier
([Link]).
Save
Même action que F2. Si le fichier s'appelle NONAME,
Turbo propose de le renommer.
Write to
Sauve le fichier sous un nouveau nom. Si un fichier du
même nom existe, Turbo demande confirmation pour
l'écraser.
Directory
Affiche le contenu du répertoire courant. Il est possible
d'utiliser un masque du DOS.
Change dir
Permet de changer d'unité active et/ou de répertoire cou­
rant.
OS shell
Permet d'aller exécuter une commande du DOS, puis de
revenir sous Turbo en tapant "exit"
Quit
Retour sous DOS. Analogue à Alt-X.

Commande Edit : l'éditeur

La première ligne de l'éditeur donne des informations
sur l'édition
Line n numéro de ligne du curseur
Col n numéro de colonne du curseur
Insert mode insertion actif
Indent mode indentation actif
Tab tabulations actives
A:[Link] unité, nom et extension du fichier
en cours d'édition. Turbo affecte par
défaut le nom NONAME au fichier
en cours d'édition.

16
Déplacement du curseur

déplacement d'un caractère dans la

PgUp
m direction indiquée.

écran précédent,
PgDn écran suivant,
Home début de ligne,
End fin de ligne,
Ctrl Q R début de fichier,
Ctrl Q C fin de fichier,
Ctrl Q B début de bloc,
Ctrl Q K fin de bloc,
Ctrl Q P dernière position du curseur,
Ctrl Q T pose de tabulations.

Effacement

Ctrl G ou Del efface le caractère sous le curseur.

del efface le caractère à gauche du curseur (sur certains

ordinateurs, la touche est marquée )•

Ctrl T efface le mot à droite du curseur.
Ctrl Y efface la ligne sous le curseur.

Commandes de modification
Ctrl N insère une ligne à la position du curseur.
Ins bascule du mode insertion en recouvre­
ment et vice versa.
Ctrl QI supprime ou active l'indentation.

Recherche et remplacement
Ctrl Q F Recherche
Ctrl Q F Recherche et remplace

17
Utilisation des blocs
Ctrl K B marque un début de bloc.
Ctrl K K marque une fin de bloc (le bloc marqué
apparaît en surbrillance).
Ctrl K H supprime les repères de bloc.
Ctrl K V déplace le bloc à la position du curseur.
Ctrl K C duplique le bloc à la position du curseur.
Ctrl K Y détruit le bloc.
Ctrl K R lecture d'un bloc depuis le disque (donner
après avoir introduit la commande le nom
du fichier à lire).
Ctrl K W écriture d'un bloc sur le disque (donner
après avoir introduit la commande le nom
du fichier à créer ou recréer).

Commande Run : exécution

Compile et lie (s'il y a lieu), puis exécute le programme
en mémoire.
A la fin de l'exécution, Turbo affiche
Press any key to return to Turbo Pascal

Menu Compile : compilation

File Edit Run Compila Options

Line 1 Col 1 Inse Compile

Make
Build
Destination Memory
Find error
Primary file:
Get info

Compile
Compile le programme en cours d'édition.
Si tout s'est bien passé, Turbo affiche
Success. Press any key
Make
Recompile les units utilisés par le programme principal
(programme en cours d'édition ou Primary file), mais

18
uniquement ceux qui ont été modifiés depuis la dernière
compilation du programme.
Build
Recompile tous les units utilisés par le programme prin­
cipal (programme en cours d'édition, ou Primary file).
Destination
Il s'agit d'une commande interrupteur par défaut la
compilation du programme principal ne gère pas de
fichier .EXE sur le disque.
Cette commande est sans effet sur Make et Build qui
génèrent toujours des fichiers TPU sur le disque.
Find error
Lorsqu'une erreur survient à l'exécution d'un programme
.EXE (sous DOS), son adresse est donnée sous forme
segment offset.
La commande Find effor permet de localiser Teneur
dans le programme source en donnant son adresse, à
condition que le programme ait été compilé avec la
directive {$D+} (D est active par défaut).
Primary file
Est à utiliser avant les options Make ou Build pour spé­
cifier le fichier principal.
Get info
Ouvre une fenêtre donnant toutes sortes d'informations
sur le programme en cours d'édition.

Menu Options

File Edit Run Compile Options

----------------------------------------------------------- Edit
Line 1 Col 1 Insert Indent Compiler
Environment
Directories
Parameters
Load options
Save options
 Le sous-menu Compiler
Ce menu permet de spécifier les directives interrupteurs
ainsi que {SDEFINE} et {$M} depuis l'environnement
intégré.
La liste suivante donne la correspondance entre les
options et les directives (voir Annexe 1 "Les directives
de compilation").
Range checking Off ($R-)
Stack checking On {$S+}
I/O checking On {$1+}
Debug information On {$D+}
Turbo Pascal map file Off [$T-J
Force far calls Off {$F-}
Var-string checking Strict {$V+}
Boolean évaluation Short circuit {SB-}
Numeric processing Software {$N-}
Link buffer Memory {$L+}
Conditional defines [SDEFINE nom}
Memory size [$M pile,tasmin,tasmax}

Le sous-menu Environment
Edit Run Compile Option*
----------------------------------------- Edit
Line 2 Col 1 Insert Indent Compiler
Environment
Back up source files On
Edit auto save Off
Config auto save Off
Retain saved screen On
Tab size 8
Zoom Windows Off
Screen size

Back up source files

Par défaut, Turbo crée un fichier .BAK pour la version
primitive du programme lors d'une nouvelle sauvegarde.
Edit auto save
Par défaut, Turbo ne sauve pas le programme source
avant l'utilisation de Run ou OS Shell.

20
Config Auto save
Par défaut, Turbo ne sauve pas les options choisies
(Compiler, Environment, Directories) dans le fichier de
configuration TP
Retain saved screen
Par défaut, Turbo sauve le dernier écran avant Run ou
OS shell qui est restitué après retour sous Turbo.
Tab size
Le nombre de tabulations de l'éditeur est de 8 par défaut.
Ce nombre peut être modifié de 2 à 16. Ctrl OT doit être
actif pour utiliser les tabulations.
Zoom Windows
Par défaut, Turbo partage l'écran entre les deux fenêtres
(éditeur et extérieure). En mode actif, une seule fenêtre
occupe la totalité de l'écran.
Screen size
Permet de choisir entre 25, 43 (EGA) ou 50 (VGA)
lignes, si l'ordinateur est équipé des cartes correspon­
dantes.
Le sous-menu Directories : les chemins d'accès
File Edit Run Compile options
------- frit
Line 2 Col 1 Insert Indent Compiler
Environment
Directories
Turbo directory:
Exécutable directory:
Include directories:
Unit directories:
Object directories:
Pick file name:
Current pick file:

Pour les commandes supportant plusieurs chemins, ceux-

ci seront énumérés et séparés par des points-virgules
Turbo directory
Spécifie le chemin d'accès du fichier de configuration
TP et des fichiers d'aide [Link]

21
Exécutable directory
Spécifie le chemin d'accès des fichiers exécutables
.EXE.
Include directories
Spécifie les chemins d'accès des fichiers inclus (directi­
ve {$1 nom_fic}).
Unit directories
Spécifie les chemins d'accès des units TPU.
Object directories
Spécifie les chemins d'accès des fichiers .OBJ
Pick file name
Le menu File/Pick affiche la liste (Pick List) des 8 der­
niers fichiers chargés dans l'éditeur. La commande Pick
file name permet de sauver la liste (Pick List) dans un
fichier .PCK au moment où l'utilisateur quittera Turbo.
Le fichier Pick a le nom TURBO. PCK par défaut. Un
nom différent doit figurer dans le fichier de configura­
tion.
Si un fichier .PCK existe, l'environnement intégré repo­
sitionnera l'utilisateur dans le dernier programme utilisé
lors du prochain lancement.
Current pick file
Ce n'est pas une commande, mais il affiche le nom du
fichier Pick courant. Si aucun nom ne figure à l'écran,
cela signifie qu'aucun fichier .PCK n'a été créé, vous ne
serez donc pas repositionné dans votre programme lors
d'un prochain lancement.
Le sous-menu Parameters
Permet de passer des arguments à un programme (voir
chapitre 12 "Passage des paramètres").
Le sous-menu Load options
Charge un fichier de configuration (extension TP,
[Link] par défaut).

22
Le sous-menu Save options
Sauve toutes les options sélectionnées (Compiler,
Environment, Directories) dans un fichier de configura­
tion (extension TP, [Link] par défaut).
Le fichier de configuration [Link] peut être
créé/modifié sous l'environnement intégré (voir ci-des­
sus) ou bien à l'aide de l'utilitaire TINST,

3. Eléments
du langage

Mots clés
Ils constituent le vocabulaire du langage. Ils ne peuvent
pas être redéfinis par l’utilisateur
ABSOLUTE AND ARRAY
BEGIN CASE CONST
DIV DO DOWNTO
ELSE END EXTERNAL
FILE FOR FORWARD
FUNCTION GOTO IF
IMPLEMENTATION IN INLINE
INTERFACE INTERRUPT LABEL
MOD NIL NOT
OF OR PACKED
PROCEDURE PROGRAM RECORD
REPEAT SET SHL
SHR STRING THEN
TO TYPE UNTIL
USES VAR WHILE
WITH XOR

23
Identificateurs
Identificateurs standard ou prédéfinis
Peuvent être éventuellement redéfinis par l'utilisateur
(c'est totalement déconseillé).
Il existe deux sortes d'identificateurs prédéfinis ceux
qui sont toujours définis et ceux qui sont locaux à un
unit. Pour disposer de ces derniers, le programme doit
mentionner l'unit utilisé (voir chapitre 15 "Utilisation
d'units").
Identificateurs définis par l'utilisateur
- Désignent un programme, un unit, une étiquette, un
type, une variable, une constante, une fonction ou
une procédure.
- Sont locaux à la procédure (fonction) où ils ont été
définis, et globaux à toutes les procédures (fonctions)
internes à leur niveau de définition. Un objet ne peut
être atteint, à un niveau donné, que s'il est défini à
ce niveau ou à un niveau supérieur
- Sont composés de lettres, de chiffres et du caractère
souligné.
- Commencent obligatoirement par une lettre.
- Peuvent avoir une longueur quelconque, seuls les 63
premiers caractères sont significatifs.

Symboles de ponctuation
; obligatoire après chaque instruction, sauf si elle
est suivie de END, ELSE ou UNTIL.
, séparateur d'éléments d'une liste.
: séparateur entre une liste de variables et son type
dans la déclaration de variables.
= séparateur d'un type et de sa description dans la
déclaration de type.
() encadrent la description d'un type dans les décla­
rations ou la liste des paramètres d'une fonction
ou d'une procédure.
[] encadrent les indices des tableaux et les éléments
d'un ensemble.

24
(* *) encadrent les commentaires et les directives de
compilation.
. fin de programme ou séparateur décimal.
.. figurent entre les bornes d'un intervalle.
'’ encadrent une chaîne de caractères.
A utilisé pour les variables pointeurs ou pour déno­
ter la touche CtrI dans les chaînes de caractères.
$ suivi d'une constante entière, dénote une constan­
te hexadécimale.
# suivi d'une constante entière, dénote le caractère
ayant le code ASCII correspondant.
Exemple
#65 = 'A'

Séparateurs
Les éléments du langage doivent être séparés par au
moins un des délimiteurs suivants un espace, une fin de
ligne ou un commentaire.
La longueur d'une ligne est de 126 caractères.

Opérateurs
L'affectation
Variable = expression ou variable ,
Les affectations à des variables de tout type, excepté le
type fichier, sont autorisées. Variable, fonction ou
expression doivent être de type compatible (voir cha­
pitre 5 "Les types : TYPE").
Exemple
delta = b * b - 4 * a* c;

Opérateurs arithmétiques
+ - * / et DIV MOD SHL SHR
Les opérateurs +, -, *, / pour lesquels
- les opérandes sont entiers ou réels
- le résultat est du type des opérandes sauf pour la
division dont le résultat est toujours réel.

25
Les opérateurs DIV (division entière), MOD (opérateur
modulo), SHL (décalage à gauche), SHR (décalage à
droite), pour lesquels
- les opérandes et le résultat sont entiers.
Exemple
547 MOD 23 = 18
2 SHL 9 =1024
Remarques :
11 n'existe pas d'opérateur puissance en Pascal.
Opérateurs logiques NOT AND OR XOR
- les opérandes sont entiers ou booléens.
- le résultat est du type des opérandes.
Exemple
12 AND 43 =8
TRUE OR FALSE = TRUE

Opérateurs relationnels = <>>=<=><

- les opérandes peuvent être de tout type scalaire ou
réel.
- le résultat est booléen.
Exemple
(a< >b) AND c

Remarque :
Des parenthèses encadrent obligatoirement les expres­
sions composées dans l'utilisation d'opérateurs logiques.
Priorité d'évaluation d'une expression

0 1 haute
- (négation) 2
NOT 3
* / DIV MOD AND SHL SHR 4
+ - OR XOR 5
= <>><<=>= IN 6
:= 7 basse

26
Opérateurs d'adresse @ A
@ suivi du nom d'une variable est l'adresse de cette
variable.
A (voir chapitre 11 "Déclaration d'un pointeur").

Les types structurés et pointeur admettent certains opé­

rateurs (voir chaque type).

4. Structure générale
d'un programme

En-tête du programme
PROGRAM nom_programme(paraml, param2. .);
L'en-tête optionnel permet de donner un nom au pro­
gramme et de passer d'éventuels paramètres (voir cha­
pitre 12 "Passage de paramètres").

Exemple .
PROGRAM ESSAI,

Déclarations
LABEL étiquettes
CONST constantes
TYPE type de données
VAR variables
PROCEDURE fonctions et
FUNCTION sous-programmes

27
Partie instructions
BEGIN

END.
L'ordre de description des divers modules est impératif.
Un ou plusieurs modules peuvent être vides ou absents.
Ainsi, le plus pauvre des programmes Pascal compren­
dra les seuls mots
BEGIN
END.

5. Déclarations

Etiquettes : LABEL
LABEL etiquettel,etiquette2,. .,

Exemple
LABEL début,fin,

Constantes : CONST
CONST constantel type 1 = valeur 1,
constante2 type2 = valeur2,

Le type de chaque constante peut être omis (constante

sans type).
Le type CONST est particulièrement utile pour créer des
fichiers de données en mémoire vive avec des
constantes structurées (tableaux, enregistrements,
ensembles).

28
Pour les tableaux et les enregistrements, les valeurs des
constantes de chaque dimension (rubriques) sont entre
parenthèses séparées par des virgules.
Exemple
CONST
e REAL = 2.718281829;
voyelle • SET OF ’a’.-'z' = ['a'.'e’.’i'.'o'.'u.'y'];
matrice : ARRAY[1..2,1..2] OF INTEGER
= ((1.2),(3,4)),
Constantes prédéfinies
PI =3.1415926536E+OO
FALSE
TRUE
MAXINT = 32767

Types : TYPE
TYPE type 1 = description_type 1,
type2 = description_type2;

Exemples
TYPE nombres = INTEGER;
caractères = SET OF CHAR;
fiches = RECORD;
nom STRING[20];
âge INTEGER
END;

Compatibilité de type

Les types scalaires sont compatibles avec les types sca­

laires inclus dans leur intervalle de définition. Il en est
de même pour les types réels.
Une variable INTEGER pourra recevoir une variable
B YTE par exemple.
En outre, un réel est compatible avec un entier.
La compatibilité pour les types structurés est vue avec
chaque type.

29
 LES TYPES

Variables : VAR
VAR variable 11,variable 12, typel,
variable21,variable22, type2;

Exemple
VAR entier,a,b INTEGER;
matrice • ARRAY[1..10,1..20] OF BYTE,

30
Fonctions et procédures
Elles ont une structure identique au programme princi­
pal, seuls diffèrent
- l'en-tête (voir chapitre 12 . "En-tête d'une fonction"
et "En-tête d'une procédure").
- le point " " final du programme est remplacé par un
point-virgule dans les sous-programmes.

6. Entrées/sorties
Les quatre procédures standard READ, READLN,
WRITE et WRITELN permettent de lire et d'écrire des
données de tout type sur un fichier.

READ
READ(fichier,variable 1 ,variable2,. .);
READ lit sur le fichier spécifié des valeurs et les assigne
aux variables de la liste.
Les types des variables doivent correspondre aux don­
nées entrées. Les valeurs entrées sont lues en séquence
et doivent être séparées par au moins un espace.
Le fichier standard INPUT (le clavier) est pris par
défaut.
Exemple
READ(a),
READ(INPUT,a);(*sont équivalents*)

READLN
READLN(fichier,variablel,variable2,. .);

31
READLN est une variante de l'instruction READ (même
syntaxe, mêmes remarques).
La différence entres les instructions READ et READLN
tient en ce que READ ne peut détecter une fin de ligne
alors que READLN en a la possibilité.
Exemple
READ(a,b);
READ(c);
L'ordinateur lira les données à affecter à "a", "b" et "c"
séparées par des espaces sur une même ligne, alors que
lors des instructions
READLN(a.b);
READ(c);
l'ordinateur, après avoir lu séquentiellement les données
à affecter à "a" et "b", saisira "c" à la ligne suivante, la
fin de la première ligne étant ignorée.

WRITE
WRITE(fichier,varl,vall,var2,val2,. .);
WRITE écrit sur le fichier spécifié les variables
(varl,var2,. .) et les valeurs (vall,val2,. .) de la liste
(ordre indifférent). Le fichier standard OUTPUT
(l'écran) est pris par défaut.
Exemple
a =3
WRITE ('3 = ',a),
affichera
a = 3 si a est entier
a = 3.0000000000E+00 si a est réel.

WRITELN
WRITELN(fichier,varl ,vall ,var2,val2,. .);
WRITELN est une variante de WRITE (même syntaxe,
mêmes remarques). WRITELN est équivalente à un
WRITE suivi d'un retour chariot.

32
WRITELN; sans variable ni chaîne produira un saut de
ligne.
Exemple
WRITE(*Programmer en ');
WRITELN('Turbo Pascal •');
WRITELNfest facile.');
affichera
Programmer en Turbo Pascal
est facile.
Remarque :
Les variables de type ensemble ou de type défini par
l'utilisateur par énumération ne peuvent être utilisées
dans les instructions d'entrées sorties que sur les fichiers
utilisateurs, et non sur les organes logiques ou les
fichiers standard (INPUT et OUTPUT).
Exemple
TYPÉ notes = (dau,re,mi,fa,sol,la,si);
VAR note notes;
ensemble SET OF ['a'..'x'];
fichier TEXT;
BEGIN
note:= mi;
ensembles ['a','b'];
WRITE(note);(*diagnostiquera une erreur*)
WRITE(ensemble),
(‘diagnostiquera une erreur*)
WRITE(fichier,note);(*est correct*)
WRITE(fichier,ensemble)(*est correct*)
END.

Paramètres d'écriture
La longueur du champ d'une variable peut être spécifiée
(valable pour WRITE et WRITELN).
WRITE(variable:longueur,. .);
La variable spécifiée peut être de type caractère, chaîne,
booléen, entier ou réel. La variable sort justifiée à droite
dans un champ égal à la longueur spécifiée.

33
Les variables réelles
Elles sortent par défaut en virgule flottante, justifiées à
droite dans un champ de 8 caractères par défaut, avec le
format
espace signe 1 chiffre lOchiffres E signe 2chiffres
La représentation décimale
WRITE(variable:longueurl :longueur2).
Avec ces spécifications, la variable spécifiée sortira en
format décimal. "Iongueur2" spécifie le nombre de déci­
males.
Exemple
a:= 3.456,
WRITELN(a),
WRITELN(a:8);
WRITELN(a:8:2);
affichera 3.4560000000E+00
3.46E+00
3.46

Organes logiques
CON écran/clavier
TRM le terminal
LPT1, LPT2, LPT3 les imprimantes (PRN synonyme
de LPT1)
C0M1, COM2 sorties séries auxiliaires (AUX synony­
me de C0M1)
NUL sortie fictive
USR l'organe utilisateur
sont considérés par Turbo Pascal comme des fichiers
textes. Ils ne sont pas prédéfinis dans la version 4.0. Il
convient donc, pour utiliser les organes logiques du
DOS, de les assigner préalablement à une variable
TEXT

Voir chapitre 10 "Vérification des entrées/sorties" , éga­

lement chapitre 13 "Accès direct aux ports d'entrées/sor-
ties du microprocesseur"

34
7. Déroulement
du programme
Instructions simples : toutes les instructions.
Instructions composées : séquence d'instructions
séparées par des et comprises entre les mots
BEGIN et END.

Branchement inconditionnel
GOTO étiquette
Exemple
GOTO début;

Alternative
IF condition THEN instructionl
ELSE instruction2;
- "condition" est une expression booléenne.
- "instructionl" et "instruction2" sont des instructions
simples ou composées.
- ELSE est optionnel.
Si "condition" est TRUE, "instructionl" est exécutée,
sinon c'est "instruction" qui le sera.
Exemple
IF a>b THEN WRITELN('a>b')
ELSE WRITELN('a% b');

Aiguillage multiple
CASE variable OF
étiquette 1 instructionl,
etiquette2 instruction2;

35
ELSE instruction
END;
"variable" est de type scalaire (réels et chaînes inter­
dits).
- "étiquette 1", "etiquette2" doivent être du type de
"variable"
- ELSE est optionnel.
- Si "variable" = "etiquettel" c'est "instructionl" qui
est exécutée, si "variable" = "etiquette2", c'est "ins­
truction" qui est exécutée, si "variable" est différen­
te de toutes les étiquettes, c’est "instruction" qui est
exécutée.
Exemple
CASE i OF
1.. 9 WRITELN('1 < i < 10'),
10 WRITELN('i=10');
11.. 19 WRITELN('1O < i < 20')
ELSE WRITELN('i <1 ou i > 20')
END;

Boucles conditionnelles
WHILE condition DO
instruction;
- "condition" est booléen.
- tant que "condition" est TRUE "instruction" est exé­
cutée.
Exemple
x:= 0;
WHILE x<= 10 DO
BEGIN
x:= x + 1, (*ou NC(x)‘)
WRITELN(x)
END;

REPEAT
instructionl,
instruction;

36
 UNTIL condition;
- "condition" est booléen.
- La séquence d'instructions comprise entre REPEAT
et UNTIL est exécutée aussi longtemps que condi­
tion est FALSE.
Exemple
x:= 0;
REPEAT
x:=x + 1,
WRITELN(x)
UNTILx = 10,

Boucle compteur
FOR compteur = val_initiale TO val_finale DO
instruction;
- "compteur" doit être de type scalaire.
- "val_initiale" et "val_finale" doivent être du type de
"compteur"
- "instruction" sera exécutée pour "compteur" variant
de "val_initiale" à "val_finale" par pas de 1 Le pas
peut être de -1 en remplaçant TO par DOWNTO.
Exemple •
FOR ch := 'a' TO ’z’ DO
WRITELN(ch);

Fonctions et procédures relatives au

déroulement du programme
Il existe un certain nombre de procédures (fonctions)
prédéfinies. L'utilisateur peut également définir ses
propres procédures (voir chapitre 12).

EXIT;
Procédure qui provoque l'arrêt du bloc en cours et passe
le contrôle au bloc de niveau supérieur.

37
HALT(code);
Procédure qui provoque l'arrêt du programme et le retour
sous MS-DOS ou Turbo si le programme a été lancé
depuis ce dernier, "code" de type WORD est optionnel,
"code" sera transmis au processus qui a lancé le pro­
gramme. La fonction ERRORLEVEL de MS-DOS per­
met de tester "code" "code" = 0, si tout s'est bien passé.
Sans paramètre, le code 0 est renvoyé.

8. Types scalaires,
types réels
Types prédéfinis

Les entiers
VAR variable 1, variable2,.. type_entiers;
il existe 5 types d'entiers en Turbo Pascal version 4.0.

Type Limites Taille en octets

BYTE 0..255 1
SHORTINT -128.. 127 1 4
INTEGER -32768-32767 2
WORD 0..65535 2
LONG INT -2147483648..2147483647 4

Le signe "$" devant une valeur entière spécifie que

celle-ci est exprimée en hexadécimal.
Exemple
$41 = 65

38
Les booléens BOOLEAN
VAR variable 1, variable2. • BOOLEAN;
- ne peuvent prendre que 2 valeurs TRUE ou FALSE
- FALSE < TRUE
Les caractères CHAR
VAR variable 1, variable2. CHAR;
- occupent un octet en mémoire.
- définissent un élément des 256 caractères ASCII.
- l'ordre des caractères est la séquence ASCII.
- des apostrophes encadrent obligatoirement un carac­
tère.
Exemple
VAR ch ■ CHAR;
BEGIN
ch := 'a'
END.
Les réels
VAR variable 1, variable2,. type_reel;
En plus du type REAL, si votre ordinateur est équipé
d'un coprocesseur arithmétique 8087/80287/80387,
Turbo Pascal propose quatre autres types de réels .
SINGLE, DOUBLE, EXTENDED et COMP 2^ <{. .faa

Types Limites Nb de chiffres Taille en octets

significatifs
g
REAL E-38..E+38 11 6
SINGLE E-38..E+38 7 4
DOUBLE E-38..E+38 8 '( 15
EXTENDED E-4931..E+4931 10 <5
COMP -2»S..2B-1 8 lî Xl
—’ .Z , ---------------- îkitL

Remarque:
Les réels ne sont pas considérés comme des scalaires.
Dans la suite du manuel, la mention "scalaire" exclut
les réels.

39
Types définis par l'utilisateur
Les intervalles..
TYPE intervalle = bome_inf..bome_sup;
où "bome_inf ' et "bome_sup" sont d'un même type sca­
laire déjà défini.
— Un intervalle restreint un type scalaire déjà défini. Le
type BYTE est un intervalle 0. .255 de type INTE­
GER.
- Un intervalle conserve toutes les propriétés du type
scalaire associé.
Exemple
TYPE lettres ='a'..,b';
angles = 0..360;
Les énumérations ( )
TYPE énumération = (valeurl,valeur2,..);
Exemple
TYPE notes = (dau,re,mi,fa,sol,la,si),
Les prédéfinis
Tous les types prédéfinis scalaire, réel, structuré, fichier
et pointeur peuvent être redéfinis par l'utilisateur.
Exemple
TYPE entiers = INTEGER;
matrice = ARRAY[1 .4,1 ..4] OF REAL,

Fonctions et procédures scalaires

PRED(arg);
Fonction qui retourne le prédécesseur de "arg" (scalaire).
SUCC(arg);
Fonction qui retourne le successeur de "arg" (scalaire).
Exemple
PRED(mi) = re
INC (arg,nombre);
Procédure qui incrémente la variable "arg" (scalaire) de

40
"nombre" (entier), "nombre" est optionnel et est pris
égal à 1 par défaut.
Exemple
INC(n),(*n :=n +1*)

DEC(arg,nombre);
Procédure qui décrémente la variable "arg" de
"nombre" Mêmes remarques que pour INC.

Fonctions arithmétiques
Dans tout ce qui suit, "nombre" désigne un nombre ou
une expression numérique, "angle" est exprimé en
radians.
ABS(nombre);
Retourne la valeur absolue de "nombre" (entier ou réel).
ARCTAN(nombre);
Retourne l'angle (réel) en radians dont la tangente est
"nombre" (entier ou réel).
COS(angle);
Retourne le cosinus (réel) de "angle" exprimé en radians
(entier ou réel).
EXP(nombre);
Retourne l'exponentielle (réel) de "nombre" (entier ou
réel).
FRAC(nombre);
Retourne la partie décimale (réel) de "nombre" (entier
ou réel).
FRAC(x) = x - INT(x)
INT(nombre);
Retourne la partie entière de "nombre" (entier ou réel).
LN(nombre);
Retourne le logarithme népérien (réel) de "nombre"
(entier ou réel).

41
SIN(angle);
Retourne le sinus (réel) de "angle" exprimé en radians
(entier ou réel).
SQR(nombre);
Retourne le carré de "nombre" (entier ou réel).
SQRT(nombre);
Retourne la racine carrée (réel) de "nombre" (entier ou
réel).

Fonctions de transfert

CHR(nombre);
Retourne le caractère (CHAR) dont le code ASCII est
"caractère" (entier).
ORD(arg);
Retourne la valeur ordinale (entier) de "arg" (scalaire)
dans le type.
ROUND(nombre);
Retourne la valeur arrondie (entier) de "nombre" (réel) à
l'entier le plus proche.
TRUNC(nombre);
Retourne la partie entière (entier) de "nombre" (réel).
Exemple :
ORD(mi) =3
ROUND(4.789) =5
TRUNC(6.895) =6
Un changement de type peut également être obtenu en
utilisant l'identificateur de type comme une fonction.
Exemple
TYPE notes = (dau,re,mi,fa,sol,la,si);
notes(3) = mi
INTEGER(fa) =4
CHAR(65) = 'A'
INTEGER('6') =54

42
Fonctions et procédures diverses
Fonctions :
Hl(mot);
Retourne l'octet (BYTE) de poids fort de "mot" (INTE­
GER ou WORD).
Exemple
HI($1EF3) = $1E(*entier*)
LO(mot);
Retourne l'octet (BYTE) de poids faible de "mot"
(INTEGER ou WORD).
SWAP(mot);
Retourne un entier qui contient les octets de poids fort
et faible de "mot" (entier) permutés.
UPC ASE(caractère) :
Retourne la majuscule (CHAR) équivalente à la minus­
cule "caractère" (CHAR).
Exemple
UPCASE('r') = R
ODD(nombre);
retourne TRUE si "nombre" (entier) est pair, FALSE
dans le cas contraire.
Exemple
ODD(26) = TRUE
RANDOM;
Retourne un nombre aléatoire x (réel), avec O < x < 1.
RANDOM(nombre);
Retourne un nombre aléatoire x (entier) avec
O < x < "nombre" (entier).
Procédure :
RANDOMIZE;
Initialise le générateur de nombres aléatoires avec un
nombre aléatoire.

43
9. Types structurés

Chaînes : STRING ,
çj- 3= cka.1.
STRING[longueur];
A utiliser dans une déclaration de type ou de variable,
"longueur" est une constante entière appartenant à l'in­
tervalle 1..255 qui spécifie la longueur de la chaîne.
Exemple
TYPE chaîne = STRING[15J;
VAR chaine2 STRING[20J;
Une chaîne est une suite de caractères compris entre
deux apostrophes. Pour placer une apostrophe dans une
chaîne, il faut la doubler.
Opérateurs

Opérateurs Opération Types opérandes Type résultat

affectation STRING CHAR STRING

+ concaténation STRING CHAR STRING
relationnels comparaison STRING BOOLEAN

Deux chaînes sont égales si leur longueur et leur conte­

nu sont identiques.
Les caractères d'une chaîne peuvent être atteints indivi­
duellement par indexation.
Exemple
chaîne := 'bonjour';
ch:= chaine[3J;
(*ch de type CHAR reçoit 'n'*)
Les types chaînes sont compatibles entre eux. On peut
affecter une chaîne à une autre chaîne de longueur infé­
rieure (elle sera tronquée à la longueur de la nouvelle

44
chaîne). Une chaîne peut recevoir un caractère mais la
réciproque est fausse si la chaîne n’est pas indexée.
Exemple
VAR nom,prénom :STRING[151;
ident :STRING30;
BEGIN
nom := 'Victor';
prénom := 'Hugo';
ident := nom + prénom
END.
Représentation interne
Les chaînes occupent en octets le nombre total de carac­
tères que peut contenir la chaîne + 1. Le premier octet
contient la longueur effective de la chaîne.
Procédures
DELETE(chaine,n,nombre);
Supprime dans "chaine" (variable ou chaîne), "nombre"
(entier) de caractères à partir du "n"ième caractère
(entier).
INSERT(chaine 1 ,chaine2 ,n) ;
Insère "charnel" (expression chaîne) dans "chaine2"
(variable ou chaîne) à partir du "n"ième caractère
(entier).
Exemple
chaine ^'informatique';
DELETE(chaine,3,4) = 'inatique'
INSERT('form',chaine, 3) = 'informatique'
STR(valeur,chaine);
Convertit "valeur" (entier) en une chaîne affectée à la
variable "chaine"
VA L(chaine,valeur,code);
Convertit "chaine" (variable ou chaîne) en une valeur
numérique (entier ou réel), affectée à "valeur" "code"
contient 0 si aucune erreur n'est détectée, sinon "code"
contient la position du premier caractère en erreur.

45
Fonctions

COPY(chaine,n,nombre);
Retourne la sous-chaîne de "nombre" de caractères de
"chaine" commençant au "n"ième caractère.("n" et
"nombre" doivent être des expressions entières).
Exemple
chaine := 'bonjour';
COPY(chaine,3,2) = ’nj'

CONCAT(chainel ,chaine2,...);
Retourne chaine 1 + chaine2 +...
LENGTH(chaine);
Retourne la longueur de "chaine".
POS(chaine 1 ,chaine2);
Retourne la position du premier caractère de "chaine2"
tel qu'une sous-chaîne de "chaine2" soit identique à
"chainel"
Exemple
POS('ct','Victor') = 3

Tableaux : ARRAY... OF
Monodimensionnés

ARRAY[type_index] OF type_composants;
A utiliser dans une déclaration de type ou de variable.
"type_index" doit être une constante scalaire, il détermi­
ne la dimension du tableau. "type_composants" peut être
de tout type scalaire, réel, structuré (chaîne, ensemble,
enregistrement, tableau).
Exemple
CONST n = 200;
TYPE notes = (dau,re,mi,fa,sol);
VAR tab1 ARRAY[1 ..100] OF INTEGER;
(‘tableau d'entiers*)
VAR tab2 ARRAY[1 ..n] OF STRING[15];
(suite)

46
(‘tableau de chaînes de caractères*)
VAR tab3 • ARRAY[notes] OF REAL;
(‘tableau de réels indicé par notes*)

Multidîmensîonnés
ARRAY[type_indexl ,type_index2,...]
OF type_composants;
A utiliser dans une déclaration de type ou de variable.
Exemple
VAR matrice ARRAY [1..10,1..10] OF REAL,
On accède à un élément d'un tableau en faisant suivre
son identificateur de la liste d’index, séparés par des vir­
gules, entre crochets.
Exemple •
matrice[3,4] désigne un élément de matrice.
Représentation interne
Un tableau occupe la taille du type de ses composants,
multipliée par le nombre d'éléments. Un tableau de 10
réels (REAL) par exemple, occupe 60 octets.
La taille maximale d'un tableau est limitée à 64927
octets.
Opérateurs sur les tableaux
L'affectation est autorisée entre tableaux de type
identique déclarés dans un même type.
Exemple
TYPE mat = ARRAY [1 ..10,1 ..20] OF REAL,
VAR a,b mat;
BEGIN
a:= b(‘est correct*)
END.
VAR a ARRAY[1..10,1..20] OF REAL,
b ARRAY[1..10,1..20] OF REAL,
BEGIN
a:= b(*diagnostiquera une erreur*)
END.

47
Remarque :
Le mot clé PACKED est défini, mais il est sans effet en
Turbo4.
Exemple .
VAR PACKED ARRAY [1..100] OF REAL,
VAR ARRAY [1..100] OF REAL,
(‘sont identiques*)

Remarque :
Les tableaux de caractères sont semblables aux chaînes,
mais une chaîne a une longueur variable, un tableau de
caractères a une longueur fixe.
Une chaîne peut recevoir un tableau de caractères, mais
la réciproque est interdite.
Exemple
VAR tab ARRAY [1..10] OF CHAR;
chaine STRING[10);
BEGIN
chaine := tab;(*est correct*)
tab :=chaine(*diagnostiquera une erreur*)
END.

Enregistrements : RECORD... END;

RECORD
rubrique 1 : type_rubrique 1,
rubrique2:type_rubrique2;

END;
A utiliser dans une déclaration de type ou de variable.
Les rubriques peuvent être de tout type, excepté le type
fichier (type enregistrement inclus).
Exemple
TYPE individu = RECORD
nom STRING[201;
âge INTEGER
END;

48
On accède à la rubrique d'un enregistrement en indi­
quant le nom de la variable déclarée de type RECORD
suivie d'un point et du nom de la rubrique.
Exemple
VAR personne individu,
(‘type individu défini ci-dessus*)
BEGIN
[Link] := 'Dupont'
END.
L'affectation entre variables de type RECORD identique
(Id tableaux) est autorisée.
L'instruction WITH enregistrement DO
Elle permet d'accéder directement à une rubrique sans
avoir à mentionner le nom de la variable enregistrement.
Exemple
WITH personne DO
BEGIN
nom:= 'Dupont';
âge := 25
END;
Dans le cas d'enregistrement d'enregistrements, on peut
imbriquer des instructions WITH jusqu'à 9 niveaux.
Les entrées sorties avec les variables
de type RECORD
Sur les organes logiques (clavier, écran, imprimante) on
ne référencie pas la variable enregistrement mais chacu­
ne de ses rubriques séparément. Alors que sur les fichiers
à accès direct, c'est la variable enregistrement qui est
référenciée et non les rubriques qui la composent.
Exemple
Avec le type "individu" défini ci-dessus, on obtiendra
VAR personne individu,
fichier FILE OF individu;
BEGIN
READ([Link]); (suite)

49
(‘saisi de la rubrique "nom" au clavier*)
READ([Link]);
(‘saisi de la rubrique "âge" au clavier*)
WRITE(fichier,personne)
(‘écriture de l'enregistrement personne dans
"fichier” *)
END.

Les enregistrements avec variantes

RECORD
CASE types_etiquettes OF
étiquette 1 (rubrique 11 :type_rubrique 11,
rubriquel2: type_rubriquel2,..);
etiquette2 (rubrique21 :type_rubrique21,
rubrique22: type_rubrique22,..);

END;
A utiliser dans une déclaration de type.
Si la liste des rubriques est vide pour un cas, une paire
de parenthèses vide est obligatoire.
Exemple
TYPE date = RECORD
jour 1..31,
mois 1..12;
annee INTEGER
END;
nationalité = (françaisjiaiss, naturalise),
personne = RECORD
CASE nationalité OF
francaisjiaiss ( ),
naturalise (date_naturl:date)
END;

Représentation interne
Un enregistrement occupe la somme de la taille de ses
rubriques. Pour les champs variables, la taille est la plus
grande.

50
Ensembles : SET OF

SET OF type_base;
A utiliser dans une déclaration de type ou de variable.
"type_base" est de type intervalle ou énumération de
scalaires.
Exemples
TYPE lettres = SET OF ’a’.-'z';
notes = SET OF (dau,re,mi,fa,sol,la,si);
VAR entiers SETOF 1..255;

Le type ensemble évite des tests ou des boucles compli­

qués.
On construit un ensemble en énumérant ses éléments
entre crochets, séparés par des virgules. Le nombre
maximal d'éléments d'un ensemble est 256.
Exemples
lettre := [ ];
(‘une paire de crochets vide désigne l'ensemble
vide*)
note := [re,fa];(*note est de type notes*)
entiers := [1.35..55.89],

Opérateurs sur les ensembles

Opérateurs Opération Types opérandes Type résultat

affectation SET SET SET

+ union SET SET SET
• intersection SET SET SET
- différence SET SET SET
= égalité SET SET BOOLEAN
<> inégalité SET SET BOOLEAN
< et > inclusion SET SET BOOLEAN
IN appartenance scalaire SET BOOLEAN

Exemples
'a'IN ['a','b'] =TRUE
[1,2,3] *[1,2] =[1,2]

51
Représentation interne
Un ensemble est un tableau de bits, chaque bit indique si
l'élément est dans l'ensemble ou non , il occupe donc au
maximum 32 octets.
La compression permet d'éviter d'employer 32 octets,
quand cela n'est pas nécessaire.

10. Fichiers
Pascal possède trois structures de fichiers les fichiers à
"accès direct" de type FILE OF, les fichiers à "accès
séquentiel" de type TEXT, les fichiers dits "sans type"
de type FILE, compatibles avec les deux types précé­
dents. Les enregistrements d'un fichier sont le plus sou­
vent de type RECORD mais peuvent être de tout type
excepté de type FILE.
Les fichiers FILE OF sont constitués d'enregistrements
de même type, alors que les fichiers TEXT admettent
des enregistrements de type différent.

Déclarations de fichiers
FILE OF type_enregistrements;
TEXT;
FILE;
A utiliser dans une déclaration de type ou de variable.

TYPE fiches = RECORD

nom STRING[2O];
âge INTEGER
END;
VAR fichierl FILE OF CHAR;
fichier2 FILE OF fiches; (suite)

52
 fichier3 TEXT;
fichier4. FILE,

Fonctions et procédures sur les fichiers :

FILE OF et TEXT
ASSIGN (fichier, ficdisq);
Procédure qui associe le fichier du disque à la variable
fichier du programme, "fichier" est une variable FILE
OF, TEXT ou FILE, "ficdisq" est une variable chaîne ou
une chaîne correspondant à un nom de fichier du DOS
(chemin, 8 caractères alphanumériques commençant par
une lettre, suivis éventuellement de l'extension de trois
caractères séparés par un point). ASSIGN est obligatoi­
re avant toute manipulation du fichier.
Exemple
ASSIGN (fichierl ,'B:[Link]);
chaîne := 'données';
ASSIGN (fichier2, chaîne);

REWRITE (fichier);
Procédure qui crée un nouveau fichier sur le disque.
Tout fichier préexistant avec le même nom est détruit.
ERASE (fichier);
Procédure qui détruit sur le disque le fichier désigné.
RENAME (fichier,chaîne);
Procédure qui renomme le fichier disque assigné à
"fichier" en "chaine" (variable chaîne ou chaîne).
CLOSE (fichier);
Procédure qui ferme le fichier désigné. Est obligatoire
après toute utilisation de fichier.
EOF (fichier);
Fonction booléenne qui retourne la valeur TRUE si la
fin du fichier est atteinte, FALSE dans le cas contraire.
Sur les organes logiques, EOF est TRUE si le caractère
courant est Ctrl-Z.

53
Sur les fichiers, EOF est TRUE si le caractère suivant
est Ctrl-Z ou s'il rencontre une fin physique de fichier.

Fonctions et procédures sur les fichiers :

FILE OF

RESET (fichier);
Procédure qui ouvre un fichier déjà existant et le prépare
pour une lecture ou une écriture. Le pointeur de fichier
est positionné sur le premier enregistrement.
READ et WRITE
(voir chapitre 6 • "READ et WRITE")
Ce sont les seules procédures autorisées pour lire et écri­
re dans un fichier de type FILE OF. Après ces instruc­
tions, le pointeur de fichier est incrémenté de 1 Pour un
accès direct à un élément du fichier, il convient avant
d'utiliser les instructions READ ou WRITE de placer le
pointeur du fichier sur l'élément voulu par l'utilisation de
la procédure SEEK.
SEEK (fichier,n);
Procédure qui déplace le pointeur du fichier spécifié sur
l'enregistrement de rang "n-, -0
SEEK(fichier,FILESIZE(fichier)) positionnera le poin­
teur à la fin du fichier spécifié.
FILEPOS (fichier);
Fonction entière retournant la position du pointeur du
fichier spécifié.
FILESIZE (fichier);
Fonction entière retournant le nombre d'enregistrements
du fichier spécifié.
Exemple de séquence d'instructions pour la gestion
d'un fichier FILE OF ■
(‘création d'un fichier*)
ASSIGN(fichier,'[Link]'),
REWRITE(fichier); (suite)

54
CLOSE(fichier);
(‘ouverture du fichier existant pour consultation,
ajout, modification*)
RESET(fichier);
(‘utilisation de SEEK, WRITE, READ‘)
CLOSE(fichier);

Fonctions et procédures sur les fichiers :

TEXT

RESET (fichier);
Procédure qui ouvre un fichier déjà existant et le prépare
pour une lecture séquentielle exclusivement. Le pointeur
est placé sur le premier élément du fichier spécifié.
READ, WRITE, READLN, WRITELN
Toutes les procédures de lecture/écriture sont autorisées
pour les fichiers TEXT.
APPEND (fichier);
Procédure qui ouvre un fichier déjà existant et le prépare
pour une écriture en fin de fichier.
EOLN (fichier);
Fonction qui retourne TRUE si une fin de ligne est
atteinte. Le composant de base d'un fichier TEXT est le
caractère, ces caractères sont placés dans des lignes dont
la fonction EOLN teste la fin.
Sur les organes logiques, EOLN est TRUE si le caractè­
re courant est Ctrl-Z ou un retour chariot.
Sur les fichiers, EOLN est TRUE si le caractère suivant
est Ctrl-Z ou un retour chariot ou si EOF est TRUE.
SEEKEOLN (fichier);
Similaire à EOLN mais ignore les espaces et les
marques de tabulation.
SEEKEOF (fichier);
Similaire à EOF mais ignore les marques de fin de ligne,
les espaces et les marques de tabulation.

55
SETTEXTBUF (fichier,buffer);
Procédure qui assigne une mémoire tampon ("buffer")
au fichier texte spécifié.
Par défaut, les transferts entre la mémoire centrale et le
disque se font par l'intermédiaire d'une mémoire tampon
de 128 octets. La procédure SETTEXTBUF permet de
définir un buffer plus grand, accélérant ainsi les trans­
ferts entre la mémoire et le disque.
SETTEXTBUF est à employer sur un fichier assigné
mais non ouvert.
Exemple
VAR fichier ’TEXT;
buffer .ARRAY [1 ..2048] OF CHAR;
BEGIN
ASSIGN(fichier, '[Link]');
SETTEXTBUF(fichier,buffer)
(*2048 octets de buffer*)
(‘suite du programme*)
END.

FLUSH (fichier);
Force l'écriture des données contenues dans la mémoire
tampon associée au fichier du disque. Après un appel à
cette procédure, le programme peut être interrompu sans
perte de données.

Exemple de séquence d'instructions pour gérer un

fichier TEXT
(‘création: séquence d'instructions identique
pour les fichiers TEXT et FILE OF*)
(‘ouverture du fichier déjà créé pour lecture
séquentielle*)
RESET(fichier);
(‘utilisation de READ, READLN*)
CLOSE(fichier),
(‘ouverture du fichier déjà créé pour ajout en fin
de fiChier‘)

56
APPEND(fichier);
(‘utilisation de WRITE, WRITELN*)
CLOSE(fichier);
Les organes logiques
Ils doivent être assignés à une variable TEXT.
Exemple :
VAR imprimante: TEXT;
BEGIN
ASSIGN(imprimante,'LPT 1 ');
WRITELN(imprimante,'ça marche');
CLOSE(imprimante)
END
L'unit PRINTER assigne l'imprimante à la variable LST

Fichiers sans type : FILE

Ils sont employés pour des opérations sur les fichiers
n'utilisant pas d'entrées sorties. Par exemple DELETE,
RENAME, CHAIN, EXECUTE. Toutes les fonctions et
procédures de manipulation des fichiers FILE OF sont
autorisées exceptées READ et WRITE, remplacées par
BLOCKREAD et BLOCKWRITE. SEEK déplace le
pointeur de fichier par enregistrement de 128 octets.
BLOCKREAD (fichier,variable,nombre,résultat);
BLOCKWRITE (fichier,variable,nombre,résultat);
Procédures de transfert à haute vitesse de "nombre" d'en­
registrements de 128 octets de "fichier" vers "variable" et
réciproquement, "résultat" est optionnel et donne le
nombre d'enregistrements effectivement transférés.
H faut vérifier que la longueur de "variable" permette le
transfert. Il est conseillé d'utiliser pour "variable" un
tableau d'octets.

Vérification des entrées!sorties

IORESULT;
Fonction qui retourne un entier (WORD) donnant l'état
de la dernière opération d'E/S "0" si aucune erreur

57
d'E/S n'a été détectée, un code d'erreur (1..99) corres­
pondant à une erreur du DOS.
La fonction IORESULT est très utile dans les situations
où un programme ne doit pas s'arrêter après une erreur
d'entrée/sortie.
Exemple
Le programme suivant teste si "ficdisq" existe sur le
disque.
VAR fichier- FILE,
BEGIN
ASSIGN(fichier,ficdisq);

RESET(fichier);
{$!+}
IF lORESULTo 0 THEN
WRITELN('fichier inconnu')
END.

Représentation interne des fichiers

Un fichier est représenté
- par un enregistrement FILEREC de 128 octets pour
les fichiers FILE et FILE OF.
- par un enregistrement TEXTREC de 128 octets et
d'un tampon de 128 octets par défaut pour les
fichiers de type TEXT (voir chapitre 17
"Constantes, types et variables").

Pointeurs
Turbo Pascal ne permet pas de donner de dimension
variable à un tableau. Cet inconvénient peut être
contourné en utilisant les variables pointées (dyna­
miques) qui sont créées quand le programme en a besoin
et éventuellement détruites quand elles deviennent
inutiles, libérant ainsi de l'espace mémoire.

58
Les variables pointées sont créées à l'aide d'un pointeur
dans une zone particulière de la mémoire appelée zone
dynamique ou tas. Elles sont empilées à partir de l'adres­
se la plus basse du tas.
Une variable pointeur ne contient pas la valeur d'une
variable mais son adresse en mémoire. On accède à une
variable pointée par un adressage indirect à l'aide de son
pointeur associé.
Turbo Pascal contrôle le tas en maintenant un pointeur
de tas HEAPPTR (voir chapitre 13 "Allocation de la
mémoire").

Déclaration d'un pointeur

Le type prédéfini POINTER
Permet de déclarer un pointeur. Les variables dyna­
miques créées seront sans type (voir GETMEM).
Le symbole A
Précédant un type, il permet de déclarer un pointeur. Les
variables dynamiques créées seront alors du type spéci­
fié après le symbole "A" Les variables pointées peuvent
être de tous types.

Procédures pour créer une variable dynamique

NEW (pointeur);
Affecte à "pointeur" la plus petite adresse disponible du
tas et crée une nouvelle variable pointée à cette adresse.
Variable pointeur et variable pointée sont désignées par
le même identificateur.
L'identificateur suivi de l'opérateur d'indirection "A"
désigne la variable pointée , en son absence il s'agit du
pointeur. Ainsi, si p est un pointeur, pA désigne la
variable pointée (contient une valeur), p désigne le poin­
teur (contient l'adresse de pA).
GETMEM (pointeur,n);
Il a le même effet que NEW mais "n" (WORD) spécifie
le nombre d'octets attribués à la variable dynamique.

59
"n" < 65521 octets.
Avec le type POINTER, il est impératif d'utiliser GET-
MEM puisque la variable dynamique créée n'a pas de
type, il appartient au programmeur de préciser la taille à
attribuer à la variable à créer (voir un exemple d'utilisa­
tion de GETMEM chapitre 18, paragraphe 4 PUTI-
MAGE).

Procédures pour récupérer de l'espace

dans le tas
DISPOSE (pointeur);
Détruit la variable pointée, l'espace libéré sera utilisé par
un nouvel appel à NEW
Les procédures MARK et RELEASE peuvent être utili­
sées pour récupérer de la mémoire dans le tas au lieu de
DISPOSE. Ne jamais utiliser DISPOSE et MARK/-
RELEASE en même temps.
MARK (pointeur);
Affecte au pointeur de tas l'adresse de "pointeur"
RELEASE (pointeur);
Supprime toutes les variables du tas à partir de l'adresse
contenue dans "pointeur"
FREEMEM (pointeur,n);
Récupère les "n" octets du tas réservé par GETMEM.
EFFET DE
EFFET DE MARK ET
DISPOSE RELEASE

RELEASE (P3)
Opérateurs autorisés entre pointeurs
de type identique

:=, =, <>
Tous les opérateurs arithmétiques sont interdits.
L’affectation entre pointeurs n'est autorisée que si les
variables pointeurs sont de type identique.

Exemple •
VAR p.q. POINTER,
BEGIN
p := q(*est correct*)
END.
VAR p: POINTER;
q: POINTER;
BEGIN
p:= q(*diagnostiquera une erreur*)
END.

Exemple de programme utilisant des pointeurs

PROGRAM permutte,
VARp, q, r ACHAR;
BEGIN
NEW(p);NEW(q),
PA = 'a';
qA = 'b‘;
r = q;
q = p;
p = r;(*permutation des pointeurs )
WRITELN('p
“..........A '-PA)>
WRITELN('qA •■qA)
END.

La constante prédéfinie NIL

Elle permet d'initialiser un pointeur.

Exemple .
p:= NIL;(*p ne pointe sur aucune variable*)

61
Connaître l'espace disponible du tas
MAXAVAIL ;
Fonction qui retourne le nombre d'octets du plus grand
espace disponible du tas.
MEMAVAIL ;
Fonction qui retourne le nombre d'octets disponibles
dans le tas.

Fonctions et opérateurs d’adresse

Les fonctions ADDR et PTR ainsi que l'opérateur @ per­
mettent d'affecter des valeurs spécifiques à des pointeurs.
ADDR (variable);
Retourne un pointeur contenant l'adresse de "variable"
L'opérateur d'adresse " a le même effet que la fonc­
tion ADDR
Exemple
VAR p POINTER;
PROCEDURE essai;
BEGINfessai*)

END;(*essai*)
BEGIN
p:= ADDR(essai);(*ou p:= @(essai);*)
(*p contiendra l'adresse de la procédure
"essai"*)
END.

PTR (segment,offset);
Retourne un pointeur contenant l'adresse spécifiée.
Exemple
p:= PTR(16297,0);
(Voir chapitre 13 "Variables absolues").

Structure de liste chaînée

Il est très facile de créer une file de variables pointées
mais il est beaucoup plus difficile de retrouver ces

62
variables auxquelles on ne peut accéder que par leur
adresse , les variables pointées n'ont pas de nom. Il faut
utiliser la technique de liste chaînée ou une gestion
directe de la mémoire (voir chapitre 13).
Les éléments de la liste sont de type RECORD, compo­
sés des rubriques de chaque élément et d'un pointeur (dit
pointeur d'enregistrement) qui pointera sur l'enregistre­
ment précédent.

élément Pointeur élément Pointeur élément

NIL
1 2 2 3 3

Exemple
(‘saisie puis affichage d'une liste de noms*)
PROGRAM pointeur;
TYPE
fiche= Aenregistr;
enregistr= RECORD
nom STRING[10J;
antecedant: fiche
(‘Pointeur sur l'enregistrement
précédent*)
END;
VAR personne- STRING[10];
p,q: fiche,
BEGIN(‘pointeur‘)
NEW(p);
[Link]:= NIL,
(‘Le premier p n'a pas d'antécédant*)
REPEAT
WRITELN('Nom suivant');
READLN (personne);
IF personneo " THEN
BEGIN
NEW(q),
(‘Création d'une nouvelle variable pointée q*)
(suite)

63
 [Link]:= personne;
[Link]:= p;
(‘Affectation au pointeur antécédant de la
variable q du pointeur p*)
p:= q
(‘p va pointer sur q‘)
END;
UNTIL personne =";
WHILE [Link]<> NIL DO
(‘Affiche la liste des noms dans l'ordre
inverse de la saisie*)
BEGIN
WRITELN([Link]);
(‘Affiche le nom suivant de la liste*)
p:= [Link]
(*p va pointer sur antécédant du dernier
enregistrement*)
END
END.(‘pointeur*)

12. Fonctions
et procédures

Fonction et procédure sont assez semblables et doivent

être définies dans le bloc de déclarations du programme
(sous-programme) appelant ou dans celui d'un niveau
supérieur (voir chapitre 3 "Identificateurs").
Une fonction, au contraire d'une procédure, restitue au
module appelant un résultat dont la valeur est de type
simple, définie dans l'entité de la fonction.

64
En-tête d'une fonction

FUNCTION nom_fonction
(paramétrai 1, parametrel2,.„. type_parametrel,
parametre21 ,parametre22.... type_parametre2;.„):
type_fonction;

En-tête d'une procédure

PROCEDURE nom procedure

(paramétré 11 .paramétré 12 typeparamétré 1,
parametre21 ,parametre22„... type_parametre2;...);

Exemples
FUNCTION calcul (x,y:INTEGER;a:CHAR):INTEGER;
PROCEDURE résultat (a:BYTE;x,y:REAL);

Appel de fonction ou procédure

Il se fait par le nom du sous-programme, suivi de la liste
entre parenthèses des paramètres séparés par des vir­
gules.
L'appel d'une fonction (contrairement à celui d'une pro­
cédure) doit faire partie d'une expression (affectation)
puisqu'une fonction reçoit une valeur.
Exemple
z :=calcul(u,v,'i');
(* fonction "calcul” défini ci-dessus, "u”, "v" et "z"
variables entières de la procédure appelante*)
résultat^ 23,d,32.3),
(* procedure "résultat" définie ci-dessus, "d"
variable réelle de la procédure appelante*)

Passage de paramètres
Les paramètres sont transmis du module appelant
(paramètres réels) au module appelé (paramètres for­
mels) dans l'ordre d'apparition de la liste.

65
Les types des paramètres réels et formels doivent corres­
pondre.
Passage par valeur
Les paramètres de la procédure appelante restent
inchangés
Passage par variable
C'est en fait l'adresse de chaque paramètre réel qui est
transmise au programme appelé les paramètres de la
procédure appelante auront la valeur obtenue dans le
programme appelé.
Les paramètres par variable doivent être précédés du
mot VAR dans l'en-tête de la procédure (fonction).
Exemple
PROCEDURE essai(VAR i,i:INTEGER);
On peut passer simultanément tes paramètres par valeur
et par variable.
Exemple
PROCEDURE calcul(VAR i,j:INTEGER;x:REAL),
Les paramètres peuvent être de type scalaire ou structu­
ré. Fonctions et procédures ne peuvent être passées en
tant que paramètres, avec la version 4. Cela devient pos­
sible avec les versions 5 (voir chapitre 19).
Les paramètres de type structuré (tableau, chaîne,
ensemble...) doivent être préalablement définis.
Exemple
TYPE chaîne = STRING[15];
PROCEDURE essai (nom:chaine);(*est correct*)
PROCEDURE essai (nom:STRING[15j);
(‘diagnostiquera une erreur*)
Lorsque l'on passe une structure, on a toujours intérêt à
utiliser un paramètre par variable seule l'adresse de la
structure est passée au programme appelé, alors que le
passage par valeur nécessite la recopie de toute la struc­
ture.
Les fichiers passés en paramètre doivent être obligatoi­
rement variables.
66
; Passer des paramètres à un programme
La liste des paramètres doit figurer dans l'en-tête du pro­
gramme, séparés par des virgules.
Les paramètres sont transmis par le menu Options/-
Parameters, séparés par des espaces ou des caractères de
tabulation.
PARAMCOUNT;
Fonction entière qui retourne le nombre de paramètres
passés au programme.
PARAMSTR (n);
Fonction chaîne qui retourne le "n"ième paramètre passé
au programme.
Exemple
command line Parameters: 12 25
PROGRAM essai(x,y);
BEGIN
WRITELN(PARAMCOUNT,' ’,PARAMSTR(2)),
(‘affichera 2 25‘)
END.

Exemples de fonctions et procédures

PROGRAM essai;
VAR a, b, c: INTEGER;
FUNCTION som(x,y INTEGER):INTEGER,
BEGIN(‘som‘)
som:= x + y;
END;(‘som‘)
PROCEDURE produite,y INTEGER;VAR z:
INTEGER);
BEGIN(‘produit‘)
z:= x ‘ y)
END;(‘produit‘)
BEGIN(‘essai‘)
a:= 5,
b:=8,
WRITELN(som(a,b));

67
 produira,b,c);
WRITELN(c)
END.(*essai*)

Procédure FORWARD
PROCEDURE nom_procedure(parame,... type_para-
me;...);
FORWARD;
Permet de séparer la déclaration d'une procédure (fonc­
tion) de son contenu. Le bloc se trouve plus loin et com­
mence par l'en-tête sans paramètre ni type.
Exemple ■
PROGRAM essai,
PROCEDURE un(x,y:INTEGER;):FORWARD;
PROCEDURE deux ,
BEGINfdeux*)

END;(*deux*)
PROCEDURE un,
BEGINfun*)

END;(*un‘)
BEGIN (‘essai*)
Ë[Link]*)

Sous-programmes externes
Turbo Pascal version 4.0 admet les routines externes en
assembleur.
La déclaration d'un sous-programme externe ne com­
prend que l'en-tête sans déclaration d'instructions, suivie
du mot EXTERNAL.
Pour que les routines en assembleur puissent être liées
au programme les utilisant, il faut inclure dans ce der­
nier la directive de compilation $L suivie du nom du
fichier DOS contenant les routines en assembleur.
Le programme en assembleur doit être préalablement
assemblé en un fichier .OBJ.

68
Les routines externes doivent préserver les registres BP,
CS, DS, et SS. Le code externe, doit être relogeable (pas
de référence au segment de données).
Les paramètres sont passés par la pile dans l'ordre dans
lequel ils sont déclarés, sous forme de pointeur de
4 octets pour les paramètres par variable (2 octets pour
le segment, les 2 suivants pour l’offset).
Par ailleurs, à l'entrée d'une routine externe, il faut sau­
vegarder le registre BP, copier le registre SP dans le
registre BP pour accéder aux paramètres, et enfin, réser­
ver de l'espace dans la pile pour l'utilisation locale.
Ce qui correspond aux instructions
PUSH BP
MOV BP,SP
SUB SP,espace

Avant le retour au programme appelant, il faut restaurer

les valeurs des registres BP et SP puis spécifier dans
l'instruction RET le nombre d'octets à supprimer. Ce qui
correspond aux instructions suivantes
MOV SP,BP
POP BP
RET nboctets

Exemple
PROGRAM principal;
{$L second}
VAR x,y JNTEGER;
FUNCTION
somme(x,y:INTEGER):INTEGER;EXTERNAL,
BEGIN(*principal*)
x:= 3; y:= 5;
WRITELN(somme(x,y))
END.(‘principal*)
Fonction en assembleur
Les variables sont transmises par la pile, la valeur est
retournée dans le registre AX.

69
Pour plus d'informations concernant les routines
externes, consulter le manuel du fabricant.

Fichiers inclus
On inclut un fichier en le déclarant par la directive de
compilation I suivie du nom du fichier
($1 fichier]
La directive doit être seule sur la ligne. L'extension .PAS
est prise par défaut. Si le fichier n'a pas d'extension, un
espace doit obligatoirement suivre son nom. On peut
ouvrir jusqu'à cinq fichiers inclus simultanément.
Un fichier inclus n'est pas un programme, mais une suite
de sous-programmes rassemblés dans un fichier du
disque et constituant une librairie. Les sous-programmes
du fichier inclus ne peuvent être compilés (pas de pro­
gramme principal). Toutes les fonctions et procédures
du fichier inclus peuvent être appelées depuis le pro­
gramme principal avec la syntaxe habituelle.
Exemple
PROGRAM principal;
{$1 [Link]]
(*Le fichier "[Link]” contient la fonction
"produit" *)
VAR x,y :INTEGER;
BEGIN(*principal‘)
x:= 3, y:= 7;
WRITELN(produit(x,y))
[Link]*)
FUNCTION produit(x,y:INTEGER):INTEGER,
BEGINfproduit*)
produite x * y
END;(*produit‘)

70
 13. Accéder
aux ressources
de la machine

Variables absolues
La mémoire est segmentée par blocs de 64 Ko. Une
adresse en mémoire est représentée sur deux grandeurs
de 2 octets chacune
- l'adresse de base (le segment) qui indique le début du
bloc.
- le déplacement (offset) à ajouter au segment (préala­
blement multiplié par 16 pour obtenir la position
réelle en mémoire qui correspond à une adresse sur
20 bits).
Turbo Pascal impose pour le code, les données et la
pile des segments fixes pour les adresses ce qui per­
met de ne manipuler des adresses que sur 2 octets
mais limite les zones correspondantes.
VAR variable :type ABSOLUTE segment: offset;
Cette déclaration spécifie l'adresse ("segment" et "off­
set") de "variable" Les adresses du segment et de l'off­
set doivent être données en hexadécimal. Une déclara­
tion de variable absolue ne peut spécifier qu'un seul
identificateur.
Exemple
VAR a INTEGER ABSOLUTE $0000:$00EE;
mot STRING[15] ABSOLUTE $0000:$00FF;
Il est possible également de déclarer une variable abso­
lue à l'adresse d'une autre variable.

71
Exemple
VAR chaîne-STRING[15];
long_chaine BYTE ABSOLUTE chaîne;
(*La longueur d'une chaîne est contenue dans le
premier octet de la chaîne*)

Fonctions et variables d’adresse absolue

Fonctions
Les fonctions OFS et SEG permettent de connaître
l'adresse (segment et offset) d'une variable.
OFS (variable);
retourne en entier l'offset du premier octet de la variable,
fonction ou procédure spécifiée.
SEG (variable);
retourne en entier le segment du premier octet de la
variable spécifiée. SEG ne peut s'appliquer à une fonc­
tion ou procédure, son segment étant le segment de code
(voir CSEG).
Exemple
segment := SEG (a),
offset :=OFS(a);
WRITELN ('segment de a = ', segment);
WRITELN ('offset de a = ', offset);
adresse := segment *16 + offset;
WRITELN ('adresse physique de a= ', adresse);

Remarque :
Si "p" est une variable pointeur, SEG (pA) et OFS (p7'1)
retourneront les segment et offset de la variable pointée
par "p", c'est-à-dire l'adresse contenue dans le pointeur
p>
alors que SEG (p) et OFS (p) retourneront les segment
et offset du pointeur lui-même.
CSEG;
Retourne en entier (WORD) le contenu du registre CS.

72
CS contient l'adresse segment du début du module com­
pilé. Chaque module (programme principal et units ) a
son propre segment de code.
DSEG;
Retourne en entier (WORD) le contenu du registre DS.
DS contient l'adresse segment du début des données du
programme.
SSEG;
Retourne en entier (WORD) le contenu du registre SS.
SS contient l'adresse segment du début de la pile. La
taille de la pile est fixée par $M.
SPTR;
Retourne en entier (WORD) le contenu du registre SP
SP contient l'adresse offset du dernier octet occupé de la
pile. SPTR se déplace vers le bas de la mémoire au
cours de l'exécution.
Voir également chapitre 11 : "Fonctions et opérateurs
d'adresse"
SIZEOF (variable);
Retourne le nombre d'octets occupés par l'argument.

Variables

HEAPORG
Variable pointeur contenant l'adresse de début du tas.
HEAPPTR
Variable pointeur contenant l'adresse du premier octet
libre du tas. Au cours de l'exécution d'un programme,
HEAPPTR ne peut dépasser la limite supérieure du tas
fixé dans $M.
FREEPTR
Variable pointeur contenant l'adresse la plus haute de la
mémoire libre. En effet, la partie haute de la mémoire
contient une pile chargée de gérer les espaces dispo­
nibles dans le tas.

73
OVERHEAPORG
Variable pointeur contenant l'adresse la plus haute de la
pile. Lorsque le tampon de mémoire overlay est vide,
HEAPORG et OVERHEAPORG pointent vers la même
adresse (voir chapitre 19).

Allocation de la mémoire

Adresses hautes

Pile de gestion du tas

FREEPTR 0<tas<640 Ko
Zone réservée pour le
tas, fixée par$M. Par
défaut 'tas = 640 Ko
HEAPPTR

Le tas
(variables dynamiques)
HEAPORG •*- OVERHEAPORG

La pile 1 Kspile<64 Ko
Zone réservée pour la
pile, fixée par $M. Par
défaut : pile = 16 Ko

Les données S64Ko

Plusieurs segments
Programmes .EXE de 64 Ko au plus
et .TPU chacun

TURBO PASCAL

Programmes résidents

MS-DOS

| j Zone occupée
Adresses basses

Zone vide

La zone de données contient les variables globales.

A l'appel d'une fonction ou d'une procédure, la pile

74
contient l'adresse de retour au programme appelant, les
paramètres passés par valeur, l'adresse des paramètres
passés par variable et les variables locales.
Le tas contient les variables dynamiques (pointées).
Au cours de l'exécution d'un programme
- DSEG, SSEG et HEAPORG sont fixes.
- CSEG contient successivement les adresses de début
du programme principal et des différents units.
- SPTR et FREEPTR se déplacent vers les adresses
décroissantes.
- HEAPPTR se déplace vers les adresses croissantes.

Gestion directe des pointeurs

(‘Saisie puis affichage d'une liste de noms*)
PROGRAM pointeur;
USES CRT;
TYPE fiche =Aenreg;
enreg = RECORD
nom STRING[10J;
END;
VAR q fiche;
ch CHAR;
n,i INTEGER;
p . STRING[10J;
BEGIN
i:=0;
CLRSCR;(*saisie des noms*)
REPEAT
WRITELNfNom suivant');
READLN(p);
IF p <> "
THEN
BEGIN
i:=i+1,
NEW(q),
(‘Création d'un nouvelle variable
pointée*)
[Link] := p;
END (suite)

75
 UNTIL p =
n:=i;
CLRSCR;(*affichage des noms*)
i:=n;
q := HEAPORG;
(*on pointe sur la première variable du
tas*)
WHILE i>0 DO
BEGIN
WRITELN([Link]);

q := PTR(SEG(qA),OFS(qA)+SIZEOF(qA))
(*q va contenir l'adresse de la variable
suivante du tas*)
END
END.

Insertion du code machine

INLINE (codel/code2/...);
Cette instruction permet l'insertion du code machine
dans un programme TURBO.
Exemple
Sauvegarde des registres AX, BX, CX, DX, SI,
DI, DS et ES avant une interruption
IN Ll N E($50/$53/$5 1 /$52/$56/$57/$ 1 E/$06) ;
(*PUSH AX
PUSH BX...*)

Procédures INLINE
Elles peuvent être utilisées pour de petites fonctions ou
procédures (moins de 10 octets). Elles sont analogues à
des macros instructions en assembleur, n'ont ni déclara­
tions locales, ni bloc BEGIN..END et ne sont consti­
tuées que d'une instruction IN.
Exemple
FUNCTION produit(x,y:INTEGER):LONGINT;
INLINE($58 (* POP DX *)
(suite)

76
 /$5A (‘ POP AX ‘)
/$F7/$EA), (‘ IMUL DX ‘)
(‘Retourne le produit de x par y*)

Accès direct à la mémoire

Il existe 3 tableaux prédéfinis MEM, MEMW et
MEML pour accéder directement à la mémoire.
L'index des tableaux MEM, MEMW et MEML est une
adresse composée du segment et de l’offset séparés par
deux points. Cet index est de type BYTE pour MEM,
WORD pour MEMW, LONGINT pour MEML.
Exemple
Var s, o WORD,
a INTEGER
BEGIN
s := SEG (a);
o := OFS (a),
MEMW [s :o] := 7;
( ‘affectation direct à "a"‘ )
WRITE (a)
END.

Accès direct aux ports d’entrées!sorties

du microprocesseur
Il se fait en utilisant les tableaux prédéfinis PORT et
PORTW L'accès aux ports de données est l'équivalent
des instructions en assembleur IN et OUT.
PORT [numéro] et PORTW [numéro]
"numéro" désigne le numéro de port, est de type BYTE
pour PORT et WORD pour PORTW Affecter une
valeur à un composant de PORT ou PORTW revient à
sortir cette valeur depuis le port spécifié. Affecter un
élément de port à une variable revient à lire cette valeur
sur le port spécifié.
Exemple
Le programme suivant émet un son.

77
USES CRT; (‘voir chap. 14 "Les units"*)
VAR a.i INTEGER;
BEGIN
a := 64;
FOR i := 1 TO 500 DO
BEGIN
a := a XOR 2;
(‘bascule de la valeur à émettre d'un état dans
un autre*)
PORT [$61] := a;
(* $61 est le port du haut parleur*)
DELAY(1),
END
END.
L'accès direct aux ports du microprocesseur est utilisé
pour les opérations de communication et de transmis­
sion. Pour connaître les affectations de ports, se référer
au manuel technique de l'ordinateur.

14. Gestion
des répertoires
Pour toutes les procédures se rapportant aux répertoires,
"chemin” est une expression ou une variable chaîne.
CHDIR (chemin);
Change le répertoire courant pour le répertoire spécifié
par "chemin"
Exemple
CHDIR ('B:/autre'),
MKDIR (chemin);
Crée un nouveau sous-répertoire dont le chemin est spé­
cifié par "chemin"

78
Exemple
chemin :='B:\TURBO\prog,
MKDIR(chemin);
RMDIR (chemin);
Efface le sous-répertoire dont le chemin est spécifié.
GETDIR (unité, chemin);
Affecte à "chemin" le répertoire courant de "unité"
"unité" = 0 spécifie le lecteur courant, "unité" = 1 le lec­
teur A,...

15. Fichiers unit

Définition
Un fichier unit est une bibliothèque de constantes,
variables, types, fonctions et procédures. Chaque unit
est un peu analogue à un programme Pascal et peut être
compilé séparément, mais non exécuté séparément.
On compile un fichier unit de la même manière qu'un
programme. Un unit compilé est sauvegardé par Turbo
avec l'extension TPU (de Turbo Pascal Unit).

Bibliothèque [Link]
Le fichier [Link] est une bibliothèque d'units et
contient les units standard SYSTEM, CRT, DOS,
PRINTER, GRAPH3 et TURB03. [Link] est
chargé en mémoire en même temps que [Link]
ou [Link].
SYSTEM
Contient les fonctions et procédures standard de Turbo
Pascal. Il n'est pas nécessaire de mentionner son utilisa­

79
tion cet unit est toujours lié au programme au moment
du link.
DOS
Permet d'invoquer le DOS sans avoir à gérer d'interrup­
tion.
CRT
Gère l'écran.
PRINTER
Facilite la gestion de l'imprimante.
TURBO3
N’est à utiliser qu'avec des programmes écrits avec la
version 3.0. Il permet une meilleure compatibilité entre
les deux versions.
GRAPH3
Contient les routines graphiques avancées et routines-
tortue de la version 3.0.

Unit [Link]
Contient un très grand nombre de routines graphiques et
reconnaît un grand nombre de cartes graphiques.

Structure d'un unit

UNIT nom_unit;
(*En tête de l'unit obligatoire*)
INTERFACE
(♦Déclarations globales à tous programmes
utilisant l'unit*)
IMPLEMENTATION
(♦Déclarations locales à l'unit (optionnelles)*)
(♦Blocs des fonctions et procédures*)
BEGIN (*optionnel*)
(♦Initialisation optionnel*)
END.

80
Partie INTERFACE
Cette partie contient les déclarations des constantes,
types, variables, fonctions et procédures communes à
l'unit et aux programmes l’utilisant.
Les blocs de déclarations de l'interface CONST, TYPE,
VAR, FUNCTION et PROCEDURE apparaissent dans
un ordre indifférent et peuvent être répétés plusieurs
fois. Les déclarations de fonctions et procédures ne
comprennent que l'en-tête, le bloc se trouve dans la par­
tie IMPLEMENTATION. Les routines FORWARD sont
interdites. Les routines INLINE figurent dans l'INTER-
FACE et non dans l'IMPLEMENTATION.
Remarque :
L'utilisateur pourra consulter les fichiers .DOC associés
aux units de Turbo pour connaître les parties INTERFA­
CE de chacun d'eux.
Partie IMPLEMENTATION
Cette partie comprend d'éventuelles déclarations locales
à l'unit ainsi que les blocs des routines déclarées dans
l'interface. Si l'unit utilise des routines externes en
assembleur, la directive {$L nom_fichier} doit figurer
dans l'unit avant le END final.
Partie INITIALISATION
Cette partie est optionnelle.
L'implémentation est comprise entre les mots IMPLE­
MENTATION et END. Un BEGIN avant END crée une
section de programme analogue à un programme princi­
pal qui sera toujours exécutée avant le programme prin­
cipal du programme appelant. Cette partie est utilisée
pour initialiser les variables de l'unit.

Utilisation d'units
Il suffit d'indiquer au début du programme les units utili­
sés par la clause
USES nom_unitl, nom_unit2,...,

81
L'utilisation d'autres units par un unit est autorisée. La
clause d'utilisation doit alors figurer juste après le mot
réservé INTERFACE.
Les noms de tous les units utilisés par un programme ou
un unit (directement ou par unit interposé) doivent figu­
rer dans la clause d'utilisation. Les noms des units utili­
sés par un autre unit doivent figurer avant le nom de
l’unit utilisateur dans la clause d’utilisation par un tiers
programme ou unit.
Exemple
L'utilisation de GRAPH3 nécessite la clause suivante
USES CRT,GRAPH3;(*GRAPH3 utilise CRT*)
Remarque :
Par défaut, Turbo Pascal admet que le nom du fichier
TPU est identique à l'identificateur de l’unit. Si tel n'est
pas le cas, il faut faire précéder l'identificateur de l'unit
(dans une clause d'utilisation) par la directive $U.
Exemple
USES {$U librairi} utilit;
Utilisation de l'unit "utilit" sauvé dans le fichier disque
"librairi"

Un unit, pour quoi faire ?

On crée un unit soit
- pour disposer d'une bibliothèque de types,
constantes, variables, fonctions ou procédures à utili­
ser dans divers programmes.
- pour créer des programmes utilisant plus de 64 Ko de
mémoire vive (limite de chaque code source). Il suf­
fit alors de découper le programme principal en une
suite d'units.
On ne peut pas créer de fichiers OVERLAY avec la ver­
sion 4.0. Dans la majeure partie des cas, la création
d'units sera suffisante. Cependant, la création d'units de
recouvrement devient possible avec les versions 5.

82
Exemples d'units et de leur utilisation
PROGRAM principal;
USES un,
BEGIN(*principal*)
a:= 3; b:= 5;
WRITELN(somme(a,b))
END.(‘principal*)
UNIT un;
INTERFACE
VAR a,b: INTEGER;
FUNCTION somme(x,y INTEGER)’ INTEGER;
(*a b et somme sont globales à tout
programme utilisant l'unit "un"*)
IMPLEMENTATION
FUNCTION somme;
BEGIN(*somme*)
somme:= x* y
END;(*somme*)
(*pas d'initialisation*)
END.(*un*)
PROGRAM principal;
USES {$U second} deux;
(*unit "deux" dans le fichier "second"*)
BEGIN(*principal*)
produira, b, c);
WRITELN(c)
END.(‘principal*)
UNIT deux;
INTERFACE
VAR a,b,c;INTEGER;
PROCEDURE produit(x,yJNTEGER, VAR z: INTEGER);
IMPLEMENTATION
PROCEDURE produit;
BEGIN(*produit*)
z:= x* y
END;(*produit*)
BEGIN(*initialisation*)
a:= 5; b:= 3
END.(*deux*)
83
PROGRAM principal;
UNIT trois;
BEGIN(*principal‘)
a:= 3, b:=5,
WRITELN(somme(a,b)),
WRITELN(produit(a,b))
END.(‘principal*)
UNIT trois,
INTERFACE
VAR a,b INTEGER,
FUNCTION produit(x,y: INTEGER): LONGINT;
INLINE($58/$5A/$F7/$EA); (‘Fonction INLINE*)
FUNCTION somme(x,y INTEGER):INTEGER;
IMPLEMENTATION
($L librairi}(*"librairi" contient la fonction
"somme" en assembleur*)
FUNCTION somme; EXTERNAL
(‘voir "somme" au chap. 12 "Sous-
programmes externes"*)
END.(‘trois*)

Utilitaire TPUMOVER
Permet de rassembler des units en bibliothèque.
L'utilisateur peut constituer sa propre librairie (fichiers
TPL) ou modifier à sa convenance la bibliothèque du
système [Link].
Modifications de [Link]
Syntaxe
TPUMOVER TURBO /paramètre nom_unit
Paramètres
/+ ajoute l'unit spécifié à [Link]
/- supprime l'unit spécifié de [Link]
I* copie l'unit spécifié appartenant à [Link]
dans un fichier nommé nom_unit.TPU
/? affiche une fenêtre d'aide
[Link] étant chargé en mémoire en même temps
que le compilateur, l'utilisateur pourra ajouter les units

84
qui lui sont toujours nécessaires, et éventuellement, sup­
primer les units systèmes qu'il n'utilise pas. Par exemple,
ajouter GRAPH et supprimer TURB03 et GRAPH3 et
s’il n'a pas de programmes écrits avec la version 3.0.

Créer sa propre librairie .TPL

Ajout dans une librairie .TPL

Syntaxe
TPUMOVER librairil librairi2
Où "librairil" est la librairie TPL dans laquelle vous
voulez faire des ajouts. "Iibrairi2" est un fichier TPL ou
TPU.

Un écran va être généré avec deux fenêtres, la fenêtre

active a un double cadre.
- si "librairil" n'existe pas encore, donner son nom.
- presser F6 pour changer de fenêtre active.
- marquer (touche +) les fichiers de "librairi2" à ajou­
ter à "librairil"
- presser Ins pour insérer les fichiers dans la nouvelle
librairie.
- après avoir changé de fenêtre active, presser F2 pour
sauver la nouvelle librairie.

Suppression dans une librairie .TPL

Syntaxe
TPUMOVER librairi
"librairi" est un fichier TPL
- marquer (touche +) les fichiers à supprimer.
- enfoncer la touche Del (pour détruire) au lieu de Ins.
- sauver la nouvelle librairie (F2).

Remarque :
On peut modifier [Link] avec la méthode ci-des­
sus.

85
16. L'unit CRT :
gestion de l'écran
et son,
L'unit PRINTER :
gestion
de l'imprimante
Constantes, types et variables (unit CRT)

Les constantes mode écran

BW40 = 0;(*40 x 25 N/B écran couleur*)
C40 = 1 ;(*40 x 25 couleur écran couleur*)
BW80 = 2;(*80 x 25 N/B écran couleur*)
C80 = 3;(*8O x 25 couleur écran couleur*)
MONO = 7;(*80 x 25 N/B écran monochrome*)
LAST = -1 ;(*réactive le dernier mode texte*)
Les constantes couleurs
BLACK = 0;
B LUE = 1,
GREEN = 2;
CYAN = 3;
RED = 4;
MAGENTA = 5;
BROWN = 6;
LIGHTGREY = 7;
DARKGREY = 8;
LIGHTBLUE = 9;
LIGHTGREEN =10;

86
LIGHTCYAN = 11,
LIGHTRED = 12;
LIGHTMAGENTA = 13;
YELLOW = 14;
WIIITE = 15;
BLINK = 128;
Ajouter BLINK à la couleur pour faire clignoter les
caractères.
Les variables

CHECKBREAK (Boolean)
Masque ou non l'interruption d'un programme par Ctrl-
Break. Si CHECKBREAK est FALSE, Ctrl-Break est
inactif. CHECKBREAK est TRUE par défaut.
CHECKEOF (Boolean)
Active ou désactive une fin de fichier par Ctrl-Z. Si
CHECKEOF est TRUE, Ctrl-Zgénère une fin de fichier.
CHECKEOF est FALSE par défaut.
CHECKSNOW (Boolean)
Contrôle de la neige sur un écran EGA. Si CHECKS­
NOW est FALSE, le contrôle de la neige est supprimé,
ce qui correspond à une vitesse accrue d'affichage des
caractères.
CHECKSNOW est active par défaut.
DIRECTVIDEO (Boolean)
Active ou désactive l'accès direct à la mémoire pour les
procédures d'affichage à l'écran. DIRECTVIDEO est
TRUE par défaut (accès direct). DIRECTVIDEO
FALSE ralentit les procédures d'affichage à l'écran.
TEXTATTR (Byte)
Les couleurs affectées au texte et au fond sont définies
habituellement par TEXTCOLOR et TEXTBACK-
GROUND, TEXTATTR permet de définir directement
les couleurs sélectionnées
- les quatre bits de bas poids définissent la couleur des
caractères.

87
- les trois bits suivants définissent la couleur du fond.
- le bit de plus fort poids sélectionne un caractère cli­
gnotant.
Exemple
TEXTATTR := $9E,
(‘caractères clignotants jaunes sur fond bleu*)

WINDMIN, WINDMAX (Word)

Après un appel à WINDOW, WINDMIN et WINDMAX
contiennent respectivement les coordonnées supérieure
gauche et inférieure droite de la fenêtre. Les coordon­
nées "x" et "y" correspondent au bas poids et au fort
poids de WINDMIN et WINDMAX.

Procédures et fonctions de gestion de l'écran

(unit CRT)
"couleur" est toujours une expression entière ou une
constante prédéfinie, les coordonnées sont des expres­
sions entières.
ASSIGNCRT (flchier_text);
Procédure analogue à ASSIGN pour associer les fichiers
standard INPUT et OUTPUT(implicites) au fichier texte
spécifié.
CLREOL;
Procédure qui efface tous les caractères depuis la posi­
tion du curseur jusqu'à la fin de la ligne sans déplacer le
curseur.
CLRSCR;
Procédure qui efface l'écran.
DELAY (temps);
Procédure qui crée une boucle d'attente.
"temps" est une expression entière. Avec une horloge à
4.77 Mhz, "temps"= 1000
correspond à peu près à une seconde.

88
DELLINE;
Procédure qui efface la ligne contenant le curseur.
GOTOXY (x,y);
Procédure qui place le curseur à la ligne "y" et à la
colonne "x" de la fenêtre active. Le coin supérieur
gauche est (1,1).
HIGHVIDEO;
Procédure qui affiche les caractères en haute intensité.
INSLINE;
Procédure qui insère une ligne vide à la position du cur­
seur.
KEYPRESSED;
Fonction qui retourne TRUE si une touche a été enfon­
cée, FALSE dans le contraire. Keypressed ne détecte pas
les touches spéciales (Ctrl, Ait, Shift etc.). Il n'y a pas
d'écho à l'écran de la touche enfoncée.
Cette fonction est différente de celle de la version 3. Le
code de la touche pressée est conservé jusqu'à son utili­
sation dans READKEY.
LOWVIDEO;
Procédure qui affiche les caractères en basse intensité.
NORMVIDEO;
Procédure qui affiche les caractères en intensité normale.
READKEY;
Fonction qui retourne sans écho le caractère tapé au cla­
vier.
Exemple :
ch:= READKEY;
(‘affecte le caractère tapé au clavier à ch*)
Remarque :
Les touches fonctions, les touches de déplacement du
curseur et les touches combinées avec Ctrl ou Ait génè­
rent des codes étendus Esc (code ASCII 27) suivi d'un
ou plusieurs caractères.

89
RESTORECRT;
Procédure qui restore le mode vidéo de démarrage.
TEXTBACKGROUND (couleur);
Procédure qui sélectionne un fond du ton de la couleur
spécifiée (intervalle 0..7).
TEXTCOLOR (couleur);
Procédure qui affiche les caractères du ton de la couleur
spécifiée (intervalle 0..31).
Exemple
TEXTCOLOR(4);
(* sélectionne des caractères rouges *)
TEXTCOLOR(GREEN + BLINK),
(* sélectionne des caractères clignotants verts*)
Avec un écran monochrome, on obtient suivant la carte
16 niveaux de gris différents (carte EGA CGA) ou les
attributs vidéo suivants (carte Hercules):
noir 0
souligné 1
blanc 7
surintensité 10
TEXTMODE (mode);
Procédure qui est utilisée pour revenir en mode texte
lorsqu'un mode graphique est actif, "mode" est une
constante entière ou mode écran prédéfinie.
WHEREX;
Fonction qui retourne la coordonnée x du curseur.
WHEREY;
Fonction qui retourne la coordonnée y du curseur.
WINDOW (xl,yl,x2,y2);
Procédure qui définit une fenêtre active (l'écran tout
entier par défaut)."xl","yl" sont les coordonnées du
coin supérieur gauche et "x2","y2" sont les coordonnées
du coin inférieur droit. Le coin supérieur gauche de la
fenêtre active correspond à (0,0).

90
Le son (unit CRT)
La procédure SOUND active le haut-parleur du PC.
SOUND (fréquence);
Emet la fréquence spécifiée jusqu'à ce que le haut-par­
leur soit arrêté par la procédure NOSOUND.
Exemple
(*émet un beep à 440 Hz pendant une seconde*)
BEGIN
SOUND (440);
DELAY (1000),
NOSOUND
END.

Gestion de l’imprimante (unit PRINTER)

L'unit PRINTER associe le fichier texte LST à LPT1
Exemple
USES PRINTER,
BEGIN
WRITELN(LST,'L'imprimante fonctionne')
END.

Activation Annulation
Mode Code ASCII Code ASCH
décimal décimal

compressé 15 18
double largeur 14 20
gras 27 27 70
souligné 27 45 1 27 45 0
notation exponentielle 27 83 0 27 84
notation indicielle 27 83 1 27 84

Attributs de l'imprimante

Exemple
WRITELN(LST,#27,#45,#1 ,'souligné',#27,#45, #0);
affichera souligné.

91
 17 Unit UQS™***^
Josh^Cok. fr) i twruoK C c,&. J z /?■< C<1C j
L ^^^7
L>r>'/C. oiAt^ ff}' eJuflu-c <iz X* *
F^ e*IxarflM JLt £.1^'

Constantes, types et variables

km.c\ih,€^tsl<i>tA^p -C <Lt< fp" ‘ ■6/
Les constantes
- Les constantes drapeaux utilisées pour tester le
registre d'état après une interruption
= $0001, 6^‘10' (* ~^7 ’)(F)
FCARRY
FPARITY = $0004; c& &'/e‘y'
FAUXILLARY _ 5JQQ1Q*
FZERO = $0040*
FSIGN = $0080;
FOVERFLOW = $0800;
- Les constantes modes fichiers, utilisées à l'ouver­
ture et à la fermeture des fichiers sur disque .
FMCLOSED = $D7B0;
FMINPUT = $D7B1,
FMOUTPUT = $D7B2;
FMINOUT = $D7B3;
- Les attributs fichiers, utilisés avec les procédures
attributs fichiers GETFATTR et SETFATTR
READONLY = $01,
HIDDEN = $02;
SYSFILE = $03;
VOLUMEID = $08;
DIRECTORY = $10;
ARCHIVE = $20;
ANYFILE = $3F;
Les types
Il existe divers types RECORD prédéfinis dans l’unit
DOS

92
F- fUL _ Ti-ft 1 (ta, ~ »/♦»>«./ z.,
•f- /' '■’
- FILEREC correspond au bloc d’interface des
fichiers FILE et FILE OF.
- TEXTREC correspond au bloc d’interface des
fichiers TEXT-U)
- REGISTERS utilisé pour les interruptions (INTR et
MSDOS).
TYPE
REGISTERS = RECORD
CASE INTEGER OF
O:(AX,BX,CX,DX,BP,SI,DI,DS,ES,
FLAGS: WORD);
1. (AL,AH,BL,BH,CL,CH,DL,DH. BYTE)
END;
- DATETIME utilisé par les procédures
PACKTIME, UNPACKTIME, GETFTIME,
SETFTIME.
TYPE
DATETIME = RECORD
YEAR,MONTH,DAY,HOUR,MIN,SEC: INTEGER
END;
- SEARCHREC utilisé par les procédures FIND-
FIRST et FINDNEXT qui recherchent l’occurence
d’un ou plusieurs fichiers sur le disque d’après leurs
attributs passés comme paramètres. (O
Les variables
DOSERROR (Integer)
Correspond aux codes erreurs du DOS
0 = Pas d’erreur
2 = Fichier inconnu
3 = Chemin inconnu
5 = Accès interdit
6 = Commande invalide
8 = Espace mémoire insuffisant
10 = Environnement invalide
11 = Format invalide
18 = Plus de fichiers
(1) Pour plus d'informations concernant l'unit DOS consulter
[Link] et le manuel du fabriquant

93
Interruptions logicielles
L'appel d'une interruption ne pose aucune difficulté mais
il est impératif de posséder un manuel décrivant pour
chaque interruption les différentes fonctions, les
registres à initialiser ainsi que la manière de lire les
résultats.
La séquence d'appel d'une interruption sera
- initialiser les registres concernés
- appeler l'interruption
- lire les bits des registres qui contiennent les résultats.
INTR (numéro, registr);
Procédure qui appelle une interruption, "registr" doit
être de type REGISTERS. Cette variable permet au pro­
gramme d'initialiser les registres du microprocesseur
avant l'interruption.
Principales interruptions
L'appel à MS-DOS = Interruption $21
Gestion vidéo = Interruption $10
Gestion du clavier = Interruption $16
Gestion Imprimante = Interruption $17
Gestion de la souris = Interruption $33
Exemple
Procédure pour déterminer l'état de l'imprimante.
AH contient l'état de l'imprimante.
Bit 0 L'imprimante ne répond pas.
Bit 4 Imprimante Off-line.
Bit 5 Pas de papier.
Bit 6 Imprimante occupée.
PROCEDURE imprimante;
USES DOS;
VAR registr- REGISTERS,
BEGIN
[Link]:= 2; (*initialisation$)
registr. DX:= 0;
INTR($17,registr); (suite)

94
 IF register AH AND $80= 0
THEN WRITE('imprimante occupée');
IF register AH AND $40= 0
THEN WRITEfpas de papier1)
END.

MSDOS (registr);
Cette procédure est tout à fait similaire à INTR, elle
évite simplement l'appel à l'interruption $21
Ainsi INTR($21,registr) est identique à MSDOS(registr).

Date et heure

GETDATE (annee,mois,jour,jour_semaine);
Procédure qui affecte la date courante aux variables spé­
cifiées. "jour_semaine" appartient à l'intervalle 0..6 (0
correspond à dimanche) (paramètres de type WORD).
GETTIME (heure,minute,seconde,centiem_sec);
procédure qui affecte l'heure courante aux variables spé­
cifiées (paramètres de type WORD).
SETDATE (annee,mois,jour,jour_semaine);
Procédure qui affecte la date spécifiée au système.
Intervalles autorisés année 1980..2099, mois 1..12, jour
0..3/,jour_semaine 0..6. (paramètres de type WORD).
SETTIME (heure,minute,seconde,centiem_sec);
Procédure qui affecte l'heure spécifiée au système.
Intervalles autorisés heure 0..23, min O..59, sec 0..59
centiem_sec 0..99.
(paramètres de type WORD).
GETFTIME (fichier,date_heure);
Procédure qui retourne dans "date-heure" de type
PACKTIME, la date et l'heure de la dernière écriture du
fichier sur le disque. Le fichier doit être ouvert.
SETFTIME (fichier,da±eur);
Procédure qui force la date et l'heure du fichier spécifié

95
aux date et heure contenues dans "datheur" de type
LONGINT.
PACKTIME (date_heure,datheur);
Procédure qui convertit "date_heure" de type DATETI-
ME en datheur (paramètre variable) de type LONGINT.
"datheur" est utilisé par les procédures GETFTIME,
SETFTIME et UNPACKTIME.
UNPACKTIME (datheur,date_heure);
Procédure qui convertit "datheur" de type LONGINT en
"date_heure" (paramètre variable) de type PACKTIME.

Etat du disque

DISKFREE (unité);
Fonction qui retourne le nombre d'octets libres du
disque spécifié. "unite"= 0 désigne l'unité active, 1 l'uni­
té A, 2 l'unité B...
DISKSIZE (unité);
Fonction qui retourne le nombre d'octets du disque spé­
cifié (paramètre analogue à DISKFREE).

Procédures fichiers

GETFATTR (fichier,attribut);
Retourne dans "attribut" (BYTE) l'attribut du fichier
spécifié (assigné mais non ouvert).
SETFATTR (fichier,attribut);
Affecte "attribut" (BYTE) à l'attribut du fichier spécifié
(assigné mais non ouvert).
Exemple
SETFATTR(fichier,ANYFILE);
\ Vol

96
 18. Unit graph « __ ;
uvüfiA/ ' 1 i.otf1
c

Utilisable avec les adapteurs graphiques

- CGA
- MGCA
- EGA
- VGA
- Hercules
- AT&T 400 line
- 3270 PC
L’interface de GRAPH contient un grand nombre de
constantes, types, variables et routines (plus de 50) pré­
définis.

Constantes et types

Les constantes
Les codes erreurs sont retournés par la fonction GRA-
PHRESULT
= 0 Pas d erreur
GRNOINITGRAPH = -1 Mode graphique non
installé
GRNOTDETECTED = -2 Adaptateur graphique
non détecté
GRFILENOTFOUND = -3 Fichier du détecteur gra­
phique introuvable
GRINVALIDDRIVER = -4 Fichier du détecteur gra­
phique incorrect
GRNOLOADMEN = -5 Mémoire insuffisante
pour charger les gra­
phiques
GRNOSCANMEM = -6 Plus de mémoire dispo­
nible pour le remplissage
GRNOFLOODMEM = -7 Idem (la différence
vient du mode d’entrée)

97
GRFONTNOTFOUND = -8 Fichier de police des
caractères introuvable
GRNOFONTMEN = -9 Mémoire insuffisante
pour charger les caractères
GRINVALIDMODE = -10 Mode et carte gra­
phiques incompatibles
GRERROR = -11 Erreur graphique
GRIOERROR = -12 Erreur graphique en
E/S
GRINVALIDFONT = -13 Fichier graphique
incorrect
GRINVALIDFONTNUM = -14 Numéro de police de
caractères incorrect
GRINVALIDDEVICENUM= -15 Numéro de gestionnai­
re d'écrans incorrect

Les cartes graphiques

Correspondent à la carte graphique de l'ordinateur
- DETECT = 0; est à utiliser pour que Turbo affecte
lui-même la constante correspondant à la carte gra­
phique dont est équipé l'ordinateur à l'initialisation
du mode graphique INITGRAPH.
- Toutes les autres constantes correspondent à un type
de carte graphique.
CGA = 1,
MCGA = 2;
EGA = 3;
EGA64 = 4;
EGAMONO = 5;
RESERVED = 6;
HERCMONO =7;
ATT400 = 8;
VGA = 9;
PC3270 = 10;

Les modes graphiques

Correspondent aux divers modes graphiques de chaque
carte.

98
 Cartes Constantes Mode Résolution Nombre Nombre de
Mode graphique de couleurs pages écran

CGA CGACO 320 x 200 4 1

CGAC1 1 320 x 200 4 1
CGAC2 2 320 x 200 4 1
CGAC3 3 320 x 200 4 1
CGAHi <£ 640 x 200 l2..., — — — J Aa. r
MCGA MCGACO 0 320 x 200 4 1
MCGAC1 1 320 x 200 4 1
MCGAC2 2 320 x 200 4 1
MCGAC3 3 320 x 200 4 1
MCGAMED 4 640 x 200 2 1
MCGAHI 5 640 x 480 2 1
EGA EGALO 0 640 x 200 16 4
EGAHI 1 640 x 350 16 2
EGA64LO 0 - 640 x 200 16 1
EGA64HI 1 640 x 350 4 1
EGAMONOHI 3 640 x 350 2 1 ou 2(1)
HERCULES HERCMONOHl 0 720 x 348 2 2
ATT ATT400C0 0 320 x 200 4 1
ATT400C1 1 320 x 200 4 1
ATT400C2 2 320 x 200 4 1
ATT400C3 3 320 x 200 4 1
ATT400MED 4 640 x 200 2 1
ATT400HI 5 640 x 400 2 1
VGA VGALO 0 640 x 200 16 4
VGAMED 1 640 x 350 16 2
VGAHI 2 640 x 480 16 1
3270PC PC3270HI 0 720 x 350 2 1

(1)1 pour une mémoire de 64 Ko, 2 pour une mémoire > 64 Ko.

Les couleurs
Elles sont identiques à celles de l'unit CRT (voir chapitre
16 "Constantes, types et variables") à l'exception de la
constante BLINK qui n'existe pas dans GRAPH.
Constantes textes (Set/getstyle)
Utilisées par SETTEXTSTYLE pour choisir la police et
la taille des caractères d'un texte, ainsi que la direction
de l'affichage.
Motifs lignes (Line style and widths)
Utilisées par SETLINESTYLE pour dessiner des figures
avec des lignes à motifs et définir leur largeur.

99
Motifs (Fill pattern)
Utilisées par SETFILLSTYLE pour remplir une figure
avec un motif donné.
Opérateurs BITBIT
Utilisés par PUTIMAGE, spécifient l'instruction en
assembleur pour recopier chaque octet.
Les types
Ils sont utilisés pour passer des paramètres de type pré­
défini à diverses routines et sont explicités avec les rou­
tines les employant.

Utiliser GRAPH

INITGRAPH (carte,mode,chemin);
Procédure qui initialise le mode graphique. Attribue une
partie du tas à la gestion de l'écran graphique.
"carte" correspond à une des 10 cartes graphiques recon­
nues par Turbo4.
L'utilisateur peut
- autodétecter la carte en affectant la constante
DETECT à "carte"
- affecter la constante carte dont il dispose à "carte"
Exemples
carte := DETECT;(*autodétection*)
carte := EGA;(*carte EGA*)
"mode" correspond à l'un des modes graphiques dispo­
nibles de la carte.
L'autodétection affecte un mode graphique par défaut,
"chemin" doit spécifier l'accès aux fichiers graphiques
.BGI correspondant aux cartes graphiques dont est équi­
pé l'ordinateur. Une chaîne vide spécifie le répertoire
courant.
CLOSEGRAPH;
Procédure qui clôt le mode graphique. Le dernier écran
avant l'appel au mode graphique est restauré. La partie

100
du tas alloué au mode graphique par INITGRAPH est
désallouée.
GRAPHRESULT;
Fonction qui retourne le code erreur de la dernière opé­
ration graphique.
GRAPHERRORMSG (erreur);
Fonction qui retourne le message d'erreur correspondant
au code d'erreur contenu dans "erreur"
Séquence d'instructions pour l'utilisation de
GRAPH
PROGRAM dessin;
USES GRAPH,
VAR carte, mode INTEGER;
BEGIN(‘dessin‘)
carte:= DETECT;
(‘autodétection de la carte graphique*)
INITGRAPH(carte, mode, ");
(‘initialise le mode graphique*)
IF GRAPHRESULT = 0 THEN
BEGIN
(‘routines graphiques*)
END
ELSE
WRITELN(GRAPHERRORMSG
(GRAPHRESULT))
(‘affichage du message d'erreur a l'initialisation
du mode graphique*)
END.(‘dessin*)

Routines de mise en route de GRAPH

DETECTGRAPH (carte,mode);
Procédure qui retourne la carte de l'ordinateur et le
mode actif. INITGRAPH appelle DETECTGRAPH.
GETGRAPHMODE;
Fonction qui retourne en entier le mode graphique cou­
rant.

101
RESTORECRT;
Procédure qui restaure le mode CRT tel qu'il existait au
moment du démarrage.
RESTORECRTMODE;
Procédure qui restaure le mode CRT tel qu'il existait au
moment de l'initialisation du mode graphique.
SETGRAPHMODE (mode);
Procédure qui permet de choisir un mode graphique,
"mode" doit correspondre à l'un des modes disponibles
de la carte. SETGRAPHMODE restaure toutes les
variables (curseur, couleur, etc.) dans leurs valeurs par
défaut.

Principales routines graphiques

Tous les paramètres utilisés dans les routines graphiques
sont des expressions entières, sauf spécification diffé­
rente.
Le coin supérieur gauche de l'écran a pour coordonnées
(0,0). Les coordonnées du coin inférieur droit sont don­
nées par le mode graphique sélecté.
Exemple
En mode CGAC2 (x2,y2) = (319,199)
Les angles sont donnés en degrés orientés dans le sens
trigonométrique.
Les lignes des figures composées uniquement de lignes
droites sont tracées avec le motif et la largeur définis
dans SETLINESTYLE.
Les figures dites "pleines" sont remplies avec le motif et
la couleur définis dans SETFILLSTYLE ou SETFILL-
PATTERN.
Les lignes (les figures pleines) sont tracées (remplies),
par défaut, sans motif et avec la couleur active.
ARC (x,y,anglel,angle2,rayon);
Procédure qui dessine un arc de cercle de centre (xl,yl),
entre "anglel" et "angle2" de rayon spécifié.

102
BAR (xl,yl,x2,y2);
Procédure qui dessine un rectangle plein, ([Link]) et
(x2,y2) correspondent aux coordonnées supérieur
gauche et inférieur droit du rectangle.
BAR3D (x 1 ,y 1 ,x2,y2,profondeur,sommet);
Procédure qui dessine un parallélépipède en trois dimen­
sions. "sommet" est Booléen, et si "sommet" est TRUE,
la face supérieure est dessinée. La face avant est pleine.
CIRCLE (x,y,rayon);
Procédure qui dessine un cercle de centre (x,y) et de
rayon spécifié.
CLEARDEVICE;
Procédure qui efface l'écran, toutes les variables gra­
phiques reprennent leurs valeurs par défaut.
CLEARVIEWPORT;
Procédure qui efface la partie de l'écran correspondant à
la fenêtre active.
DRAWPOLY(nombre,sommets);
Procédure qui dessine un polygone ayant "nombre" de
sommets, "sommets" (sans type) contient les coordon­
nées (x,y) de chacun d'entre eux. La figure doit être fer­
mée les coordonnées du premier et du dernier sommet
sont identiques.

Exemple
CONST penta . ARRAY [1 ..4,1.2] OF INTEGER
= ((50,100),(100,100),(150,150),(50,100)),
BEGIN
nb:= 4;
DRAWPOLY(nb,penta){affichera un triangle}
END.

ELLIPSE (x,y,angle 1 ,angle2,xrayon,yrayon);

Procédure qui dessine un arc de cercle elliptique de
centre (x,y), entre "angle 1" et "angle2", des rayons spé­
cifiés.

103
FILLPOLY(nombre, sommets);
Analogue à DRAWPOLY, mais le polygone est plein.
FLOODFILL (x,y,bordure);
Procédure qui remplit une figure contenant le point (x,y)
et entourée par la couleur de "bordure"
GETBKCOLOR;
Fonction qui retourne la couleur du fond.
GETCOLOR;
Fonction qui retourne la couleur graphique active.
GETIMAGE (xl,yI,x2,y2,pointeur);
Procédure qui sauve un rectangle de l'écran en zone
dynamique à l'adresse contenue dans le pointeur spéci­
fié.
GETIMAGE est à utiliser avec IMAGESIZE et GET-
MEM (voir l'exemple donné avec PUTIMAGE).
GETMAXX; et GETMAXY;
Fonctions qui retournent les résolutions en x et en y de
la carte et du mode graphique actif.
Exemple
En mode 320x200 GETMAXY retourne 199.
GETPIXEL (x,y);
Fonction qui retourne la couleur du point spécifié.
GETX; et GETY;
Fonctions qui retournent les coordonnées x et y du cur­
seur.
IMAGESIZE (xl,yl,x2,y2);
Fonction qui retourne le nombre d'octets nécessaires
pour sauver une zone rectangulaire.
LINE (xl,yl,x2,y2);
Procédure qui trace une ligne entre les points spécifiés.
LINEREL (dx,dy);
Procédure qui trace une ligne depuis la position du cur­
seur, avec les longueurs spécifiées.

104
Exemple
MOVETO(5,10);
LINEREL(15,20),
(‘tracera une ligne de (5,10) à (20,30)*)
LINETO (x,y);
Procédure qui trace une ligne depuis la position du cur­
seur jusqu'au point spécifié.
MOVEREL (dx,dy);
Procédure qui déplace le curseur des longueurs spéci­
fiées.
MOVETO (x,y);
Procédure qui déplace le curseur à la position spécifiée.
OUTTEXTXY (x,y,chaîne);
Procédure qui affiche la chaîne spécifiée à la position
spécifiée.
PIESLICE (x,y,anglel ,angle2,rayon);
Procédure qui dessine une part de camembert pleine,
avec les mêmes paramètres que ARC.
PUTIMAGE (x,y,pointeur*operateur);
Procédure qui dessine un rectangle de l'écran préalable­
ment sauvé par GETIMAGE. "x" et "y" spécifient le
coin supérieur gauche où sera affiché le rectangle, "ope­
rateur" (constante BITBIT) spécifie la manière dont la
nouvelle image se superposera sur l'écran.
Constantes BITBIT :
NORMALPUT = 0; { MOV {Copie exacte)
XORPUT =1 {XOR (OU exclusif avec l'écran)
ORPUT =2; {OR} {OU logique avec l'écran)
ANDPUT = 3; { AND {ET logique avec l'écran)
NOTPUT = 4; {NOT {Copie complémentaire)
Exemple
USES GRAPH,
VAR écran .mode,taille INTEGER;
point POINTER;
BEGIN (suite)

105
 ecran:= DETECT;
INITGRAPH(ecran,mode,"),
BAR(15,25,45,75);
taille:= IMAGESIZE(10,30,50,80);
GETMEM(point,taille);
GETIMAGE(10,30,50,80«pointA) ;
{sauver l'image}
PUTIMAGE(50,50,pointA,0)
{afficher l'image}
END.
PUTPIXEL (x,y,couleur);
Procédure qui affiche un point en (x,y) dans la couleur
spécifiée.
RECTANGLE (xl,yl,x2,y2);
Similaire à BAR mais le rectangle est vide.
SETACTIVEPAGE (page);
Procédure par laquelle la page écran spécifiée devient la
page active (les graphiques qui suivent SETACTIVEPA­
GE seront dirigés vers la page spécifiée).
Seules les cartes EGA VGA et Hercules supportent plu­
sieurs pages graphiques.
Voir l'exemple de SETVISUALPAGE.
SETBKCOLOR (couleur);
Procédure qui affecte la couleur spécifiée au fond, en
utilisant la palette.
SETCOLOR (couleur);
Procédure qui spécifie la couleur courante, en utilisant la
palette.
SETFILLPATTERN (motif,couleur);
Procédure qui permet à l'utilisateur de spécifier une
forme de son choix dans la couleur spécifiée qui sera
utilisée pour remplir une figure avec les procédures
FILLPOLY, FLOODPOLY, BAR, BAR3D et PIESI.I-
CE.
"motif' est de type FILLPATTERNTYPE

106
FILLPATTERNTYPE = ARRAY [1..8] OF BYTE;
Chaque octet correspond à une ligne horizontale et
chaque bit à un pixel dans la forme. Les bits à 1 dessi­
nent un point dans la couleur spécifiée.

Exemple •
CONST
bloc FILLPATTERNTYPE
= ($AA,$FF,$AA,$FF,$AA,$FF,$AA,$FF),
(‘correspondra à la forme
10 10 10 10 première ligne
11111111 deuxième ligne
Les six lignes suivantes correspondant à la répé­
tition des deux premières.*)
SETFILLPATTERN(bloc,1 );
BAR(10,10,100,100);

SETFILLSTYLE (motif,couleur);
Procédure qui spécifie la forme et la couleur qui seront
utilisées pour remplir une figure avec les procédures
FILLPOLY, FLOODPOLY, BAR, BAR3D et PIESLI-
CE.

Constantes motifs :
EMPTYFIL
SOLIDFILL 6ZZ)
LINEFILL [c* -
LTSLASHFILL
SLASHFILL
BKSLASHFILL *
LTBKSLASHFILL &<£J 7
HATCHFILL
XHATCHFILL
INTERLEAVEFILL
WIDEDOTFILL
CLOSEDOTFILL K
USERFILL - 12;(motif utilisateur défini
dans SETFILLPATTERN}

107
Exemple
La séquence suivante affichera les motifs prédéfinis
FOR i :=0TO11 DO
BEGIN
SETFILLSTYLE(i.l),
BAR(10,10,30,30);
ch:= READKEY(*ch de type CHAR*)
END;
SETLINESTYLE (motif-ligne,motif_util,largeur);
Procédure qui spécifie le motif et la largeur des lignes,
"motifjigne" est une des constantes prédéfinies (Line
style), "motif_util" est égal à 0 sauf si "motifjigne" =
USERBITLN = 4, auquel cas "motif_util" contiendra le
motif "largeur est une constante largeur"
Constantes motifjigne (Line style)
SOLIDLN = 0;
DOTTEDLN = 1,
CENTERLN = 2;
DASHEDLN = 3;
USERBITLN = 4;{motif défini par l'utilisateur}
Constantes largeur :
NORMWIDTH = 1,
THICKWIDTH = 3;
Exemples
La séquence suivante affichera les motifs lignes prédéfi­
nis en trait fin
FOR i :=0 TO 3 DO
BEGIN
SETLINESTYLE(i,0,1);
LINE(10,10,100,100);
ch:= READKEY(*ch de type CHAR*)
END,
(‘motif utilisateur*)
SETLINESTYLE(USERBITLN,$AB,
THICKWIDTH),
LINE(10,10,100,100),

108
-Sttt, y/’) - ^/-“^
SETTEXTSTYLE (lettres,direction,taille); h^,'/"'2
Procédure de mise en page, "lettres" spécifie la police de
caractères à utiliser, "direction" le sens de l’affichage,
"taille" (1 ..10) la dimension des caractères.
Les différentes polices de caractères sont contenues dans
les fichiers .CHR.
"taille" = 1 caractères 8x8
"taille" = 2 caractères 16x16 ..
Constantes police de caractères :
DEFAULTFONT
TRIPLEXFONT
SMALLFONT
SANSSERIFFONT
GOTHICFONT
Constantes direction :
HORIZDIR = 0 , { gauche à droite}
VERTDIR = 1 ; { haut vers bas)
Exemple
Affichage des diverses polices de caractères •
FOR i := 0 TO 4 DO
BEGIN
SETEXTSTYLE(i,0,1),
OUTTEXTXY(0,0, Turbo’)
END,
Affichage dans toutes les dimensions
FOR i := 1 TO 10 DO
BEGIN
SETEXTESTYLE(0,0,i);
OUTTEXTXY(0,0,‘Turbo’)
END;
SETVIEWPORT (xl,yl,x2,y2,clip);
Procédure qui spécifie une fenêtre active, (xl,yl) et
(x2,y2) désignent les coins supérieur gauche et inférieur
droit de la fenêtre, "clip" est une variable Booléenne. Si
"clip" est TRUE, tous les dessins seront tronqués aux
limites de la fenêtre active. . {■ J- /,
SETVISUALPAGE (page);
Procédure qui affiche la page écran spécifiée. Ceci est
très utile pour obtenir un effet de dessin animé (voir
SETACTIVEPAGE).

Exemple
USES [Link],
VAR écran,mode INTEGER;
ch:= CHAR;
BEGIN
écran := DETECT;
INITGRAPH(ecran,mode,44);
SETACTIVEPAGE(O),
RECTANGLE(5,10,25,40);
SETACTIVEPAGE(I),
CIRCLE(100,100,50);
SETVISUALPAGE(O);(*affiche page(O)*)
ch:= READKEY;
SETVISUALPAGE(1 );(*affiche page(1 )*)
ch:= READKEY;
CLOSEGRAPH
END.

TEXTHEIGHT(chaine); et TEXTWIDTH(chaine);
Fonctions qui retournent les hauteur et largeur en pixels
de la chaîne spécifiée et préalablement affichée par
OUTTEXTXY.

Pour plus d'informations concernant 1'wm7 GRAPH . l'in­

terface, les procédures palette et les procédures retour­
nant les divers paramètres utilisés dans SETFILLPAT-
TERN, SETLINESTYLE, SETFILLSTYLE et SET-
TEXTSTYLE, consulter [Link] et le manuel du
fabricant.

110
 19. Versions 5.0
et 5.5
La version 5.0 apporte des modifications mineures par
rapport à la version 4.0. La version 5.5 reprend intégra­
lement les modifications de la version 5.0 mais introduit
une innovation majeure avec la Programmation Orientée
Objet présentée au chapitre 20.
De nouvelles procédures graphiques et fonctions systè­
me ont été introduites, elles ne sont pas décrites dans ce
manuel, vous en obtiendrez la liste en consultant les
fichiers documentation correspondants.

Quelles modifications apportées

aux programmes de la version 4.0 ?
Des directives de compilation ayant été supprimées ou
modifiées dans les versions 5, il convient d'actualiser les
directives des programmes. Par ailleurs, il est nécessaire
de recompiler tous les units. C'est tout !

Contenu des disquettes Turbo Pascal 5.5

Disquette 1
Installation et compilateur. Les fichiers des disquettes 2,
3 et 4 sont donnés sous forme compactée (*.ARC).
Disquette 2
Aides et [Link] (logiciel d'auto-apprentissage de
l'EDI (environnement intégré de Turbo Pascal)).
Disquette 3
Exemples de programmes orientés objets et graphiques
ainsi que des fichiers .DOC.
Disquette 4
Utilitaires.

111
Mise en oeuvre du logiciel
Que vous travailliez avec un disque dur (ce qui semble à
peu près indispensable avec un logiciel de cette qualité)
ou avec deux lecteurs de disquettes, il vous faudra ins­
taller le logiciel •
- Placez la disquette 1 en A
- Tapez A. |-<-l |
- Tapez INSTALL El
Suivez les instructions données à l'écran. Le programme
INSTALL se charge du décompactage des fichiers
archives. Profitez des possibilités du programme INS­
TALL pour bien organiser l’installation du logiciel sur
disque dur en créant les sous-répertoires adéquats.
Attention de bien mentionner dans vos applications ulté­
rieures le chemin des fichiers BGI.

Environnement intégré
La barre des menus affiche
File Edit Run Compile Options Debug Break/watch
Les deux nouvelles options (Debug et Break/watch) cor­
respondent au débogueur intégré dont le maniement est
explicité au prochain paragraphe.
L'écran est partagé en deux fenêtres l'éditeur et Watch
(fenêtre de suivi des variables).
Pour afficher la fenêtre Output (entrées/sorties du pro­
gramme) au lieu de la fenêtre Watch et réciproquement
- Enfoncer F6 pour activer Watch ou Output
- Enfoncer Ait Fl
Pour basculer de l'EDI à l'écran d'exécution du program­
me
- Enfoncer Ait F5

112
Débogueur intégré
Un débogueur est un outil d'aide à la mise au point des
programmes. Tous les programmeurs savent bien qu'une
fois le programme syntaxiquement correct, il est rare
que l'on obtienne dès le premier passage les résultats
escomptés. Qui n'a alors parsemé son programme
d'ordres WRITE pour suivre l'évolution des variables.
Ce travail fastidieux, le débogueur le fera désormais
pour nous.
Pour utiliser le débogueur intégré, commencer par acti­
ver les deux commandes
- Options/Compiler/Debug Information
ou utiliser {$D+}
- Options/Compiler/Local Symbols
ou utiliser ($L+)

Les divers modes d'exécution

La commande Run génère 5 modes d'exécution
Run ou Ctrl F9
Compilation suivie d'exécution
Program Reset ou Ctrl F9
Permet de reprendre le débogage au début du program­
me (les variables ne sont pas réinitialisées)
Go to Cursor ou F4
Exécution du programme jusqu'à la position du curseur.
Le curseur fonctionne comme un point d'arrêt. Attention,
la ligne choisie doit correspondre à un code exécutable.
Trace into ou F7
Exécution en pas à pas
Step Over ou F8
Exécution en pas à pas dans la routine active, les procé­
dures étant exécutées d'une traite, le débogueur s'arrêtant
sur l'instruction qui suit l'appel.

113
Poser des point d'arrêt dans le programme
- Placer le curseur sur la ligne de programme où vous
désirez un arrêt.
- Enfoncer alors Ctrl F8 ou sélectionner Debug/Toggle
Breakpoint.
Ctrl F8 fonctionnant comme un inverseur, procéder de la
même manière pour supprimer un point d'arrêt.
Debug/Clear ail breakpoints supprime tous les points
d'arrêt.
Le débogueur est d'une remarquable souplesse d'utilisa­
tion, après chaque arrêt, vous poursuivez l'exécution
dans le mode que vous désirez. Vous pourrez, par
exemple, suivre pas à pas le déroulement d'une procédu­
re sans pour autant suivre en pas à pas la totalité du pro­
gramme, ce qui est généralement fastidieux et inutile.
Suivi des variables, des fonctions et des procédures
Placer des points d'arrêts n'est utile que s'il est possible
de suivre l'évolution des variables, pour cela
- Enfoncer Ait F6 pour activer la fenêtre Watch
- Enfoncer Ins (une fenêtre de saisie apparaît)
- Taper le nom de la variable à suivre
- Enfoncer CT (le nom de la variable apparaît dans
Watch)
Pour supprimer une variable dans Watch .
- Enfoncer Ait F6 pour activer la fenêtre Watch
- Placer le curseur sur la ligne de la variable à détruire
- Enfoncer Del
Remarque :
Les quatre premières commandes de Break/watch per­
mettent d'obtenir des effets similaires, et en outre de
modifier la valeur d'une variable en cours d'exécution.
On peut faire afficher dans Watch tous les types de
variables
- Les variables structurées apparaîtront entre paren-

114
 thèses avec la même syntaxe que pour les constantes.
- Les pointeurs seront affichés sous la forme segment
offset.
- Le suivi d'un fichier sera affiché sous sa forme
OPEN, CLOSE, INPUT etc.
- Les fonctions et les procédures seront affichées par
le pointeur de leur adresse.
Affichage de la liste des procédures
et fonctions appelées
Enfoncer Ctrl F3 ou appeler la commande Debug/Call
Stack sur un point d’arrêt provoquera l'affichage de la
pile avec la liste des procédures appelées et leurs para­
mètres. Vous pourrez même utiliser le curseur pour
remonter à un niveau appelant et après avoir enfoncé
vous serez positionné dans l'éditeur au début de la
procedure appelante.

Directives de compilation
$A+ spécifie l'alignement sur mot machine pair.
$E+ spécifie l'émulation du coprocesseur 80x87
$L n'existe plus. Utilisez Options/Linker/Link buffer.
$L+ spécifie la génération de symboles locaux de
débogage.
$0 spécifie le nom d'units overlay.
$0+ spécifie la mise en condition d'units overlay.
$T+ n'existe plus.
$U n'existe plus. Utilisez Options/Directories//Unit
directories.

Type sous-programme

TYPE
nom_procedure =
PROCEDURE(param 1 ,param2,.. : type_parm;..);
ou nom_fonction =
FUNCTION(paraml,param2,..:type_parm;..):type_fonction;

115
Du fait de la création du type sous-programme, il
devient possible de passer des procédures ou des fonc­
tions comme paramètres.
Attention, la directive $F doit être active pour pouvoir
passer des procédures ou fonctions comme paramètres.

Exemple
La procédure carré reçoit une fonction comme para­
mètre et affiche la valeur de son carré pour x = 2.
{$F+}
TYPE f = FUNCTION(x: INTEGER):REAL;
FUNCTION f1(x:INTEGER):REAL,
BEGIN
f1 := x*x +4*x;
END;
PROCEDURE carre(varf:f);
VAR x: INTEGER, z. REAL,
BEGIN
x:=2;
z:= varf(x)*varf(x),
WRITELN(z)
END;
BEGIN
carre(fl);
END.

Les overlays
Si les units permettent d'utiliser la totalité de la mémoire
disponible, les units de recouvrement (overlays) vont
permettre de gérer des programmes plus grands que la
mémoire, c'est-à-dire de dépasser les fatidiques 640 Ko,
que vous ayez ou non une mémoire étendue.
Le principe étant que seuls les units "overlays" actifs
résident en mémoire vive à un instant donné. L'unit
OVERLAY se charge de la gestion de la zone de recou­
vrement ou des échanges avec la mémoire étendue, s'il y
a lieu. La zone de mémoire de recouvrement se situe

116
entre la pile et le tas. Le tas doit bien entendu être vide
au moment de la réservation de la mémoire de recouvre­
ment.
Créer un programme utilisant des units
de recouvrement
- Créer un unit d'initialisation afin de charger en
mémoire le gestionnaire de recouvrement.
- Spécifier dans le programme principal
• la directive {$F+}
• l'unit OVERLAY avant tout unit recouvrable.
• la directive {$O nom_unit} (pour chaque unit de
recouvrement) après la clause USES.
- Spécifier dans chaque unit de recouvrement les deux
directives {$O+,F+}
- Spécifier dans les autres units utilisés par le pro­
gramme, la directive {$F+}
Procédures essentielles de Punit OVERLAY

OVERINIT(nomfic);
Initialise le gestionnaire de recouvrement et ouvre le
fichier .OVR spécifié. Un fichier .OVR est généré par
Turbo Pascal au moment de la compilation du program­
me principal utilisant des units de recouvrement.
OVERINITEMS;
Gère l'utilisation de la mémoire étendue.
OVERSETBUF(taille);
modifie la taille du tampon de recouvrement.
Exemple
{Unit d'initialisation}
UNIT initial;
INTERFACE
IMPLEMENTATION
USES OVERLAY;
BEGIN
OVRINIT('[Link]');{impératif}
(suite)

117
 OVRINITMS;{Si vous avez une mémoire
étendue}
OVERSETBUF(50000)
{conseillé pour améliorer les performances}
END.
PROGRAM principal;
{$F+}
USES OVERLAY,initial,unit1 ,unit2,unit3;
{$0 unitl}
{$0 unit3}
La variable OVERRESULT de l'unit OVERLAY ren­
seigne sur la manière dont s'est déroulée la procédure
OVERINIT une valeur différente de zéro correspond à
une erreur.

20. Programmation
Orientée Objets
Le principe fondamental de la POO (Programmation
Orientée Objets) est d'associer le code et les données
pour créer un ensemble (un objet) spécifié en Turbo
Pascal 5.5 par le nouveau type OBJECT La POO intro­
duit des concepts de programmation fondamentalement
différents de la programmation traditionnelle il faut
raisonner en termes de boîtes de savoir-faire et non plus
en termes de procédures recevant des paramètres.
Pourquoi écrire des programmes orientés objets ?
La POO est particulièrement adaptée aux programmes
de simulation si vous désirez réaliser un programme
simulant un robot industriel, il paraît logique de considé­

118
rer le robot comme un objet ayant ses caractéristiques
(ses champs de données) et ses comportements (ses pro­
cédures). Les graphiques sont des simulations, c'est
pourquoi la POO est souvent utilisée dans les environne­
ments graphiques.

Type OBJECT
Le type OBJECT est très proche du type RECORD mais
alors que le type RECORD ne comprend que des
champs de données, le type OBJECT comprend, en plus
des champs de données, des déclarations de méthodes.
Une méthode n'est rien d'autre qu'une fonction ou une
procédure associée à l'objet.
- On déclare une méthode par son en-tête dans le type
OBJET. Sa définition se trouve plus loin (comme
pour les procédures FORWARD), qualifiée avec le
nom du type.
- On ne peut définir de type OBJET que dans le bloc le
plus externe d'un programme ou d'un unit.
- Les champs de données doivent précéder les en-têtes
des méthodes dans la déclaration de type.

Les déclarations de variables objet

Elles se font de manière analogue à toutes les variables
du Pascal. Une variable objet peut être statique ou dyna­
mique.
L'accès aux champs de données ou de méthodes
Il se fait à la manière d'un RECORD en utilisant l'ins­
truction WITH ou en spécifiant le nom du type. Les
champs de données d'un objet sont totalement et conti­
nuellement accessibles aux méthodes de cet objet.
Exemple
TYPE chaîne = STRING[20J;
fiches = OBJECT
nom,prénom chaîne;
(suite)

119
 PROCEDURE debut(monnom,monprenom:chaine),
END;
VAR mafiche fiches;
{Méthode de l'objet fiches}
PROCEDURE [Link](monnom,
monprenorrrchaine);
BEGIN
nom := monnom;
prénom := monprenom;
END;
{Programme principal}
BEGIN
[Link]('DUPONT','Jules');
END.
Le programme principal peut s'écrire
BEGIN
WITH mafiche DO
debutfDUPONT'.'Jules)
END.
La première syntaxe est préférable à celle avec WITH.
Néanmoins, il est possible que dans le cas d'une métho­
de complexe, l'usage du WITH simplifie l'écriture de la
routine.

L’héritage
En programmation traditionnelle, il est fréquent de défi­
nir un premier type enregistrement que l'on utilisera
dans la définition d'un autre type enregistrement. En
POO, on utilisera la notion d'héritage un objet peut être
défini comme un descendant d'un autre objet.
Pour déclarer un objet descendant d'un autre, il suffit de
faire suivre le mot OBJECT, dans la définition du type
descendant, par le nom de type de son ascendant direct
entre parenthèses. Un objet peut avoir autant de descen­
dants que l'on veut, chaque descendant à son tour pourra
avoir ses propres descendants. On peut construire ainsi,
de proche en proche, des familles d'objets.
120
Chaque descendant hérite non seulement des champs de
données de ses ascendants mais également de ses méthodes.
Un objet ne peut avoir qu'un seul ascendant direct.
Exemple
TYPE chaîne = STRING[20J;
fiches = OBJECT
nom,prénom chaîne;
PROCEDURE debut(monnom, monprenom:
chaîne),
PROCEDURE affiche;
END;
fiches_date = OBJECT(fiches)
annee WORD;
PROCEDURE debut(monnom, monprenom:
chaine;monanneeWORD),
PROCEDURE écris;
END;
VAR mafiche_date fiches_date;
{Méthodes de l'objet fiches}
PROCEDURE [Link](monnom,
monprenom:chaine),
BEGIN
nom := monnom;
prénom := monprenom;
END;
PROCEDURE [Link];
BEGIN
WRITELN(nom),
WRITELN(prenom)
END;
{Méthodes de l'objet fiches_date}
PROCEDURE fiches_date.debut(monnom,
monprenom:chaine;monanneeWORD),
BEGIN
annee := monannee;
[Link](monnom,monprenom),
END, (suite)

121
PROCEDURE fiches_date.écris;
BEGIN
[Link];
WRITELN(annee)
END;
{Programme principal}
BEGIN
mafiche_date.debut('DUPONT','Jules',1960),
mafiche_date. écris;
END.
Un descendant hérite des méthodes de son ascendant. Il
peut également les rejeter II suffit pour cela de créer
une nouvelle méthode locale au type objet homonyme
de la méthode héritée. La nouvelle méthode prend le pas
sur celle reçue en héritage. Mais attention, seules les
méthodes peuvent être redéfinies, cela est interdit pour
les champs de données.
Si vous êtes observateur, vous aurez constaté que c'est
ce qui a été fait dans l'exemple ci-dessus le type objet
"fiches_date" reçoit la méthode "[Link]" en hérita­
ge. Mais il la redéfinit en une méthode propre
"fiches_date.debut" qui prend le pas sur celle reçue.

Méthodes virtuelles
Les méthodes utilisées jusqu'ici sont statiques. Quand le
compilateur rencontre une méthode statique, il regarde
si une méthode du nom est définie dans l'objet. Si la
réponse est positive, c'est l'adresse de cette méthode qui
est conservée. Sinon, la recherche se poursuit dans l'as­
cendant direct.
Si la méthode est trouvée, l'adresse de la méthode de
l'ascendant remplace celle de la méthode dans le code
du descendant. La recherche se poursuit de proche en
proche et bien entendu si la méthode n'est toujours pas
trouvée lorsque le type originel est atteint, il y aura un
message d'erreur. Le pointeur sur l'adresse de la métho­
de étant affecté à la compilation, on n'est plus certain à

122
l'exécution d'accéder au code correspondant à la métho­
de redéfinie, ce qui donnera des résultats peut-être
curieux à l'exécution et en tous les cas pas ceux
escomptés. Les méthodes virtuelles vont permettre de
résoudre ce genre de problème.
Qu'est-ce qu'une méthode virtuelle ?
On peut admettre de manière simplifiée que les
méthodes virtuelles sont aux méthodes statiques ce que
les variables dynamiques sont aux variables statiques
la résolution de leurs références est effectuée de manière
dynamique à l'exécution du programme et non à la com­
pilation.
Il ne faut cependant pas pousser la similitude trop loin
on crée des variables dynamiques pour avoir une
meilleure gestion de la mémoire, alors que l'on crée des
méthodes virtuelles pour avoir une extension de la
méthode, ce qui n'optimise en rien la gestion de la
mémoire, bien au contraire !
Il apparaît donc prudent, dès l'instant où une méthode
doit être redéfinie de la déclarer virtuelle, l'adresse de la
méthode n'étant affectée à son pointeur d'adresse qu'au
moment de l'exécution. Tous les descendants de l'objet
ancêtre de la méthode pourront toujours accéder à ce
code.
Comment déclarer une méthode virtuelle ?
On déclare une méthode virtuelle en faisant suivre son
en-tête du mot VIRTUAL. De même que l'on associe
aux variables dynamiques les procédures NEW et DIS­
POSE, deux méthodes particulières (CONSTRUCTOR
et DESTRUCTOR) vont permettre de mettre en oeuvre
et de détruire les méthodes virtuelles associées à un type
objet.
Les constructeurs
- Un constructeur n'est jamais virtuel.
- Tout objet possédant une méthode virtuelle doit com­
porter un constructeur.

123
- Tous les champs de données de l'objet doivent être
initialisés à l'appel du constructeur.
- Le constructeur devra être appelé avant le premier
appel à une méthode virtuelle.
- Toutes les méthodes descendantes homonymes d'une
méthode virtuelle doivent être redéclarées virtuelles.
C'est-à-dire qu'il faut spécifier à nouveau dans l'en­
tête, la mention VIRTUAL.
- L'usage veut que l'identificateur d'un constructeur
soit "init"
Que contiendra un constructeur ?
La première action d'un constructeur est toujours l'appel
au constructeur de son ascendant immédiat pour l'initia­
lisation des champs hérités. La seconde étape est l'initia­
lisation de ses champs propres. Les constructeurs sont
obligatoirement statiques puisque les méthodes vir­
tuelles dépendent justement d'une initialisation préalable
de l’objet par un constructeur.
Les destructeurs
- Un destructeur est généralement virtuel.
- Il n'a, en général, pas de paramètres.
- Sa définition peut être vide.
- L'usage veut que l'identificateur d'un destructeur soit
"fin"
Que contiendra un destructeur ?
L'action essentielle d'un destructeur est l'appel au des­
tructeur de son ascendant direct.
Remarques
- Un objet peut posséder à la fois des méthodes sta­
tiques et des méthodes virtuelles. C'est d’ailleurs tou­
jours le cas, dès l'instant où l'objet contient des
méthodes virtuelles puisque les constructeurs sont
toujours statiques.
- Une redéfinition d'une méthode statique peut modi­
fier à sa guise l'en-tête de la méthode (voir l'exemple
ci-dessus). En revanche, la redéfinition d'une métho­

124
 de virtuelle doit respecter strictement l'ordre, les
types et les noms des paramètres.
- Il est recommandé de définir les destructeurs virtuels
afin que l'appel à un constructeur concerne bien dans
tous les cas le type d'objet visé.
L'exemple suivant reprend le même programme qu'au
paragraphe précédant en introduisant des méthodes vir­
tuelles.
TYPE chaine = STRING[20],
fiches = OBJECT
nom,prénom chaine;
CONSTRUCTOR init(monnom,monprenom:
chaine),
PROCEDURE affiche;VIRTUAL,
DESTRUCTOR fin;VlRTUAL
END;
fiches_date = OBJECT(fiches)
annee WORD;
CONSTRUCTOR init(monnom,monprenom:
chaine;monanneeWORD),
PROCEDURE affiche;VIRTUAL,
DESTRUCTOR fin;VIRTUAL
END;
VAR mafiche_date fiches_date;
{Méthode de l'objet fiches}
CONSTRUCTOR [Link](monnom,
monprenom:chaine),
BEGIN
nom := monnom;
prénom := monprenom;
END;
PROCEDURE [Link];
BEGIN
WRITELN(nom),
WRITELN(prenom)
END;
DESTRUCTOR [Link]; <suite}
BEGIN
125
END;
{Méthodes de l'objet tiches_date}
CONSTRUCTOR fiches_date.init(monnom,
monprenom:chaine;monannee:WORD),
BEGIN
annee :=monannee;
[Link](monnom,monprenom);
END;
PROCEDURE fiches_date.affiche;
BEGIN
[Link];
WRITELN(annee)
END;
DESTRUCTOR fiches_date.fin;
BEGIN
[Link] au destucteur de l'antécédant}
END;
{Programme principal}
BEGIN
mafiche_date.init('DUPONT', 'Jules', I960),
mafiche_date.affiche;
mafiche_date.fin
END.
Méthodes statiques ou méthodes virtuelles ?
Les méthodes statiques correspondent à un appel direct,
alors que l'appel des méthodes virtuelles est indirect.
L'appel d'une méthode statique est donc toujours plus
rapide que celui d'une méthode virtuelle. La gestion de
la mémoire est optimisée avec les méthodes statiques. Si
une méthode ne doit pas être redéfinie, on la définira
donc comme statique. Pour les méthodes destinées à être
redéfinies, il faut mettre en balance les avantages et
inconvénients de chaque espèce.
Les méthodes statiques
- risque non négligeable que l'appel à une méthode
redéfinie ne concerne pas dans tous les cas le type
d'objet visé.
126
- gain en temps à l’exécution.
- optimisation de la gestion de la mémoire
- possibilité de redéfinir l'en-tête de la méthode.
Les méthodes virtuelles
- aucun risque à la redéfinition : l'appel concernera
toujours l'objet visé.
- perte de temps à l'exécution.
- moins bonne gestion de la mémoire.
- impossibilité de modifier l'en-tête des méthodes
redéfinies.
- définition d'un code évolutif, ce qui est finalement le
but de la POO.

A propos d'objets
Compatibilié et affectation
Un objet de type ascendant peut se voir affecter un objet
du type de l'un de ses descendants. L'inverse est toujours
interdit. En effet, un descendant a une structure plus
riche que ses ascendants. Une affectation d'un ascendant
vers un descendant laisserait des champs indéfinis, ce
qui serait dangereux et qui, de toutes les manières, est
interdit. Dans une affectation d'un descendant vers l'un
de ses ascendants, seuls les champs communs aux deux
types sont copiés.
Exemple
fiches := 1iches_date; (est correct}
La réciproque est interdite.
Constantes
Une constante de type objet se déclare avec la même
syntaxe que les constantes enregistrements. On ne peut
affecter de valeurs qu'aux champs de données.
Exemple
CONST
tafiche_date : fiches_date =
((nom 'DUPONT'; prénom Jules')
(annee I960));
127
Objets dynamiques
Les objets peuvent être des variables dynamiques au
même titre que n'importe quelle variable Pascal.
On déclare un type objet dynamique avec la syntaxe
habituelle.
Si le programme contient des objets dynamiques, chaque
constructeur commence par créer son propre objet par
NEW pour pouvoir initialiser ses champs de données.
Cependant que les destructeurs libéreront l'espace alloué
dynamiquemennt en faisant appel à DISPOSE.
L'exemple suivant reprend toujours le même program­
me, mais cette fois avec des objets dynamiques.
TYPE chaîne = STRING[20];
fichesptr = Niches;
fiches = OBJECT
nom,prénom chaîne;
CONSTRUCTOR init(monnom,monprenom:
chaîne),
PROCEDURE affiche;VIRTUAL,
DESTRUCTOR fin;VIRTUAL
END;
fiches_dateptr = Afiches_date;
fiches_date = OBJECT(fiches)
annee WORD;
CONSTRUCTOR init(monnom,monprenom:
chaine;monannee:WORD),
PROCEDURE affiche;VIRTUAL,
DESTRUCTOR finjVIRTUAL
END;
VAR maficheptr fichesptr;
mafiche_date fiches_date;
mafiche_dateptr fiches_dateptr;
{Méthode de l'objet fiches}
CONSTRUCTOR
[Link](monnom,monprenom:chaine),
BEGIN
NEW(maficheptr); (suite)

128
 nom := monnom;
prénom := monprenom;
END;
PROCEDURE [Link];
BEGIN
WRITELN(nom);
WRITELN(prenom)
END;
DESTRUCTOR [Link];
BEGIN
{libération de l'espace mémoire alloué
dynamiquement)
DISPOSE(maficheptr)
END;
{Méthodes de l'objet fiches_date)
CONSTRUCTOR fiches_date.init(monnom,
monprenom:chaine;monannee:WORD),
BEGIN
NEW(mafiche_dateptr),
fiches. init(monnom, monprenom),
annee :=monannee;
END;
PROCEDURE fiches_date.affiche;
BEGIN
[Link];
WRITELN(annee)
END;
DESTRUCTOR fiches_date.fin;
BEGIN
[Link];
DISPOSE(mafiche_dateptr)
END;
{Programme principal)
BEGIN
mafiche_date.init('DUPONT','Jules',1960),
mafiche_date.affiche;
mafiche_date.fin
END.
129
Extension de NEW et DISPOSE
NEW peut être utilisé maintenant commme une fonction
qui renvoie une variable dynamique du type spécifié et
ceci, même en dehors de l'environnement POO.
Exemple
NEW(p);
q:=pA; .
pourra s écrire .
q := NEW(p),
En outre, l'appel à NEW pour la création d'un objet, peut
comporter deux paramètres le nom du pointeur et l'ap­
pel à un constructeur.
Exemple
TYPE chaine = STRING[20J;
fichesptr = Niches,
fiches = OBJECT
nom,prénom chaine;
CONSTRUCTOR init(monnom,monprenom:
chaine),
PROCEDURE affiche;VIRTUAL,
DESTRUCTOR fin;VIRTUAL
END;
VAR mafiche fiches;
maficheptr fichesptr;
CONSTRUCTOR fiches. init(monnom,
monprenom:chaine),
BEGIN
nom := monnom;
prénom ;= monprenom;
END;
PROCEDURE [Link];
BEGIN
WRITELN(nom),
WRITELN(prenom)
END;
DESTRUCTOR [Link];
BEGIN (suite)

130
END;
{Programme principal}
BEGIN
maficheptr := NEW(fichesptr,init('DUPONT,'Jules')),
maficheptrA. affiche;
DISPOSE(maficheptr,fin)
END.
Units
Des objets peuvent parfaitement être définis dans des
units. La déclaration est faite dans la partie INTERFA­
CE, les méthodes qui en dépendent figurent dans la par­
tie IMPLEMENTATION. Dans la partie IMPLEMEN­
TATION, l'unit peut définir ses propres objets exacte­
ment comme n'importe quel type ou variable du Pascal.

Fichiers
Les types FILE ne peuvent pas gérer la sauvegarde ni la
lecture de structure de type OBJECT Pour faire une
telle sauvegarde, il vous faudra utiliser l'unit
[Link] contenu dans [Link]
(consulter le manuel du fabricant).

Utilisation du débogueur intégré

La mise au point d'un programme orienté objet se fera
de la même manière qu'un programme traditionnel. Un
objet ou une méthode inséré dans la fenêtre Watch sera
suivi comme un enregistrement ou une procédure.
Pour des programmes vraiment complexes, l'utilisateur
peut avoir intérêt à se procurer TURBO DEBUGGER
qui permet, en particulier, d'afficher la hiérarchie des
types d'objets manipulés.
Directive de compilation
{SRsigne}
{$R+} contrôle avant chaque appel à une méthode vir­
tuelle si son constructeur a bien été appelé.
Valeur par défaut {$R-J

131
Annexe 1. Directives
de compilation
Elles contrôlent certaines caractéristiques du compila­
teur. Une directive de compilation est spécifiée dans un
programme comme un commentaire avec une syntaxe
particulière
{$directive signe)
(pas d'espace entre la directive et le signe)
{$directive paramètrel,paramètre2„.)
(espace obligatoire entre la directive et le premier para­
mètre)
On peut également spécifier certaines directives en acti­
vant une option du sous-menu Options/Compiler (voir
chapitre 2 "Menu Options").
Il existe trois sortes de directives
- interrupteurs
- paramètres
- conditionnelles
Les directives ont une valeur par défaut choisie pour
minimiser la vitesse d'exécution et la taille du code
objet.
La liste suivante donne chaque directive avec sa syn­
taxe, suivie, s'il y a lieu, de l'option du menu
Options/Compiler équivalent et de son type.

Directives interrupteurs
Plusieurs directives interrupteurs peuvent être séparées
et regroupées en une seule par des virgules.
Exemple
{$I+,B+,D-}

132
{$Bsigne} Boolean évaluation (local)
{$B+} Tous les termes d'une expression Booléenne sont
évalués.
($B-) Le compilateur cesse d'évaluer les termes
Booléens dès que le résultat de l'expression est évident.
Valeur par défaut • {$B-}
($Dsigne) Debug information (global)
($D+) permet à Turbo Pascal de localiser une erreur
d'exécution dans le programme source.
Valeur par défaut {$D+}
{$Fsigne} Force farcalls (local)
{$F+} Fonctions et procédures sont compilées comme
des routines lointaines (appels et retours avec change­
ment de code segment).
($F-) Le compilateur choisit le mode de compilation
approprié à chaque routine.
Valeur par défaut {$F-)
{$Isigne} I/O checking (local)
{$1+} Vérifie les E/S. (~
{$1-} Le programme doit vérifier les E/S lui-même à
l'aide de la fonction IORESULT.
(voir chapitre 10 "Vérification des entrées/sorties").
Valeur par défaut {$1+}
{$Lsigne} Link buffer (global)
{$L+} Les units utilisés par le programme sont copiés
en mémoire durant la compilation du programme princi­
pal, cela accélère la compilation mais nécessite plus de
mémoire.
{$L-} Les units utilisés sont lus deux fois sur le disque
au cours de la compilation.
Valeur par défaut {L+}
{$Nsigne} Numérique processing (global)
($N+) permet l'utilisation des quatre types de réels du
coprocesseur arithmétique.
Valeur par défaut {$N-J

133
{$Rsigne} Range checking (local)
{$R+} Le compilateur vérifie que les indices utilisés par
les tableaux et les chaînes sont inclus dans leurs bornes
de définition.
{$R+ ) est à utiliser au cours de la mise au point des pro­
grammes.
Valeur par défaut {$R-J
{$SsigneJ Stack checking (local)
($S+) A chaque appel de fonction ou de procédure, le
compilateur vérifie si l'espace disponible dans la pile est
suffisant pour les variables locales.
Valeur par défaut {$S+}
{$Tsigne} Turbo map file (global)
A utiliser uniquement lors de la compilation de pro­
grammes sur disque.
($T+) génère un programme TPM. Un programme
TPM pourra être utilisé par le menu Compile/Find error
pour localiser une erreur d'exécution dans le programme
source. Le programme source doit avoir été compile
avec la directive ($D+) pour que le fichier TPM
contienne les informations nécessaires.
Valeur par défaut ($T-)
{$Vsigne} Var-string checking (local)
($V+ ) vérifie si la longueur des chaînes passées comme
paramètres coïncide avec la longueur de chaîne déclarée
dans les paramètres de la procédure.
Valeur par défaut ($V+)

Directives paramètres
{$1 fichier} Fichier inclus
(voir chapitre 12 "Les fichiers inclus").
{$L nom fichier} (local)
Cette directive est à utiliser lorsque le programme
emploie des routines externes écrites en assembleur, ras­
semblées dans le fichier spécifié. L'extension .OBJ est
prise par défaut (fichier relogeable).
134
{$M taille_pile,mintas,maxtas}Memory sizes (local)
Cette directive spécifie la distribution de la mémoire.
"Taille_pile" spécifie la taille du segment de pile
(1024..65520). "mintas" et "maxtas" spécifient les tailles
minimale et maximale du tas. "mintas" appartient à l'in­
tervalle (0..655360), et "maxtas" à (Mintas..655360).
Valeurs par défaut {$M 16384,0,655360}, soit la totalité
de la mémoire disponible allouée au tas. Voir chapitre
13 "Allocation de la mémoire"
{$U nomfichier} (local)
(voir chapitre 15 "Les units").

Directives conditionnelles
Elles permettent une compilation conditionnelle d'une
portion de programme. L'utilisation d'une directive
conditionnelle est tout à fait similaire à l'instruction IF
du Pascal.
L'usage d'une telle directive sera de la forme
{$IFxxx...} code source "un"
{$ELSE} code source "deux"
<$ENDIF)
dans laquelle "IFxxx" correspond à :IFDEF, IFNDEF ou
IFOPT
Si la condition de {$IFxxx...} est vérifiée code source
"un" sera compilé, sinon c'est code source "deux" qui
sera compilé.
{$ELSE} est optionnel.
Les directives {SIFDEF} et {SIFNDEF} utilisent des
symboles conditionnels eux-mêmes définis ou non par
les directives {SDEF1NE symbole) et (SUNDEF sym­
bole}
{$DEFINE symbole}
Menu équivalent.
Options/Compiler/Conditional defines
Cette directive définit un symbole pour une directive
($IFDEF) ou {SIFNDEF} Le nom donné à un symbole

135
conditionnel obéit aux mêmes règles que les identifica­
teurs Pascal.
Un symbole conditionnel est inconnu dans le program­
me Pascal.

Exemple
{$DEFINE a}
IFaTHEN WRITEfa existe')
(‘diagnostiquera une erreur*)

Il existe quatre symboles prédéfinis en Turbo Pascal.

VER40 correspond à la version 4.0 de Turbo, les
versions suivantes correspondront à
VER55 pour VER 5.5...
MSDOS indique que le système d'exploitation est
MS-DOS.
CPU86 indique que le microprocesseur appartient à
la famille des 80x86.
CPU87 n'est définit que si le coprocesseur arithmé­
tique 8087 est présent.

{$UNDEF symbole}
Annule la définition d'un symbole conditionnel.
{$IFDEF symbole}
Compilation du code suivant si "symbole" est défini.
{$IFNDEF symbole}
Compilation du code suivant si "symbole" n'est pas
défini.
($IFOPT x+}
Compilation du code suivant si la directive interrupteur
"x" est active.
{$IFOPT x-}
Compilation du code suivant si la directive interrupteur
"x" est inactive.

136
{$ELSE}
Compilation du code suivant si la condition posée dans
une directive {$IFxxx...} n'est pas réalisée.
{$ENDIF}
Marque la fin d'une directive conditionnelle.
Exemple
{$IFDEF CPU87}(*Si le 8087 est présent*)
{$N+}(*utiliser les types du 8087*)
{$ENDIF}

Annexe 2. Erreurs

Erreurs à la compilation
Lors d'une erreur de compilation, le curseur est position­
né sur l'erreur dans l'éditeur, le message suivant apparaît
dans le haut de l'éditeur
Error "numéro de l'erreur" "message d'erreur"
Messages d'erreurs
1. Out of memory
Espace mémoire insuffisant, solutions
- compiler le programme sur disque.
- diviser le programme en plusieurs units.
- supprimer le fichier d'aide à l'utilisateur
([Link]).
- utiliser TPC au lieu de TURBO.
- supprimer les programmes résidents.
- utiliser des units de recouvrement (OVERLAY).

137
2. Identifier expected
3. Unknown identifier
Tout identificateur doit être déclaré.
4. Duplicate identifier
Identificateur déjà défini.
5. Syntaxe error
6. Error in real constant
Erreur dans une constante réelle.
7. Error in integer constant
Un réel supérieur au plus grand entier doit se terminer
par un point.
8. String constant exceeds line
Les constantes chaîne ne doivent pas excéder une ligne.
9. Too many nested files
Le compilateur est limité à cinq fichiers sources.
10. Unexpected end of file
- Il y a probablement des BEGIN sans END.
- H n'y a pas de point final.
- Un commentaire n'est pas fermé.
11. Line too long
Longueur maximale 126 caractères.
12. Type identifier expected
13. Too many open files
Trop de fichiers ouverts.
Solution
Modifier la valeur de FILES dans [Link].
14. Invalid file name
Nom de fichier invalide.
15. File not found
Le fichier n'est pas trouvé dans le répertoire courant, ni
dans les répertoires qui contiennent ce type de fichier.
16. Disk full
Plus de place sur le disque
Solution
Prenez un autre disque ou détruisez des fichiers.
17. Invalide compiler directive
- La lettre de la directive n'existe pas.
- Un des paramètres est invalide.

138
- Une directive globale est utilisée alors qu'une partie
du programme est compilée.
18. Too many files
Il y a trop de fichiers invoqués lors de la compilation.
Solution
Fusionner plusieurs fichiers.
19. Undefined type in pointer définition
Le type pointeur n'a pas été déclaré.
20. Variable identifier expected
Identificateur variable attendu.
21. Error in type
22. Structure too large
La taille maximale d'une variable structurée est de
65520 octets.
23. Set base type out of range
Le type de base d'un ensemble est limité à 256 éléments.
24. File component may not be files
Les fichiers de fichiers sont interdits.
25. Invalid string length
Longueur maximale d'une chaîne = 256.
26. Type mismatch
Incompatibilité de type, peut apparaître
- dans une assignation.
- dans un passage de paramètres.
- entre les termes d'une expression.
- avec une expression utilisée comme index dans un
tableau.
27. Invalid subrange base type
Type de base autorisé pour un type structuré type sca­
laire.
28. Lower bound greater than upper bound
Borne inférieure supérieure à la borne supérieure dans
une déclaration de type structuré.
29. Ordinal type expected
Type scalaire obligatoire.
30. Integer constant expected
31. Constante expected
32. Integer or real constante expected
139
33. Type identifier expected
34. Invalid function resuit type
Le type retourné par une fonction est interdit.
Types autorisés simple, chaîne, pointeur.
35. Label identifier expected
Identificateur d'étiquette attendu.
36. BEGIN expected
37. END expected
38. Integer expression expected
39. Ordinal expression expected
Expression scalaire obligatoire.
40. Boolean expression expected
41. Operand types do not match operator
Types des termes incompatibles avec l'opérateur.
42. Error in expression
N'avez-vous pas oublié un opérateur ?
43. Illégal assignment
Les affectations entre fichiers et variables sans type sont
interdites.
44. Field identifier expected
Identificateur de champ (rubrique) attendu dans la spéci­
fication d'une variable RECORD.
45. Object file too large
Taille maximale d'un fichier (.OBJ) 64 Ko.
46. Undefined external
Routine externe non définie.
Les fichiers contenant les routines en assembleur doi­
vent être déclarées par la directive ($L nom_fichier)
47. Invalid object file record
Fichier objet (.OBJ) invalide.
Le fichier .OBJ est-il bien un fichier objet ?
48. Code segment too large
Le code segment ne peut excéder 64 Ko. Diviser votre
programme en plusieurs units.
49. Data segment too large
Le segment de données ne peut excéder 64 Ko.
Utiliser des variables dynamiques.

140
50. DO expected
51. Invalid public définition
Un identificateur PUBLIC dans une routine en assem­
bleur n'a pas été déclaré externe dans le programme
Pascal.
52. Invalid extrn définition
Les identificateurs déclarés EXTRN ne
doivent pas dénoter des variables absolues ni des rou­
tines INLINE.
53. Too many extrn définitions
Un fichier objet ne doit pas comprendre plus de 256
définitions EXTRN. <
54. OF expected
55. INTERFACE expected
56. Invalid relocatable reference
Les routines en assembleur (.OBJ) doivent être relo­
geables (pas de référence au code objet).
57. THEN expected
58. TO or DOWNTO expected
59. Undefined forward
Référence en avant indéfinie
- une routine déclarée dans l'interface n'apparaît pas
dans l'implémentation.
- une routine FORWARD n'a pas de définition.
60. Too many procedures
Nombre maximal de routines 512.
Solution
Scinder le programme en divers units.
61. Invalid typecast
Une affectation ne peut avoir lieu qu'entre variables ou
expressions de même type.
62. Division by zéro
63. Invalide file type
La routine spécifiée ne peut pas être utilisée avec le type
de fichier spécifié.
64. Cannot read or write variable of this type
Impossible de lire ou écrire des variables de ce type.

141
Types utilisables en E/S CHAR, INTEGER, REAL et
STRING.
65. Pointer variable expected
66. String variable expected
67. String expression expected
68. Unit not found
L'unit n'a pas été spécifié dans une clause USES.
69. Unit name mismatch
Le nom du fichier TPU est différent de celui spécifié
dans la clause USES.
70. Unit version mismatch
Les units utilisés ont été modifiés.
Solution
Utiliser une des commandes
Compile/Make ou Compile/Build.
71. Duplicate unit name
Nom d'unit déjà mentionné dans une clause USES.
72. Unit file format error
Un unit est un fichier TPU.
73. Implémentation expected
74. Constant and case types do not match
Le type constante est incompatible avec le sélecteur de
cas (CASE).
75. Record variable expected
76. Constant out of range
Constante hors des limites
- l'index d'un tableau déborde,
- affectation hors limite du type,
- passage de paramètres hors limite du type.
77. File variable expected
78. Pointer expression expected
79. Integer or real expression expected
80. Label not within current block
Etiquette n'appartenant pas au bloc courant.
81. Label already defined
Etiquette déjà définie

142
82. Undefined label in preceding statement part
Etiquette non définie.
83. Invalid @ argument
L'opérateur @ peut agir sur les variables, les fonctions
et les procédures.
84. UNIT expected
85. expected
86. " expected
87. expected
88. "(" expected
89. ")" expected
90. "=" expected
91. " :=" expected
92. "[" or "(." expected
93. "]" or ".)" expected
94. expected
95. expected
96. Too many variables
Les variables globales et les variables locales ne peuvent
excéder 64 Ko.
97. Invalid FOR control variable
Type autorisé pour une variable de contrôle d'une boucle
FOR scalaire.
98. Integer variable expected
99. Files are not allowed here
Type fichier interdit.
100. String length mismatch
Longueur de chaîne ne coïncidant pas avec le nombre de
composants du tableau de caractères.
101. Invalid ordering of fields
Les champs d'une variable RECORD doivent être écrits
dans l'ordre de la déclaration.
102. String constant expected
103. Integer or real variable expected
104. Ordinal variable expected
Variable scalaire attendue.
105. INLINE error

143
106. Character expression expected
107. Too many relocations items
La taille de la table d'allocation de fichiers .EXE dépas­
se 64 Ko. Le programme est trop grand pour l'éditeur de
liens de Turbo Pascal et également pour le DOS.
Solution
Utiliser la procédure EXEC du DOS en séparant le pro­
gramme en un programme principal et plusieurs pro­
grammes secondaires.
108. Not enough memory to run program
Espace mémoire insuffisant pour exécuter le programme.
Solutions
- supprimer les programmes résidents.
- compiler le programme sur disque et l'exécuter sous
DOS.
109. Cannot find EXE file
Fichier EXE introuvable.
110. Cannot run a unit
Un unit ne peut être exécuté que depuis un programme
qui l'utilise.
111. Compilation aborted
Compilation interrompue par Ctrl-Break.
112. CASE constant out of range
Constante de cas (CASE) hors limites du type.
113. Error in statement
114. Cannot call an interrupt procedure
Appel d'interruption interdit.
115. Must hâve an 8087 to compile this
Un coprocesseur 8087 est nécessaire pour compiler ceci.
116. Must be in 8087 mode to compile this
Il faut être en mode 8087 pour compiler ceci {$N+}.
117. Target adresse not found
L'instruction correspondant à l'adresse est introuvable.
La commande Compile/File ne peut localiser l'erreur.
118. Include files are not allowed here
Fichiers inclus interdits ici.
119. TPM file format error
Erreur dans le format d'un fichier TPM.

144
Est-ce bien un fichier TPM ?
120. NIL expected
121. Invalid qualifer
Utilisation erronée d'une variable
- indexation d'une variable autre qu'un tableau ou une
chaîne.
- spécification de champ pour une variable non
RECORD.
- déréférence d'une variable non pointeur.
122. Invalid reference variable
La valeur retournée par une fonction pointeur n'a pas été
déréférenciée.
123. Too many symbols
Le nombre de symboles est limité à 64 Ko.
Solutions
- {$D-}
- faire une partie des déclarations dans un unit.
124. Statement part too large
Bloc de traitement trop volumineux. Un bloc de traite­
ment est limité à 24 Ko environ.
Solution
Séparer le bloc en plusieurs procédures.
125. Module has no debug information
Le module n'a pas d'information pour localiser une
erreur.
Solution
Recompiler le module avec Debug info on, et utiliser si
nécessaire Compile/Find pour localiser l'erreur.
126. Files must be var parameters
Les fichiers doivent être passés comme paramètres
variables.
127. Too many conditionnai symbols
Trop de symboles conditionnels.
128. Misplaced conditionnai directive
Directive conditionnelle mal placée.
($ELSE) ou {SENDIF} sans {$IFxxx}
129. ENDIF directive missing
Pas de directive {$ENDIF} Il doit y avoir autant de

145
 {$IFxxx} que de {$ENDIF}
130. Error in initial conditionnai defines
Définition incorrecte de symboles conditionnels (voir la
syntaxe de la directive {SDEFINE }).
131. Header does not match previous définition
L’en-tête d'une routine spécifiée FORWARD ou dans
1ÏNTERFACE ne correspond pas à celle du bloc.

Erreurs à l'exécution
Affichage: Runtime error nnn at xxxx yyyy
nnn = numéro de l'erreur
xxxx yyyy = adresse de l'erreur (segment:offset)
Les erreurs d'E/S vont de 1..199.
La directive de compilation I doit être active pour pro­
voquer l'arrêt du programme.
En mode passif une erreur ne provoque pas l'arrêt du
programme, mais les opérations d'entrée/sortie sont sus­
pendues jusqu'à l'appel de la fonction IORESULT.
Les erreurs de 1 ..99 correspondent au code d'erreur du
DOS. Les erreurs fatales vont de 200..255. Elles provo­
quent toujours l'arrêt du programme.
Principaux messages d'erreurs à l'exécution
Les erreurs d'E/S
2. File not found
Fichier disque inconnu.
3. Path not found
Chemin inconnu ou invalide. Le répertoire n'existe pas.
4. Too many open files
Trop de fichiers ouverts (voir erreur de compilation 13).
5. File access denied
Accès fichier refusé.
Fichier ouvert en lecture ? En écriture ?
Opérations d'écriture autorisées dans le fichier ?
Répertoire complet ?
Destruction de fichier autorisée ?

146
Nouveau nom de fichier déjà existant ?
6. Invalide file handle
Numéro de fichier DOS invalide.
12. Invalide file access code
Code d'accès fichier invalide.
La valeur de FILEMODE est invalide.
15. Invalide drive number
Numéro de lecteur invalide.
16. Cannot remove current directory
Impossible d'effacer le répertoire courant.
17. Cannot rename across drives
Impossible de renommer un fichier sur un lecteur diffé­
rent.
100. Disk read error
Erreur de lecture sur le disque lecture après la fin de
fichier.
101. Disk write error
Erreur d'écriture sur le disque plus de place sur le
disque.
102. File not assigned
Fichier non assigné. Un fichier disque doit obligatoire­
ment être assigné à une variable fichier.
103. File not open
Fichier non ouvert.
104. File not open for input
Fichier non ouvert en lecture.
105. File not open for output
Fichier non ouvert en écriture.
106. Invalid numeric format
La valeur numérique lue est incompatible avec le format
spécifié.

Erreurs fatales
200. Division by zéro
201. Range check error
Valeur hors limites. Ne peut apparaître que si {$R+}
(R active). (Voir erreur de compilation 76).

147
202. Stack overflow error
Plus de place dans la pile.
Ne peut apparaître que si {$S+} (S active).
Solution :
Utiliser ($M...)
203. Heap overflow error
Plus de place dans le tas.
Vérifier {$M...}
204. Invalide pointer operation
Tentative d'allocation hors du tas.
Utilisation de DISPOSE ou FREEMEM avec un poin­
teur = NIL.
205. Floating point overflow
Dépassement de capacité en virgule flottante.
206. Floating point underflow
Valeur en virgule flottante trop faible.
Ne peut apparaître qu'en utilisant le 8087
Le résultat est zéro.
207. Invalid floating point operation
Opération invalide en virgule flottante.
Argument négatif pour SQRT ou LN. Réel dépassant les
bornes des entiers pour TRUNC ou ROUND.

148
Annexe 3. Index

A BKSLASHHLL................. 107
BLACK................................86
@......................................... 62 BLINK................................. 87
ABS..................................... 41 BLOCKREAD.................... 57
ABSOLUTE........................ 71 BLOCKWRITE................... 57
ADDR................................. 62 BLUE.................................. 86
AND............................ 26, 105 BOOLEAN.................... 30,39
ANDPUT............................ 105 BROWN.............................. 86
ANYHLE............................ 92 BW40.................................. 86
APPEND............................. 55 BW80.................................. 86
ARC...................................102 BYTE............................ 30,38
ARCHIVE........................... 92
ARCTAN............................. 41
ARRAY..OF.................. 30,46 c
ASCH...................................11
ASSIGN.............................. 53 C40...................................... 86
ASSIGNCRT....................... 88 C80...................................... 86
ATT400 ............................... 98 CASE..OF..END................. 35
ATT400C0........................... 99 CENTERLN....................... 108
ATT400C1........................... 99 CFG...................................... 13
ATT400C2........................... 99 CGA......................... 10,98,99
ATT400C3........................... 99 CGAC0................................ 99
ATT400HI........................... 99 CGAC1..................... 99
ATT400MED....................... 99 CGAC2................................ 99
AT&T 400 line.....................10 CGAC3................................ 99
AUX.................................... 34 CGAHI................................ 99
CHAR............................ 30,39
CHDIR................................ 78
B CHECKBREAK.... .............. 87
CHECKEOF........................ 87
$B.......................................133 CHECKSNOW................... 87
.B AK.................................... 13 CHR.................................... 42
BAR.................................. 103 .CHR............................. 11,109
BAR3D............................... 103 CIRCLE.............................. 103
BEGIN. .28, 35 CLEARDEVICE................ 103
.BGI ............................. 11,100 CLEARVIEWPORT.......... 103

149
CLOSE................................ 53 DIV...................................... 26
CLOSEDOTFILL.............. 107 DO..................... ..... 36, 37,49
CLOSEGRAPH.................. 100 DOS................... ........... 80,92
CLREOL............................. 88 DOSERROR..... ................. 93
CLRSCR............................. 88 DOTTEDLN..... ............... 108
COM 1 et COM2.................. 34 DOUBLE........... ........... 30,39
COMP................................ 30,39 DRAWPOLY..... ................ 103
CON.................................... 34 DS...................... ................. 73
CONCAT............................. 46 DSEG............................ 73, 75
CONST............................... 28,29
CONSTRUCTOR..............123
COPY.................................. 12 E
COS..................................... 41
CPU86................................136 EGA.......................... 10,98,99
CPU87................................136 EGA64HI............................ 99
CRT..................................... 80 EGA64LO........................... 99
CS........................................ 72 EGAHI................................ 99
CSEG................................. 72,75 EGALO............................... 99
CYAN.................................. 86 EGAMONO........................ 98
EGAMONOHI.................... 99
ELLIPSE............................ 103
D SELSE........................ 135,137
ELSE............................. 35,36
$D................................ 20, 133 EMPTYFILL...................... 107
DARKGRAY...................... 86 END............................... 24,35
DASHEDLN......................108 SENDIF......................135, 137
DATETIME......................... 93 EOF..................................... 53
DEC..................................... 41 EOLN.................................. 55
DEFAULTFONT............... 109 ERASE................................ 53
SDEFINE..............................19 .EXE..................................... 13
DELAY................................ 88 EXIT.................................... 37
DELETE.............................. 45 EXP.................................... 41
DELLINE............................ 89 EXTENDED................. 30,39
DESTRUCTOR..................123 EXTERNAL........................ 68
DETECT............................. 98
DETECTGRAPH............... 101
DIRECTORY...................... 92 F
DIRECTVIDEO.................. 87
DISKFREE.......................... 96 $F................................ 20, 133
DISKSIZE........................... 96 FALSE.................................29
DISPOSE............................. 60 FAUXILLARY.................... 92

150
FCARRY............. ................ 92 GETX................................. 104
FILE........................ 30,52,57 GETY................................. 104
FILEOF.............. .......... 30, 52 GOTHICFONT.................. 109
FILEPOS............. ............... 54 GOTO................................. 104
FILESIZE.... .J... ............... 54 GOTOXY.............................89
FILLPOLY.......... ............. 104 GRAPH................................ 11
FINDFIRST......... ............... 93 GRAPH3..............................80
FINDNEXT......... ............... 93 [Link]....................... 11
FLOODFILL....... ..............104 GRAPHERRORMSG........101
FLUSH................ ............... 56 GRAPHRESULT............... 101
FMCLOSED....... ............... 92 [Link].................... 12
FMINPUT........... ............... 92 GREEN................................86
FMINOUT........... ............... 92 [Link].......................... 12
FMOUTPUT....... ............... 92 GRERROR.......................... 98
FOR..TO..DO...... ............... 37 [Link]............ 11
FORWARD......... ......... 68, 81 GRFILENOTFOUND......... 97
FOVERFLOW.... ............... 92 GRFONTNOTFOUND....... 98
FPARITY............ ............... 92 GRINDVALIDDEVICENUM ..98
FRAC.................. ............... 41 GRINDVALIDFONT.......... 98
FREEMEM......... ............... 60 GRINDVALIDFONTNUM .98
FREEPTR 73 75 GRINVALIDDRIVER........ 97
FSIGN................. ............... 92 GRINVALIDMODE........... 98
FUNCTION......... ......... 27, 65 GRIOERROR...................... 98
FZERO................ ............... 92 GRNODETECTED............. 97
GRNOFLOODMEM........... 97
GRNOINTTGRAPH............ 97
G GRNOLOADMEM............. 97
GRNOSCANMEM............. 97
GETBKCOLOR.................104 GRUCK............................... 97
GETCOLOR......................104
GETDATE........................... 95
GETDIR.............................. 79 H
GETFATTR................... 92, 96
GETFTIME......................... 95 HALT.................................. 38
GETGRAPHMODE.......... 101 HATCHFILL...................... 107
GETTMAGE....................... 104 HEAPORG.................... 73,75
GETMAXX........................104 HEAPPTR..................... 73,75
GETMAXY........................104 HERCMONO...................... 98
GETMEM........................... 59 HERCMONOHI.................. 99
GETPIXEL.........................104 HI......................................... 43
GETTIME........................... 95 HIDDEN............................. 92

151
HIGHVIDEO................... 89 LIGHTCYAN...................... 87
HORIZDIR....................... 109 LIGHTGREEN................... 86
LIGHTGREY...................... 86
LIGHTMAGENTA............. 87
I LIGHTRED......................... 87
LINE................................... 104
SI................... 20, 70,133,134 LINEFILL.......................... 107
SIF......................................135 LINEREL........................... 104
SIFDEF....................... 135,136 LINETO............................. 105
SIFNDEF.................... 135,136 LISEZ MOI.......................... 11
SIFOPT....’...................135,136 [Link]................11
IF..THEN..ELSE................. 35 [Link]........................ 12
IMAGESIZE......................104 LN....................................... 41
IMPLEMENTATION.......... 80 LO....................................... 43
IN......................................... 51 LONGINT..................... 30,38
INC...................................... 40 LOWVIDEO....................... 89
INT...................................... 41 LPT...................................... 34
INITGRAPH......................100 LST...................................... 91
INLINE......................... 76, 81 LTBKSLASHFILL............. 107
INPUT................................. 33 LTSLASHFILL.................. 107
INSERT............................... 45
INSLINE............................. 89
INT.......................................... M
INTEGER...................... 30, 38
INTERFACE....................... 80 SM...................................... 135
INTERLEAVEFILL.......... 107 MAGENTA......................... 86
INTR................................... 94
[Link]......................... 12
IORESULT.................. 57,112 .MAP.................................... 12
MARK................................. 60
K MAXAVAIL........................ 62
MAXINT............................. 29
KEYPRESSED................... 89 MCGA...................... 10,98,99
MCGAC0............................ 99
MCGAC1............................ 99
L MCGAC2............................ 99
MCGAC3............................ 99
SL.................. 20, 68,133,134 MCGAHI............................. 99
LABEL................................ 28 MCGAMED........................ 99
LAST................................... 86 MEM................................... 77
LENGTH............................. 46 MEMAVAIL........................ 62
LIGHTBLUE...................... 86 MEML................................. 77

152
MEMW............................... 77 P
MKDIR............................... 78
MOD................................... 26 PACKED........... ................ 48
MONO................................. 86 PACKTIME....... ................ 96
MOVEREL....................... 105 PARAMCOUNT ................ 67
MOVETO..... ..................... 105 PARAMSTR....... ................ 67
MSDOS............................... 95 .PAS.................... ................ 12
.PCK................... ................. 13
PIES LICE........... ............... 105
N POINTER........... .......... 30,59
PORT.................. ................ 77
$N....................................... 134 PORTW.............. ................ 77
NEW.................................... 59 POS.................... ................ 46
NIL...................................... 61 PRED................. ................ 40
[Link].................... 16 PRINTER........... .......... 80, 90
NORMALPUT...................105 PRN.................... ................ 34
NORMVIDEO.................... 89 PROCEDURE.... .......... 27 65
NORMWIDTH..................108 PTR.................... ............... 62
NOSOUND......................... 91 PUTIMAGE....... .....100,105
NOT............................. 26,105 PUTPIXEL......... .............106
NOTPUT............................ 105
NUL..................................... 34
R
$R....................... ....... 20, 134
O RANDOM.......... ............... 43
oFrittiSftn?*/........ RANDOMIZE.... ............... 43
OBJECT.............................119 RE AD................. ....31,54,55
ODD.................................... 43 READKEY......... ............... 89
OF.................................. 36, 51 READLN............ ......... 31,55
OFS..................................... 72 READONLY...... ............... 92
OR..................................... 105 REAL................. ......... 30, 39
ORD.................................... 42 RECORD........... ......... 30,48
ORPUT............................... 105 RECTANGLE.... ............. 106
OUTPUT............................. 33 RED.................... ............... 86
OUTTEXTXY.................... 105 REGISTERS...... ............... 93
OVERLAY.......................... 82 RELEASE.......... ............... 60
OVERINTT........................ 117 RENAME........... ............... 53
OVERINTTEMPS...............117 REPEAT..UNTTL .............. 37
OVERRESULT..................118 RESET................ ......... 54, 55
OVERSETBUF..................118 RESTORECRT... ...... 90,102

153
RESTORECRTMODE...... 102 SP........................................ 69
REWRETE.......................... 53 SPTR................................... 73
ROUND.............................. 42 SQR..................................... 42
SQRT................................... 42
SS........................................ 73
S SSEG................................... 73
STRING........................ 30,44
$S................................ 20, 134 STR..................................... 45
SANSSERIFFONT............ 109 SUCC.................................. 40
SEARCHREC..................... 93 SWAP.................................. 43
SEEK................................... 54 SYSFILE............................. 92
SEEKEOF........................... 55 SYSTEM............................. 79
SEEKEOLN........................ 55
SEG..................................... 72
SETACTIVEPAGE............ 106 T
SETBKCOLOR..................106
SETCOLOR....................... 106 ST................................ 20, 134
SETDATE........................... 95 3270 PC.......................... 10,99
SETFATTR......................... 92,96 TEXT............... 30, 52
SETFILLPATTERN...........106 TEXTATTR......................... 87
SETFILLSTYLE..99, 100,107 TEXTBACKGROUND...... 90
SETFTIME.......................... 95 TEXTCOLOR..................... 90
SETGRAPHMODE...........102 TEXTHEIGHT...................110
SETLINESTYLE............... 108 TEXTMODE....................... 90
SET OF............................... 30,51 TEXTREC..................... 58,93
SETTEXTBUF.................... 55 TEXTWIDTH.................... 110
SETTEXTSTYLE..............109 THEN.................................. 35
SETT1ME............................ 95 THICKWIDTH.................. 108
SETVIEWPORT................ 109 [Link]................... 12, 23
SETVISU ALPAGE............110 TO....................................... 37
SHL..................................... 26 [Link]...................... 12
SHORTINT.......... .........30, 38 TP........................................ 13
SHR..................................... 26 TPC...................................... 13
SIN...................................... 42 [Link].............................. 12
SINGLE.............................. 30,39 .TPL...................................... 13
SIZEOF............................... 73 TPM.................................... 13
SLASHHLL.......................107 [Link]........................ 12
SMALLFONT....................109 TPU..................................... 13
SOLIDFILL........................107 [Link].........12, 84
SOLIDLN...........................108 TRM.................................... 34
SOUND............................... 91 TRUE.................................. 29

154
TRUNC............................... 42 VERTDIR........................... 109
TURBO 3............................ 80 VGA.........................10,98, 99
[Link]........................11 VGAHI................................ 99
[Link]........................11 VGAMED........................... 99
[Link]...................... 22 VGALO............................... 99
[Link]......................... 22,23 VIRTUAL.......................... 123
[Link]............ 11,79,84
[Link]........................11
TYPE.................................. 27,29 w
WHEREX............................ 90
U WHEREY............................ 90
WHILE..DO........................ 36
SU....................................... 135 WHITE................................ 87
SUNDEF............................ 136 WIDEDOTFILL................. 107
UNIT................................... 80 WINDMAX......................... 88
[Link].,.................. 11 WINDMIN.......................... 88
UNPACKTIME................... 96 WINDOW........................... 90
UNTIL................................. 37 WITH..DO........................... 49
UPCASE............................. 43 WORD........................... 30,38
[Link]..................12 WRITE.................... 32, 54, 55
USERBITLN......................108 WRITELN..................... 32,55
USERFILL.........................107
USES................................... 81
USR..................................... 34 X
XHATCHFILL................... 107
V XOR.................................... 26
XORPUT............................ 105
SV................................ 20, 134
VAL..................................... 45
VAR............................... 27, 30 Y
VER40................................136
VER55................................136 YELLOW.............................87

155
 F / P

’ol u«l Ta • J’- Jy

lU
 Collection
Presses Pocket
Micro-informatique

Le Basic et ses fichiers tomes 1 et 2

par Jacques Boisgontier

Initiation facile GW-BASIC

Initiation facile Turbo Pascal
par Jean-Michel Gaudin

Initiation facile MS-DOS

par Alain Pinaud

Initiation facile Excel Mac

Initiation facile Word 4 Mac
par Pierre Auchatraire

Initiation facile Excel PC

par Laurent Toubiana

Guide rapide Turbo Pascal

Guide rapide dBase III Plus
par Bénédicte Hudault

Guide rapide SQL

Guide rapide Unix
par Uriel Chouchena et Patrick Pons

Guide rapide Works

Guide rapide Turbo C
par Jean-Michel Gaudin

Guide rapide Macintosh

par Pierre Brandeis
 Micro Mémento MS-DOS
par Yvon Dargery

Micro Mémento Programmeur PC

par Daniel Martin

Micro Mémento Norton Utilities

par Microsoft Press

Micro Mémento RapidFile

par Alain Gargadennec et Jean-Michel Jégo

Micro Mémento Lotus 1-2-3 version 2.2

par Jean-Louis Marx
 Achevé d'imprimer sur les presses
de Cox and Wyman Ltd (Angleterre)
 4"
kclA^‘- -Ç i
z
3 6'Zij
4 O- & fàjC

S SX/ ^As >>

OCC Z X'S »»" "

A jn. 00i
Cbn v bt<rS C«-L S C C 2* to x 1L
J 0 oi î4x Vr
C(rP> S ok OV<$ 1 ?o r- lî*
S> f 4 (, i
'P 4 oc 31/0
l 0 i t«xe 6 > 2o>
; < \
/ 2,0^ t 100,1*1 z lùi IM ïfl X b tt
i 02
\ w / 23 XO 15
( 0 ?
1 0 c/ 31 XÛ
10 5 41 >0
i 0 ip i?9 xo

10l S/X
1P c b 1/6
toi b-y 6 -*>
Zuh W-l
1“ s 12 x'tZ't
20 6 (SkiS <,j(
le>> tS* <A
ZO ID ii * 32 -2$

M 3o) <5 X1Ç-I?

301 Il Kit-H

ΫS S£z?J
Je ’<t> US rL gs
30 64

Dépôt légal septembre 1990

Nouveau tirage : août 1990
Imprimé en Angleterre
*iO(
*102 zl À ‘S
‘ivi
‘tcÇ
«rcÉ h Z * Ji
So-? KzA,
J f. . > ï rt j ihX
 ôw>C
Fi = & Ht
t
VIO •= 6g -1'3

Hwifcr <= 71 -
ÇM = 75
fjüp -73 1^7 O. ■
imW oi [cJ-£
F< Î^H
Q> ?■<- 'Zc *t
~n
i =• SCJ JS— "Tu< é£c J
4- = 7f
- ?7
lu J - 8Z
PJ c 83
- fj
4 =M
= <.<
Ui-^y/zc-vt — £_

* <=57
*-tW- 8
0<ï-> = y
—t>l - $
M- x K
E7t = ?■?
 MICRO-INFORMATIQUE

GUIDE RAPIDE
"Le Guide Rapide" est un véritable livre d'apprentissage
d'un logiciel, d'un langage ou d'un système d'exploitation.
Il présente toutes les notions nécessaires à sa bonne
utilisation et les principales commandes ou instructions. Le
Guide Rapide ne retient que l'essentiel d'un produit et
permet au lecteur d'être efficace très rapidement sans avoir
à assimiler des notions qui ne lui serviront que très
rarement. Ecrit de manière progressive, il conduit le lecteur
jusqu'à un bon niveau de connaissance.

TURBO PASCAL • BENEDICTE HUDAULT

Turbo Pascal est devenu en quelques années un des lan­
gages de programmation standard. Il est utilisé aussi bien
comme langage d'apprentissage par les étudiants que
comme langage de déve-
loppement en entreprise. Il existe deux autres collections
Les fonctionnalités puis­ Micro-Infor matique
santes de Turbo Pascal,
INITIATION FACILE
sa rapidité de compilation, Collection de prise en main qui
ses outils de développe­ constitue l'entrée dans la
ment performants, la sim­ gamme.
plicité de son interface
utilisateur, son faible en­ MICRO MEMENTO
Destinée à un public voulant
combrement en mémoire
avoir un ouvrage de référence
en font un langage appré­ exhaustif sur un thème, elle joue
cié de tous. donc le rôle de complément des
deux autres collections.
52990.9
ISBN 2-266-03523-1