La première partie explique que les déclarations ont pour but de définir des objets manipulés par le programme et d'allouer des casesmémoire (ou réceptacles) pour leur valeur.
Le chapitre précédent montre que les expressions ont pour but de produire une valeur á partir des valeurs courantes d'objets sans modifier ces dernières non compte tenu des effets de bord des fonctions (cfr Ch 12).
Une instruction peut modifier la valeur d'objets.
Les instructions apparaissent dans la partie instruction d'un programme ou dans la partie instruction d'un sousprogramme.
Toute instruction peut être précédée d'au plus une étiquette préalablement déclarée (cfr Ch 1). L'instruction vide est sans effet sur le programme. Elle peut servir dans une phase de mise au point du programme.
Une instruction composée est une séquence d'instructions exécutées dans l'ordre où elles sont écrites.
begin
t:=x;
x:=y;
y:=t
end
La dernière instruction d'une instruction composée ne doit pas être suivie d'un pointvirgule conformément au diagramme syntaxique. Si on écrit :
begin
t:=x;
x:=y;
y:=t;
end
La dernière instruction de l'instruction composée est alors l'instruction vide.
On voit donc que le pointvirgule (;) sert á séparer les instructions dans une suite d'instruction formant une instruction composée : il ne fait pas partie des instructions ellemêmes.
L'instruction appel de procédure est décrite dans le chapitre 11 Les autres instructions sont décrites cidessous.
L'instruction d'affectation est une façon de donner une valeur á une variable.
où accès á variable structurée est défini en
Ch 7.2
et où identificateur de fonction est utilisé dans la partie
instruction de la fonction au sens décrit en
Ch 12
2.2. Règles relatives á l'affectabilité de valeurs aux variables
Soit Tv le type de la variable.
Soit Te le type de l'expression.
Pour que l'instruction d'affectation soit syntaxiquement correcte, il faut que le type Te soit affectable au type
Tv. Pour cela, il faut qu'une des conditions suivantes soit remplie:
Pour que l'instruction d'affectation soit exécutable, il faut qu'elle soit syntaxiquement correcte et que la valeur de l'expression puisse être affectée á la variable en respectant les contraintes exprimées par les types (par exemple : limites exprimées par les bornes d'un intervalle).
const PI = 3.141592 ;
type entier = integer ;
couleur = (bleu,blanc,rouge,jaune) ;
tab = array[18..24] of couleur ;
var x,y : entier ;
a,b : real ;
fanion : couleur ;
dessin, arcenciel : tab ;
begin
x := 3 * 4 + 2 ;
y := x div 5 ;
a := PI / 4 ;
b := - a ;
fanion := rouge ;
arc-en-ciel := dessin ; { si la variable dessin possede une valeur }
...
end.
Lors d'une déclaratione de variable
(cfr Ch 5)
, aucune
valeur n'est attribuée á la variable. L'initialisation d'une
variable est donc toujours nécessaire. Elle peut se faire via
une instruction d'affectation.
2.4. Record á champ variant
(cfr Ch 2.2.2)
Une variable de type record á champ variant est une variable dont la structure est influencée par la valeur que prend un de ses champs. La structure dépend de la valeur affectée á ce champ.
type fiche = record
nom : packed array [1..20] of char;
prenom : char;
case etranger : Boolean of
true : (nationalite : pays);
false : (regimelinguistique : langue)
end;
var personne : fiche;
Si on affecte la valeur vrai au champ etranger de la variable
personne, les champs accessibles de la variable sont :
nom, prenom, etranger, nationalite.
Par contre, si on affecte la valeur faux au champ etranger de la
variable personne, les champs accessibles de la variable sont :
nom, prenom, etranger, regimelinguistique.
type pays = (Belgique, France, Allemagne, Italie);
type langue = (FR, NL, DE);
var p1,p2 : fiche;
begin
....
p1.etranger := true;
p1.nationalite := France;
... {p1.regimelinguistique n'a pas de sens}
p2.nationalite := false;
p2.regimelinguistique := NL;
... {p2.nationalite n'a pas de sens}
{impression de la strucure}
writeln(p1.nom,p1.prenom);
if p1.etranger
then writeln(p1.nationalite)
else writeln(p2.regimelinguistique)
...
end.
L'instruction goto s'écrit
Effet : la prochaine instruction exécutée est celle qui est précédée par l'étiquette spécifiée (cfr Ch 8.1).
Remarques :
Vérification de l'appartenance d'un entier e á un tableau a : array [1..N] of integer, en parcourant séquentiellement le tableau.
trouve := false;
i := 1;
while (i <= n) and not trouve do
if a[i] = e then trouve := true
else i := i + 1;
writeln (trouve);
trouve := false;
for i := 1 to n do
if a[i] = e then
begin
trouve := true;
goto 999
end ;
999: writeln (trouve);
Effet : l'instruction1 est exécutée si la condition expression est vraie; l'instruction2, si elle apparaît, est exécutée si la condition expression est fausse. Il faut que expression soit booléenne.
Remarques :
if a>b
then max := a {un point-virgule place ici est une erreur}
else max := b;
...
if expression1 then if expression2 then instruction1 else instruction2
peut sembler ambiguë en ce sens que rien n'indique si
l'exécution de l'instruction2 est contrôlée par la valeur de
expression1 ou par la valeur de expression2. PASCAL lève
cette ambiguïté en considérant que cette instruction est
équivalente á :
if expression1 then
begin if expression2 then instruction1 else instruction2 end
Donc, l'exécution de instruction2 dépend de la valeur de
expression2. Si l'on veut la faire dépendre de expression1,
alors il est nécessaire d'écrire
if expression1 then begin if expression2 then instruction1 end
else instruction2
expression et constante sont de type T avec T un type simple autre que real.
La même constante ne peut apparaître deux fois dans une instruction case.
Effet : seule l'instruction en regard de l'expression constante est exécutée. Après l'exécution de cette instruction, l'instruction case est terminée : on passe donc á l'instruction suivante.
Le PASCAL standard ne reconnaît pas de cas par défaut (c'estádire une instruction á exécuter si l'expression n'égale aucune des constantes) : cette situation donne lieu á une erreur.
Toutefois, le PASCALUVA accepte la clause otherwise en fin d'instruction case comme instruction par défaut.
Il faut noter l'absence de ":" après le motclé otherwise.
type days = (monday,tuesday,wednesday,thursday,friday,saturday,sunday);
var x : integer ;
jour : days;
...
case jour of
saturday,sunday:
begin
.
.
.
end;
monday: x := x + 1;
tuesday,thursday: ; {instruction vide}
wednesday,friday: begin
.
.
.
end
end {case jour} ;
x := x + 4;
...
case jour of
saturday, sunday: writeln('pas de cours');
wednesday: writeln('cours l''avant-midi');
otherwise writeln('cours toute la journee') {uniquement PASCAL-UVA}
end {case jour};
...
Le langage PASCAL offre trois instructions de répétition : while,
repeat et for.
5.1. Instruction while ... do
expression est une expression booléenne.
Effet : Tant qu'expression a la valeur "vrai", on exécute
l'instruction.
5.2. Intruction repeat ... until
expression est une expression booléenne.
Effet : la suite d'instructions est exécutée, puis tant que
l'expression booléenne est fausse, la suite d'instructions est á
nouveau exécutée (c'estádire jusqu'á ce que expression soit
vraie). L'instruction est donc exécutée au moins une fois.
5.3. Instruction for ... do
Les deux valeurs (valeur initiale et valeur finale) sont deux expressions dont le résultat doit être affectable á la variable. Ce type doit être un type simple, sauf real.
Effet : la valeur initiale et la valeur finale sont calculées une fois pour toute au début de l'instruction for. Ensuite, l'instruction est exécutée pour toutes les valeurs scalaires comprises entre valeur initiale et valeur finale, en ordre croissant (to) ou en ordre décroissant (downto). Dans le premier cas, si la valeur finale est inférieure á la valeur initiale, l'instruction n'est pas exécutée. Dans le second cas, il en est de même si la valeur finale est supérieure á la valeur initiale.
L'instruction with fournit une économie d'écriture en permettant á un utilisateur de ne spécifier qu'une fois le nom de variables de type record (dans l'entête d'instruction) au lieu de les spécifier chaque fois qu'un champ de la structure est utilisé.
Exemple: Les instructions
UneAuto.annee := 1979 ;
UneAuto.couleur := bleu ;
UneAuto.marque := 'DATSUN CHERRY GL ' ;
peuvent être remplacées par
with UneAuto do
begin
annee := 1979 ;
couleur := bleu ;
marque := 'DATSUN CHERRY GL '
end{with UneAuto} ;
Lorsque plusieurs variables sont spécifiéees dans l'entête
d'instruction, l'instruction
with v1, v2, ..., vn do S ;
est équivalente á
with v1 do
with v2 do
...
with vn do S ;
