CODINGCLASSEURS WEKA ★ Comment exploiter toutes les ressources et augmenter les performances de votre AMSTRAD CPC ★

4/4.3 Les mots réservés de Turbo PASCAL (!)|1er Complément)Coding Classeurs Weka

4/4.3 Les mots réservés de Turbo PASCAL

Dans 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>
FonctionOpé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 falsefalse 
 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
FonctionDé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.

UtilisationLa 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;

FonctionPermet 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. 

FonctionMarque la fin d'un bloc d'instructions qui avait commencé par l'instruction « begin ».
UtilisationUn 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> ; 

FonctionPermet 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;

UtilisationL'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; 

Fonctionpermet 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
Formatfunction < 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
Formatgoto < etiquette >; 
FonctionPermet 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
Formatinline (ccode hexadécimal sur 8 ou 16 bits> / ); 
FonctionPermet 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).

UtilisationSi 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 
FormatIf < 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.

UtilisationUtilisez 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 
Formatif < element > in < ensemble > then < action1 > else < action2 >;
FonctionTeste 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>.
Formatlabel < etiquette >. 
FonctionLa 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 > 
FonctionDonne le reste d'une division entière.
UtilisationChaque fois que le reste d'une division entre deux entiers devra être entier, il faudra utiliser l'instruction « mod ».

 not 
Formatnot < Opérateur booléen ou entier > 
FonctionOpé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;

 

 
Formatoverlay 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 ».

UtilisationReportez-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 :

orfalsetrue
falsefalsetrue
truetruetrue

 

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
Formatprogram ; 
FonctionDéfinit un début de programme en lui donnant un nom. La déclaration de début de programme sera suivie des blocs suivants :
  1. étiquettes,
  2. constantes,
  3. types,
  4. variables,
  5. procédures et fonctions,
  6. programme principal.
UtilisationL'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; 
FonctionDé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.
UtilisationCe 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 >; 

FonctionPermet 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 ».
UtilisationL'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 > ;

FonctionDéfinit un type ensemble. Un ensemble est une collection d'objets (appelés membres ou éléments) de même nature.
UtilisationDé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 >
FonctionRéalise un décalage à gauche de n positions de l'argument < entier2 >. Le nombre de décalages à faire est donné dans < entier1 >. 
UtilisationCette 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 > 
FonctionRéalise un décalage à droite de n positions de l'argument < entier2>. Le nombre de décalages à faire est donné dans .
UtilisationCette 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 > ]; 
FonctionDé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. 
UtilisationPour 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
Formattype
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 :

  1. étiquettes,
  2. constantes,
  3. types,
  4. variables,
  5. procédures et fonctions,
  6. 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
Formatvar 
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 :

  1. étiquettes,
  2. constantes,
  3. types,
  4. variables,
  5. procédures et fonctions,
  6. programme principal. 
UtilisationChaque 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
Formatwhile do
(* une ou plusieurs instructions *)
end; 
FonctionPermet 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; 

FonctionPour é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 :

xorfalsetrue
falsefalsetrue
truetruefalse

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;

 

Page précédente : 4/4.2 La programmation structurée en PASCAL (1er Complément)

CPCrulez[Content Management System] v8.7-desktop/cache
Page créée en 123 millisecondes et consultée 457 fois

L'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.