4/4.3 Les mots réservés de Turbo PASCALDans cette partie, nous allons examiner succinctement la fonction de chaque mot réservé de Turbo PASCAL. Ces mots ne pourront en aucun cas être redéfinis par l'utilisateur. Nous allons étudier les mots-clés suivants : abs, and, array, begin, case, const, div, do, downto, else, end, externat, file, forward, for, function, goto, inline, if, in, label, mod, nil, not, overlay, of, or, packed, procédure, program, record, repeat, set, shl, shr, string, then, type, to, until, var, while, with, xor. abs | Format | < Entier 1 > : = abs( < Entier2 > ) ou < Reel1 > : = abs() | | Fonction | Donne la valeur absolue de l'argument fourni. Le résultat est du même type que la valeur soumise. | | Utilisation | Cette fonction est utilisée à chaque fois qu'un calcul doit faire abstraction des valeurs négatives qui pourraient lui être fournies. Exemple : Permet d'éviter des erreurs d'exécution sur des fonctions, ou plus généralement sur des calculs qui n'acceptent que des nombres positifs comme argument. |
and | Format | < Expression 1 > and < Expression2> | | Fonction | Opérateur booléen (deux valeurs : True et False). Réalise un ET logique entre les deux expressions fournies, selon la table de vérité ci-après :
| and | false | true | | false | false | false | | true | false | true |
Cette fonction logique peut être étendue à chaque bit d'un nombre entier de la manière suivante :  | | Utilisation | L'opérateur « and » peut être utilisé avec toutes les fonctions booléennes du Pascal, soit pour réaliser des affectations, soit pour tester la validité de deux opérations simultanément. Exemple : Pour tester la simultanéité de deux conditions booléennes, on fera :
If Condition_1 and Condition_2 then Action; |
array | Format | : array [< dimension >] of ; | | Fonction | Le mot-clé « array » est utilisé pour : — déclarer un tableau, — définir sa ou ses dimensions, — définir le type de ses éléments. | | Utilisation | La déclaration des tableaux doit se faire dans la section « var ». Le type des éléments du tableau peut être un type prédéfini (integer, string, etc.) ou un type défini par l'utilisateur à la section type. |
begin | Format | begin | | Fonction | Déclare le début d'une section. | | Utilisation | Cet ordre est obligatoirement utilisé en début de programme, de procédure ou de fonction. |
case | Format | case < valeur1 > : Action1 ; < valeur2 > : Action2; < valeurn > : Actionn; end; | | Fonction | Test multiple sur un opérateur du type : Si < opérateur> = < Valeur1 > alors faire < Action1> sinon si < opérateur > = < Valeur2 > alors faire < Action2 > etc. sinon si < opérateur > = < Valeurn > alors faire < Actionn > | | Utilisation | Cette fonction est à utiliser à chaque fois qu'un test porte sur trois ou plus de trois valeurs. |
const | Format | const | | Fonction | Dans l'en-tête d'un programme (avant le premier begin), cette instruction signifie que les instructions qui vont suivre permettront de déclarer des constantes. | | Utilisation | La déclaration des constantes est à faire après la déclaration des étiquettes (label) et avant la déclaration des types (type) |
div | Format | < Entierl > div | | Fonction | Donne le quotient de la division entière de deux nombres entiers. | | Utilisation | Dans tous les cas où le résultat d'une division devra être entier, il faudra utiliser l'ordre « div ». |
do | Format | for < variable >:= to < valeur2 > do begin ( * une ou plusieurs instruction(s) * ) end ; ou for : = downto do begin ( * une ou plusieurs instructiob (s) * ) end; | | Fonction | Permet d'exécuter plusieurs fois une ou plusieurs instructions. La première forme (for to do) est utilisée si < valeur2 > est supérieure à < valeur1 >. La deuxième forme (for downto do) est utilisée dans le cas contraire. | | Utilisation | Cette instruction de répétition est à utiliser à chaque fois que le nombre de répétitions est connu par avance. On utilisera plutôt l'instruction « while » ou l'instruction « repeat » dans le cas contraire. |
downto Voir l'instruction do else Voir l'instruction if end | Format | end end; ou end. | | Fonction | Marque la fin d'un bloc d'instructions qui avait commencé par l'instruction « begin ». | | Utilisation | Un point virgule est obligatoire derrière chaque instruction end sauf pour la dernière du programme qui doit être suivie d'un point. |
external | Format | Procédure ; external < Adresse d'implantation> ; | | Fonction | Permet de faire référence à une procédure dont le code objet est défini à l'extérieur du programme. | | Utilisation | Une procédure définie en externe s'appelle comme une autre procédure. Souvent, on utilise le concept de procédure externe pour insérer des sous-programmes écrits en Assembleur dans un programme en Pascal. Des paramètres peuvent être passés à une procédure ou une fonction externe par l'intermédiaire de la pile. Nous étudierons prochainement le fonctionnement (appel, implantation, création, etc.) des procédures et fonctions externes, et la manière de leur passer ou de récupérer des valeurs (passage de paramètres, acquisition du résultat des fonctions, etc.). |
file | Format | < nom de type> = file of ; | | Fonction | Définit un type fichier. Utilisé dans la déclaration des types, cet ordre permet de définir la structure d'un fichier : type
annuaire = file of record
Nom : string[15];
Prénom : string[15];
Adresse : string[80];
Téléphoné: string[ 11];
end;Utilisé dans la déclaration des variables, il permet de définir un ou plusieurs fichier(s) du type défini dans la déclaration des types. Exemple :
var
annuaire1 : annuaire;
annuaire2 : annuaire; | | Utilisation | L'ordre « file of » permet d'accéder facilement à des données simples ou complexes (définies par un ordre « file of record »). |
forward | Format | function < nom > (Var: < declarations > ) : < type >; forward; ou procédure < nom > (Var: < déclarations > ); forward; | | Fonction | permet de déclarer l'en-tête d'une fonction ou d'une procédure à part, et plus haut que la définition de la fonction ou de la procédure elle-même. | | Utilisation | |
for Voir l'ordre « do ». function | Format | function < nom > (Var: < déclarations > ) : < type >; | | Fonction | Permet de définir une suite d'instructions destinées à effectuer un certain nombre de calculs, et à renvoyer une valeur dans une variable. Les instructions de calcul qui composent une fonction doivent être encadrées par les ordres « begin » et « end;». | | Utilisation | Les fonctions sont des entités comparables aux procédures dans le sens où ce sont des sous-programmes indépendants qui possèdent leurs propres déclarations de types, variables, etc. La différence entre procédure et fonction est la suivante : — une procédure est un sous-programme qui effectue une ou plusieurs actions, pas forcément dans le but de fournir le résultat d'un calcul ; — une fonction est une procédure dont le but est de calculer une valeur. Cette valeur est passée au programme qui a activé la fonction et rangée dans une variable. La valeur renvoyée peut être de type simple (real, string, etc.) ou d'un type plus complexe défini, par exemple, par l'utilisateur. |
goto | Format | goto < etiquette >; | | Fonction | Permet de dérouter l'exécution séquentielle du programme en l'orientant vers une étiquette déclarée dans l'en-tête du programme dans la partie de déclaration des labels. | | Utilisation | Cette instruction sera utilisée le moins souvent possible, car elle va à rencontre du concept de structure qu'impose le Pascal. Si vous désirez cependant l'employer, il vous faut savoir que son action se limite à un déplacement dans la même « unité de programme » : c'est-à-dire que l'on ne pourra pas accéder à un label qui se trouve en dehors de la procédure ou du programme où l'ordre goto est écrit. |
inline | Format | inline (ccode hexadécimal sur 8 ou 16 bits> / ); | | Fonction | Permet d'insérer des instructions en code machine directement dans le programme source. Deux codes hexa. doivent être séparés par un slash ( / ), et l'ensemble des codes hexa. encadré par des parenthèses ouvrantes et fermantes. Les codes peuvent être : — déclarés en clair par des valeurs hexadécimales, — des constantes entières, — des variables entières, — des identificateurs de procédures ou de fonctions, (dans ce cas, c'est l'adresse d'implantation de la procédure ou de la fonction qui est codée). | | Utilisation | Si l'exécution n'est pas assez rapide en Turbo PASCAL pour une procédure particulière (par exemple, une procédure de tri ou de calcul répétitif), vous pourrez vous servir de l'ordre « inline » pour insérer un sous-programme en langage machine. |
if | Format | If < condition > then < action 1 > else < action2 > où < action 1 > et < action2 > peuvent être composées d'une ou plusieurs instructions. | | Fonction | Exécute une ou plusieurs instruction(s) si une condition est réalisée, et une ou plusieurs autres instructions dans le cas contraire. | | Utilisation | Utilisez cette instruction pour tous les tests simples. Il vaudra mieux utiliser une instruction « case » que plusieurs instructions « if » consécutives pour des raisons de vitesse d'exécution et de clarté du programme écrit. |
in | Format | if < element > in < ensemble > then < action1 > else < action2 >; | | Fonction | Teste l'appartenance d'< element > à < ensemble >. | | Utilisation | Reportez-vous à l'ordre « set of » pour voir ce qu'est un ensemble et comment le déclarer. L'ordre « in » ne s'emploie que sur les structures d'ensembles. L'élément testé doit être du même type que les éléments de l'ensemble. Le résultat est vrai si l'élément fait partie de l'ensemble, ou faux dans le cas contraire. |
label < etiquette>. | Format | label < etiquette >. | | Fonction | La section « label » est la première à être indiquée après la déclaration du nom du programme. Les labels (ou étiquettes) sont des noms alphanumériques qui peuvent commencer par une lettre ou par un chiffre, et qui se terminent par le caractère « : ». Les labels sont utilisés par les instructions « goto ». Si vous tentez d'utiliser un débranchement par goto à une étiquette non définie dans la section des « label », une erreur se produira à la compilation. | | Utilisation | La section label est très peu utilisée puisqu'elle est directement liée à l'ordre « goto » qui est lui-même très peu utilisé. |
mod | Format | < Entier1 > mod < Entier2 > | | Fonction | Donne le reste d'une division entière. | | Utilisation | Chaque fois que le reste d'une division entre deux entiers devra être entier, il faudra utiliser l'instruction « mod ». |
not | Format | not < Opérateur booléen ou entier > | | Fonction | Opérateur booléen (deux valeurs: True et False). Inverse la valeur logique de l'expression fournie : si l'expression est vraie (True), « not expression » sera faux (False) ; inversement, si l'expression est fausse (False), « not expression » sera vraie (True). | | Utilisation | Cette fonction logique peut être étendue à chaque bit d'un nombre entier de la manière suivante : not 0 = - 1 not 10 = - 11 not -103 = 102 not $1234 = -4661 (= $EDCB) Cet opérateur peut être utilisé avec toutes les fonctions booléennes du Pascal, soit pour réaliser des affectations, soit pour tester l'inverse du résultat fourni par la fonction. Par exemple, pour tester la non-appartenance d'un élément à un ensemble, on fera :
If Not (Element in Ensemble) then Action; |
| Format | overlay procédure ;
begin
(* description de la procédure *)
end;ou overlay function < Nom > : < type >;
begin
(* description de la procédure *)
end; | | Fonction | Permet de déclarer une procédure ou une fonction en « overlay » (recouvrement, en français). Le principe de l'overlay est le suivant : une zone en mémoire RAM, appelée zone d'overlay, est réservée pour charger des sous-programmes (procédures ou fonctions) indépendants qui ne sont pas nécessaires en permanence pour exécuter le programme principal. Il peut y avoir plusieurs sous-programmes déclarés en overlay (et c'est là tout son intérêt), mais un seul est en mémoire en même temps. Il en résulte qu'un programme dont le code machine dépasse la capacité mémoire de l'AMSTRAD peut quand même être exécuté en utilisant ce procédé.
 | | Utilisation | Nous vous recommandons d'utiliser le procédé d'Overlay uniquement quand cela est nécessaire, c'est-à-dire quand le code généré dépasse la capacité mémoire de l'AMSTRAD, car la technique d'Overlay a la fâcheuse propriété de ralentir grandement la vitesse d'exécution sur les systèmes à lecteur de disquettes comme l'AMSTRAD : à chaque chargement d'un nouveau sous-programme d'Overlay, il y a un accès disque... |
of | Format | < nom > = array [1..20] of < type >;
case < variable > of
end;< variable > = set of ;
< variable > = file of ; | | Fonction | L'ordre « of » n'est jamais utilisé seul. On le rencontre dans la zone de déclaration « var », et dans l'instruction de test multiple « case ». | | Utilisation | Reportez-vous aux ordres array, case, set et file pour avoir des détails sur l'utilisation de l'ordre of. |
or | Format | | | Fonction | Opérateur booléen (deux valeurs : True et False). Réalise un OU logique entre les deux expressions fournies, selon la table de vérité ci-dessous :| or | false | true | | false | false | true | | true | true | true |
Cette fonction logique peut être étendue à chaque bit d'un nombre entier de la manière suivante :
124 ($7C) 0 1 1 1 1 1 0 0
or
15 ($F) 0 0 0 0 1 1 1 1
127 ($7F) 0 1 1 1 1 1 1 1 $1234 0 0 0 1 0 0 1 0 0 0 1 1 0 1 0 0 or $2111 0 0 1 0 0 0 0 1 0 0 0 1 0 0 0 1 $3335 0 0 1 1 0 0 1 1 0 0 1 1 0 1 0 1 | | Utilisation | Cet opérateur peut être utilisé avec toutes les fonctions booléennes du Pascal, soit pour réaliser des affectations, soit pour tester simultanément la validité de deux opérations. Par exemple, pour tester la validité d'au moins une condition booléenne sur deux, on fera : If Condition_1 or Condition_2 then Action; |
packed Cette fonction n'existe pas en Turbo PASCAL. De même, les ordres Pack et Unpack du PASCAL standard ne sont pas implémentés. Le compactage des tableaux est automatiquement fait par le Turbo PASCAL quand cela est possible. procédure | Format | procédure < nom > (* éventuellement description de variables locales ou globales *); begin
(* description de la procédure *)
end; | | Fonction | Permet de déclarer une procédure avec ses données locales et/ou globales. L'ordre « begin » doit suivre la déclaration et l'ordre « end; » doit terminer la description de la procédure. | | Utilisation | Si vous suivez les consignes données au chapitre 1/4 de la partie 4 sur la programmation structurée, vous serez amené(e) à diviser le problème que vous vous proposez de résoudre en sous-problèmes. Chaque sous-problème fera l'objet d'une procédure ou d'une fonction, selon le type d'action qu'il doit accomplir. La différence entre procédure et fonction est la suivante : - une procédure est un sous-programme qui effectue une ou plusieurs actions,
- une fonction est une procédure dont le but est de calculer une valeur. Cette valeur est passée au programme qui a activé la fonction et est rangée dans une variable. La valeur renvoyée peut être d'un type simple (real, string, etc.) ou d'un type plus complexe défini, par exemple, par l'utilisateur.
|
program | Format | program ; | | Fonction | Définit un début de programme en lui donnant un nom. La déclaration de début de programme sera suivie des blocs suivants :- étiquettes,
- constantes,
- types,
- variables,
- procédures et fonctions,
- programme principal.
| | Utilisation | L'ordre Program, bien que n'ayant aucune signification particulière est conseillé au début de chaque programme écrit en Turbo PASCAL. |
record | Format | < nom > = record (* description de la structure du fichier #) end; | | Fonction | Définit la structure d'un fichier. Cette déclaration doit être faite dans la déclaration des types. Le type record ainsi défini pourra être affecté à une variable dans la partie déclaration des variables. | | Utilisation | Ce type de données sera utilisé à chaque fois que plusieurs données concernant le même sujet devront être rassemblées pour être accédées directement. Par exemple, on pourra déclarer un fichier qui contient le nom, l'adresse et le téléphone de nos amis de la façon suivante : type
Renseignements_ami = record
Nom : string[20];
Prénom : string[20];
Adresse : string[20];
Téléphoné: string[ 11 ];
end; var
ami : Renseignements_ami; |
repeat | Format | repeat
(* une ou plusieurs instructions *)
until < condition >; | | Fonction | Permet de répéter une ou plusieurs instructions jusqu'à ce qu'une condition doit réalisée. Cette instruction de répétition est à rapprocher des instructions « while » et « for ». | | Utilisation | L'instruction « for » sera utilisée à chaque fois que le nombre de répétitions est connu par avance. On utilisera plutôt l'instruction « while » quand la répétition doit être faite jusqu'à ce qu'une condition soit fausse et « repeat » quand la répétition doit être faite jusqu'à ce qu'une condition soit vraie. |
set | Format | = set of ctype simple sauf real > ; | | Fonction | Définit un type ensemble. Un ensemble est une collection d'objets (appelés membres ou éléments) de même nature. | | Utilisation | Définit un type ensemble. Un ensemble est une collection d'objets (appelés membres ou éléments) de même nature. La structure d'ensemble peut être très utile à chaque fois que vous voulez manipuler des données d'un même type dont le nombre est restreint. Des opérateurs spécifiques aux ensembles peuvent être utilisés : * Intersection d'ensembles.
+ Union d'ensembles.
— Différence d'ensembles.
= Test d'égalité entre deux ensembles.
>= Test d'inclusion : Vrai si le deuxième ensemble est inclus dans le premier.
<= Test d'inclusion : Vrai si le premier ensemble est inclus dans le second.
IN Test d'appartenance d'un élément à un ensemble. Vrai si l'élément appartient à l'ensemble. |
shl | Format | < entier1 > shl < entier2 > | | Fonction | Réalise un décalage à gauche de n positions de l'argument < entier2 >. Le nombre de décalages à faire est donné dans < entier1 >. | | Utilisation | Cette fonction permet de simuler la fonction de décalage SLA A de l'Assembleur. Elle est cependant plus étendue puisqu'elle permet de travailler sur des opérateurs de 16 bits (- 32768 à 32767). |
shr | Format | < entier1> shr < entier2 > | | Fonction | Réalise un décalage à droite de n positions de l'argument < entier2>. Le nombre de décalages à faire est donné dans . | | Utilisation | Cette fonction permet de simuler la fonction de décalage SRA A de l'Assembleur. Elle est cependant plus étendue puisqu'elle permet de travailler sur des opérateurs de 16 bits (- 32768 à 32767). |
string | Format | < Nom de type > = string [< dimension > ]; | | Fonction | Définit un type chaîne alphanumérique. Ce type a beaucoup de similitudes avec le type array, à ceci près que chaque élément d'un type string est un caractère, et que le nombre de caractères d'une variable de type string peut varier dynamiquement. | | Utilisation | Pour avoir plus de renseignements au sujet des chaînes de type string, voir les instructions Concat, Copy, Delete, Insert, Length, Pos, Str et Val qui sont réservées aux manipulations de variables de type string. |
then Reportez-vous à l'instruction « if » type | Format | type | | Fonction | Turbo PASCAL possède des types de données prédéfinis (real, string, char, integer, etc.). Cependant, de nouveaux types peuvent être définis par l'utilisateur dans le bloc « type » qui est le troisième défini après le début de progamme. La déclaration de début de programme peut être suivie des blocs suivants : - étiquettes,
- constantes,
- types,
- variables,
- procédures et fonctions,
- programme principal.
| | Utilisation | Chaque fois qu'une variable sera d'un type non prédéfini dans Turbo PASCAL, il faudra déclarer son type dans le bloc réservé aux déclarations de type. |
to Reportez-vous à l'ordre « do » until Reportez-vous à l'ordre « repeat » var | Format | var | | Fonction | Bloc destiné à la déclaration de toutes les variables qui seront utilisées dans le corps du programme. La déclaration de début de programme peut être suivie des blocs suivants : - étiquettes,
- constantes,
- types,
- variables,
- procédures et fonctions,
- programme principal.
| | Utilisation | Chaque variable utilisée dans un programme écrit en Turbo PASCAL doit obligatoirement avoir été déclarée précédemment, sans quoi, une erreur se produira à la compilation. |
while | Format | while do
(* une ou plusieurs instructions *)
end; | | Fonction | Permet de répéter une ou plusieurs instructions tant qu'une condition est réalisée. Cette instruction de répétition est à rapprocher des instructions « repeat » et « for ». | | Utilisation | L'instruction « for » sera utilisée à chaque fois que le nombre de répétitions est connu par avance. On utilisera plutôt l'instruction « while » quand la répétition doit être faite jusqu'à ce qu'une condition soit fausse et « repeat » quand la répétition doit être faite juqu'à ce qu'une condition soit vraie. |
with | Format | with < variable d'enregistrement >
do (* traitement *)
end; | | Fonction | Pour éviter de compliquer les notations relatives à l'accès des éléments contenus dans des enregistrements (records), l'instruction with permet d'accéder à une variable sans dire à chaque utilisation à quel enregistrement elle appartient. | | Utilisation | Considérons les enregistrements suivants : type
personne = record
nom : string[20];
prénom : string[20];
adresse : string[80];
téléphoné: string[ 11 ];
end; travail = record
désignation_poste : string[60];
entreprise : string[20];
salaire : integer;
end; candidat = record
individu : personne;
experience : travail;
end; var
embauche : candidat; Pour accéder au salaire d'un des candidats, il faudra taper : embauche.candidat, salaire Cette forme est difficile à manipuler car très lourde. L'instruction with pourra faciliter les choses de la façon suivante : with embauche do
with candidat do
salaire:= ;
end;
end; Si les manipulations d'articles sont nombreuses, on aura intérêt à utiliser « with » le plus souvent possible, car la lisibilité d'un programme qui emploie « with » est très supérieure. |
xor | Format | < Expression 1 > xor < Expression2 > | | Fonction | Opérateur booléen (deux valeurs : True et False). Réalise un OU EXCLUSIF logique entre les deux expressions fournies, selon la table de vérité ci-dessous :| xor | false | true | | false | false | true | | true | true | false |
Cette fonction logique peut être étendue à chaque bit d'un nombre entier de la manière suivante : 124 ($7C) 0 1 1 1 1 1 0 0
xor
15 ($F) 0 0 0 0 1 1 1 1
=
115 ($73) 0 1 1 1 0 0 1 1$1234 0 0 0 1 0 0 1 0 0 0 1 1 0 1 0 0
xor
$2111 0 0 1 0 0 0 0 1 0 0 0 1 0 0 0 1
=
$3325 0 0 1 1 0 0 1 1 0 0 1 0 0 1 0 1 | | Utilisation | Cet opérateur peut être utilisé avec toutes les fonctions booléennes du Pascal, soit pour réaliser des affectations, soit pour tester la validité exclusive de deux opérations. Par exemple, pour tester la non-simultanéité de deux conditions booléennes, on fera : If Condition_1 xor Condition_2 then Action; |
CPCrulez[Content Management System] v8.7-desktop/c
Page créée en 529 millisecondes et consultée 1253 foisL'Amstrad CPC est une machine 8 bits à base d'un Z80 à 4MHz. Le premier de la gamme fut le CPC 464 en 1984, équipé d'un lecteur de cassettes intégré il se plaçait en concurrent du Commodore C64 beaucoup plus compliqué à utiliser et plus cher. Ce fut un réel succès et sorti cette même années le CPC 664 équipé d'un lecteur de disquettes trois pouces intégré. Sa vie fut de courte durée puisqu'en 1985 il fut remplacé par le CPC 6128 qui était plus compact, plus soigné et surtout qui avait 128Ko de RAM au lieu de 64Ko. |
|
