CyBWarrior

Lorsque quelqu’un se lance dans la programmation, le choix de son premier langage est déterminant.
En général, c’est soit le Basic, soit le Pascal.

Le Pascal (nommé ainsi en hommage au grand scientifique et néanmois croyant Blaise Pascal (1623 – 1662)
qui fut l’inventeur de la machine à calculer) est un langage largement dépassé et surpassé par
des langages comme le C/C++ ou le tout nouveau Java.

Pourtant, son emploi reste largement répandu, principalement dans l’enseignement. En effet, le
Pascal est un des premiers langages à offrir une approche de la programmation structurée.

De plus, Borland à décider d’abandonner la vente de ce logiciel. Il est maintenant totalement
gratuit et on peut le trouver et le télécharger sur leur site.

Le Pascal permet aussi d’inclure ou pas certaines fonctions, selon qu’elles soient utilisées ou
non par le programme, un peu à la manière du C++ avec les directives #INCLUDE.

Ce langage permet aussi de compiler les programmes écrit et ainsi de créer des fichiers EXE autonomnes
et parfaitement fiables.

Le Pascal permet aussi d’inclure des passages de code en langage d’assemblage, de façon beaucoup
plus simple qu’en QBasic.

Et puis le Pascal posséde un pannel de fonctions très attractives regroupées sous le nom de Turbo
Vision. Turbo Vision permet de créer facilement des applications DOS ayant un physique acceptable,
c’est à dire avec des menus déroulants, des fenêtres, des barres d’états, de l’aide en ligne etc…

Bien sûr, on peut maintenant faire la même chose beaucoup plus simplement sous Windows avec Delphi
ou Visual Basic…

D’ailleurs des applications très récentes et énormement utilisées ont été écrite en Turbo Pascal.
Je pense nottament à NASM, un excellent assembleur, et à son environnement de développement NASM-IDE.

Etant dans le logiciel libre jusqu’à la mort, les auteurs de cette application proposent même
carrement le code source. Très instructif.

La version de Turbo Pascal que j’utilise est la dernière, c’est la 7. Vu que c’est Borland
himself qui la fourni, je pense qu’il n’y aura pas de problèmes de compatibilité entre les différents
compilateurs existant.

Au premier abord, Turbo Pascal peut paraître plus compliqué que le Basic. En effet, alors que
ce dernier ne nécessite pas une déclaration des variables, le Turbo Pascal en réclamme une.

En Turbo Pascal, il faut aussi se familliariser avec l’emploi du ; (point-virgule),
comme en C++.

Il vous faudra aussi écrire de multiples fois begin et end.

Mais malgrès ces petits détails, je pense qu’il vaut mieux pour un débutant de commencer par
le Turbo Pascal, plutôt que par le Basic. Pourquoi ? Parceque si jamais vous passez à la programmation
Windows, vous verrez que Delphi qui utilise ce même langage est beaucoup plus puissant que son
homologue Visual Basic.

Télecharger Turbo Pascal

Avant de commencer votre premier programme, il faut savoir qu’en Turbo Pascal, un programme posséde
un squelette. Et c’est sur cette ossature que vont se fixer les instructions de votre programme.
Ce squelette, le voici :

begin

end.

Ici déjà, vous pouvez executer le programme en cliquant sur Run dans le menu Run.
Evidemment, rien ne va se passer. Mais il n’y aurra pas d’erreurs, ce qui est déjà pas mal. Car
si vous jamais vous aviez omis c’est deux petites lignes, au malheur! Essayez si vous voulez…

Maintenant, il serait chic de donner un nom à notre programme. Pour cela, on va le rajouter à la
suite de ce que l’on appelle un identificateur. Ici, c’est program. Vu que notre
programme va s’appeler Ecrire, nous allons écrire :

program Ecrire;

begin
end.

À ce stade là, il nous faut préciser que le Turbo Pascal n’est pas case sensitive (sensible
à la casse (majuscules, minuscules) des caractères) comme peut l’être un langage comme C++.

Ensuite, ce qui est placé après program n’est pas pris en compte lors de la compilation
du programme. C’est en fait une information purement informative pour le programmeur, au cas où
il ne sache plus sur quoi il travaille

Ensuite, nous allons écrire notre texte. Pour écrire, nous allons utiliser la procédure (c’est
le nom exacte) write :

program Ecrire;

begin

  write(’Salut! Je suis un Warrior!’);

end.

Certainement n’avez vous pas eu le temps de voir ce qu’il c’était passer. Pour revoir l’écran
précédent, il vous faut cliquer dans le menu Debug, puis sur User Screen.

Entre apostrophes, c’est la chaîne de caractères a afficher. Les parenthèses quand à elles
sont communes à toutes les instructions. En Pascal c’est comme ça.

N’oubliez pas non plus le point-virgule à la fin de la ligne (comme après program).
En Pascal, il faut qu’il soit à la fin de chaque ligne, sauf exceptions que nous préciserons.
En Pascal c’est comme ça.

Petite parenthèse pour les Basicmans : les chaînes de caractères sont à placer entre apostrophes et
non entre guillemets. Je sais que cela peut paraître étrange au début, puisque l’apostrophe représente
les commentaires en Basic. Mais…en Pascal c’est comme ça…

Maintenant, imaginez que l’on est voulu faire la même, mais en anglais. Ça donnerait :
Hello! I’m a Warrior!. Vous remarquez qu’il y a un apostrophe dans la chaîne de caractères
à afficher. Si on l’utilise tel quel, une erreur se produira. Il faudra donc doubler cet apostrophe,
comme le montre le programme suivant :

program Ecrire;

begin

  write(’Hello! I »am a Warrior!’);

end.

Cependant, write n’inclue pas le saut de ligne et le retour chariot. C’est à dire
que le curseur est toujours après le point d’exclammation. Si on ré-utilise write,
le texte sera écrit bêtement à la suite :

program Ecrire;

begin

  write(’Hello! I »am a Warrior!’);

  write(’Salut! Je suis un Warrior!’);

end.

C’est pourquoi il faudra utiliser une instruction plus ou moins dérivée de write :
writeln (avec ln comme line). Là, la mise à la ligne sera effectué :

program Ecrire;

begin

  writeln(’Hello! I »am a Warrior!’);

  writeln(’Salut! Je suis un Warrior!’);

end.

Petits calculs

Mais on peut aussi utiliser les instructions write et writeln pour afficher
le résultat de petits calculs. Il suffit pour cela d’écrire l’opération dans les parenthèses,
mais sans les apostrophes. Voici un exemple qui calcule la somme de 15 et 9 :

begin

  write(’15 + 9 =’);

  write(15 + 9);

end.

Pour simplifier le tout, on pourrait regrouper le tout en une seul ligne, on prenant soin de bien
séparer les deux termes (‘15 + 9 =’ et 15 + 9) par une virgule :

begin

  write(’15 + 9 =’, 15 + 9);

end.

Comme dans n’importe quel langage informatique digne de ce nom, les mathèmatiques tiennent une part
importante. Il existe d’innombrables fonctions mathématiques en Turbo Pascal et ces pourquoi nous
nous limiterons pour l’instant aux 4 opérations rudimentaires que sont l’addition, la soustraction,
la multiplication et la division. Les « symboles » utilisés sont les même que dans pratiquement tous
les langages :

Récapitulatif des opérateurs arithmétiques

Opérateur	Fonction	Exemple de code	Résultat
+	Addition	write(3 + 4);	7
-	Soustraction	write(7 – 4);	3
*	Multiplication	write(4 * 5);	20
/	Division	write(63 / 9);	7

Bien entendu, Turbo Pascal applique les rêgles élementaires des mathématiques, c’est à dire que
dans une opération, la multiplication et la division sont prioritaires à l’addition et à la soustraction,
ce qui explique pourquoi les deux programmes suivant ne donnent pas le même résultat :

begin

  writeln(’Calcul de 5 + 5 * 3 : ‘);

  writeln(5 + 5 * 3);

end.

Le résultat sera 20.

Par contre, sur le listing suivant, on a adopté une stratégie différente avec des parenthèses :

begin

  writeln(’Calcul de (5 + 5) * 3 : ‘);

  writeln((5 + 5) * 3);

end.

Ici, le résultat sera 30.

Comme dans tout langage de programmation, le Turbo Pascal permet l’utilisation de commentaires
dans le programme, afin de permettre au programmeur de pouvoir se retrouver.

Il existe 2 façons d’inclure des commentaires dans le code :

• { Ceci est un commentaire } : avec des accolades


• (* Ceci est un autre commentaire *) : avec une parenthèse et une étoile

Tout le texte écrit à l’intérieur d’un commentaire est totalement ignoré lors de la compilation
du programme. On peut donc écrire ce que l’on veut :

begin

  { Ceci est un commentaire, et je peux écrire ce que je veux }

end.

Un commentaire peut tout a fait se constituer de plusieurs lignes :

begin

  { Ceci est

  un commentaire

  tellement long

  qu’il faut six

  lignes pour

  pouvoir l’écrire }

end.

Une petite restriction tout de même : le signe dollar ($) ne doit jamais commencer un
commentaire, sous peine d’être confondu avec une directive de compilation.

1. Déclaration des variables
2. Les types de variables
3. L’opérateur d’affectation

Une variable permet de stocker des données dans la mémoire de l’ordinateur, en vu d’une utilisation
ultérieure dans le programme.

Le Turbo Pascal tend à simplifier l’accès à la mémoire. Au lieu d’avoir à gérer un segment et
un offset, on donne tout simplement un nom assez explicite à la variable.

Toute fois, quelques rêgles sont à observer :

• Pas de caractère spéciaux ou accentués


• Pas d’espaces, ni de points


• Pas plus de 127 caractères (c’est déjà pas mal !)


• Pas de chiffres en première position


• Une variable ne peut pas prendre le nom d’une instruction existante

Voici quelques exemple de noms de variables valides :

Count

Heure1

Anticonstitutionnellement

Et voici des noms à proscrire

IF

Yéééééééhé

11h30mn54s

Déclaration des variables

Contrairement au Basic, le Turbo Pascal nécessite une déclaration préalable de toute variable
avant son utilisation. Cela impose d’avoir une certaine rigueur dans son programme.

La déclaration ne se fait pas n’importe comment, ni n’importe où.

Mais quoiqu’il arrive, il faut toujours utiliser le mot-clef var.

Ensuite, à la ligne ou à la suite, viennent les variables, puis le double-point (:) et enfin
leur types (sans oublier le point-virgule à la fin !).

On n’obtient donc la syntaxe suivante :

var Nom : Type;

Pour l’instant, nous n’allons pas compliquer la chose et toute nos variables seront déclarées
tout au début du programme, avant begin…end. :

var Count : integer;      { La variable ‘Count’ est du type Integer }

begin

end.

Laissez integer de coté pour le moment. Bien entendu, on peut utiliser plusieurs
variables dans un programme. Deux alternatives se proposent. Soit on réécrit le mot-clef var :

var Count : integer;     { 1er variable }

var ItsGood : boolean;   { 2ème variable }

begin

end.

Ou alors on utilise une seul fois var :

var Count : integer;     { 1er variable }

    ItsGood : boolean;   { 2ème variable }

begin

end.

Les types de variables

En Turbo Pascal, le type de la variable doit obligatoirement être spécifié.

Un type, qu’est ce que c’est ? En fait, le type de la variable est choisi en fonction
du type de données qu’elle va recevoir.

Par exemple, une variable peut acceuillir du texte, des nombres décimaux, entiers, d’un certain
nombre de bits…

C’est donc à vous de choisir le bon type, selon les travaux que vous voulez effectuer. Pour cela,
il faut vous referer au tableau suivant :

TYPES DE VARIABLES

Type	Déscription	Fourchette	Exemples	Mémoire requise
Shortint	Entiers courts	-128 à 127	-125; 0; 32	1 octet
Integer	Entiers « normaux »	-32 768 à 32 767	-30 000; 421;	2 octets
Longint	Entiers longs	-2147483648 à 2147489647	-12 545 454; 3 257	4 octets
Byte	Entiers sur 1 Bit (Byte ou Octet)	0 à 255	12; 157	1 octet
Word	Entiers sur 2 Bits (Word ou Mot)	0 à 65 535	27; 4 589	2 octets
Real	Nombres réels	2.9E-39 à 1.7E38	3.1415; 789.457851	6 octets
Single	Nombres décimaux (simple précision)	1.5E-45 à 3.4E38	3.1415926; 178 925.455678	4 octets
Double	Nombres décimaux (double précision)	5E-324 à 1.7E308	54.5899; 9 897 669 651.45568959	8 octets
Extended	Nombres réel	3.4E-4932 à 1.1E4932	3.14159265458; 9.81	10 octets
Comp	Entier	-9.2E18 à 9.2E18	-271; 6 548	8 octets
Boolean	Boolean sur 1 octet	false ou true	false; true	1 octet
Wordbool	Boolean sur 1 mot	false ou true	false; true	2 octets
Longbool	Boolean sur 1 Double-Mot	false ou true	false; true	4 octets
Bytebool	Boolean sur 1 octet	false ou true	false; true	1 octet
String	Chaîne de caractères	256 caractères maximum	‘Hello!’; ‘Allez-vous bien ?’	256 octets
String[n]	Chaîne de n caractères	n caractères maximum	String[6]->’Hello!’	n octets
Char	1 caractère	1 caractère maximum	‘R’	1 octet

Mais pourquoi tant de type, alors que le Basic n’en posséde que quatre ? À mon avis, c’est certainement
parce qu’au départ, le Pascal été prévu pour une utilsation scientifique.

D’ailleurs, ce tableau est loin d’être complet. En effet, il existe bien d’autres types, mais
il ne sont accessibles que par l’intermediaire d’une unité.

L’opérateur d’affectation

Pour affecter une valeur à une variable, on utilise le double point, suivi du signe égual (:=) :

var Nombre : integer; { Variable ‘Nombre’ du type entier }

begin

  Nombre := 5;  { On affecte 5 à la variable ‘Nombre’ }

  Nombre := Nombre + 1; { On ajoute 1 }

  Nombre := Nombre * Nombre; { Au carré }

  write(Nombre); { sortie : 36 }

end.

Pour les chaînes de caractères, on peut faire pareil :

var Debut : string;   { 4 variables chaînes de caractères }

    Millieu : string;

    Fin : string;

    Phrase : string;

begin

  Debut := ‘Hello ! ‘;

  Millieu := ‘Je suis un Warrior ‘;

  Fin := ‘et j »apprends le Turbo Pascal’; { Remarquez le double apostrophe }

  Phrase := Debut + Millieu + Fin; { « Concaténation » des 3 morceaux }

  write(Phrase);

end.

En Turbo Pascal, une chaîne de caractère est stockée dans un tableau. Comme nous n’avons
pas encore vu de quoi il s’agit, nous ferons vite :

var MaChaine : string;

begin

  MaChaine := ‘Warrior’;

  writeln(MaChaine[1]); { Sortie : ‘W’}

  writeln(MaChaine[2]); { Sortie : ‘a’}

  writeln(MaChaine[3]); { Sortie : ‘r’}

  writeln(MaChaine[4]); { Sortie : ‘r’}

  writeln(MaChaine[5]); { Sortie : ‘i’}

  writeln(MaChaine[6]); { Sortie : ‘o’}

  writeln(MaChaine[7]); { Sortie : ‘r’}

end.

Le contraire, si on peut appeler ça ainsi, d’une variable se nomme une constante. Par définition,
une constante est un élement qui ne variera pas.

Par exemple, pour des calculs de mécanique ou scientifiques, on peut avoir besoin d’utiliser la
gravité. En principe, on utilise 9.81.
Nous allons donc définir une constante que nous appelerons Gravite.

La déclaration ce fait à l’aide du mot-clef const et avant les déclarations de variables :

program CalculMasse;

const Gravite = 9.81;       { Définition de la constante ‘Gravite’ }
var Poids : Real;           { Deux variables }

    Masse : Real;
begin

  Masse := 50;              { 50 kg }

  Poids := Masse * Gravite; { P = M * G }

  write(’Le poids d »un corps ayant une masse de 50 kg est de ‘, Poids, ‘ Newtons.’);

end.

Remarquez qu’ici, on utilise pas l’opérateur d’affectation (:=) vu précedement, mais
simplement le égual (=).
Une constante peut aussi être du type texte, comme le montre l’exemple suivant :

const Pays = ‘France’;

begin

  write(Pays);

end.

Contrairement aux variables, il n’est nullement besoin de spécifier le type de la constante. On
peut tout de même le faire, en utilisant le double points, comme pour les variables. Il ne faut
cependant pas oublier d’affecter la valeur :

program CalculMasse;

const Gravite : Real = 9.81;  { Définition de la constante ‘Gravite’

 et de son type (Real) }
var Poids : Real;             { Deux variables }

    Masse : Real;
begin

  Masse := 50;                { 50 kg }

  Poids := Masse * Gravite;   { P = M * G }

  write(’Le poids d »un corps ayant une masse de 50 kg est de ‘, Poids, ‘ Newtons.’);

end.

Afin de nous simplifier un travail compliqué, nous allons écrire un petit programme qui nous
permetra de calculer facilement le champ magnétique d’un solénoïde (une bobine électrique). La
formule à utiliser est la suivante :

B = μ0 • N • I

         l

μ0 est une constante qui représente la perméabilité du vide. Sa valeur est 4π • 10^-7.
I représente l’intensité en ampères (A), l la longueur du solénoïde en mètres (m) et
N le nombre de spires. B représente le champ magnétique, exprimé en teslas (T).

Peu importe si le mot électricité vous donne de l’urticaire. C’est juste un exemple. Passons maintenant
à la réalisation de notre programme.

Nous n’allons pas nous compliquer la vie : nos variables et constantes porteront le même nom que
dans la formule. μ se dit mu.

On peut donc déjà écrire :

program Champ;

const mu : Real = pi * 4E-7; { perméabilité du vide }
var B : Real;                { Champ magnetique }

    N : Integer;             { Nb de spires, forcement entier }

    I : Real;                { Intensité }

    l : Real;                { longueur }
begin

  writeln(’*** Calcul du champ magnétique d »un solénoïde ***’);

  writeln;

  B := (mu * N * I) / l;

  write(’Le champ magnétique est de ‘, B, ‘ Teslas.’);

end.

Maintenant, il va faloir que l’ordinateur pose des questions à l’utilisateur du programme pour
que ce dernier puisse entrer en possession des données qui lui sont inconnues (N,
I et l).

L’instruction (ou plutôt la procédure) a utiliser est read. read va suspendre
l’execution du programme jusqu’à ce que l’utilisateur entre une information et appuie sur la
touche Entrée. L’information est stockée dans la variable passée en argument. On se retrouve
avec un programme semblable :

program Champ;

const mu : Real = pi * 4E-7; { perméabilité du vide }
var B : Real;                { Champ magnetique }

    N : Integer;             { Nb de spires, forcement entier }

    I : Real;                { Intensité }

    l : Real;                { longueur }
begin

  writeln(’*** Calcul du champ magnétique d »un solénoïde ***’);

  writeln;

  write(’Nombre de spires du solénoide : ‘);

  read(N);                   { Nombre de spires ? }

  write(’Longueur, en mètres : ‘);

  read(l);                   { Longueur ? }

  write(’Intensité, en ampères : ‘);

  read(I);                   { Itensité ? }

  B := (mu * N * I) / l;

  write(’Le champ magnétique est de ‘, B, ‘ Teslas.’);

  readln;

end.

read est similaire à write dans la mesure où celui-ci posséde également
un dérivé : readln.

On peut utiliser ReadLn pour suspendre l’execution du programme, comme ici à la fin
pour laisser à l’utilisateur le temps de voire le résultat.

La structure conditionnelle permet d’influer et de piloter le déroulement du programme. Si vous
avez pratiqué le Basic, vous ne serez pas dépaysé, puisque la syntaxe est quasiment la même :

if condition then instruction;

if veut dire SI en anglais, et then, ALORS. En clair, SI la condition
est vraie, ALORS on execute les instructions.

Je pense que vous pouvez prévoir de vous même le résultat du programme suivant :

var Age : Integer;

begin

  write(’Entrez votre age : ‘);

  read(Age);

  if Age > 18 then writeln(’C »est bon, vous êtes majeur.’); { SI Age > 18 ALORS …}

end.

Si la condition n’est pas remplie, on peut executer une autre instruction. Comme en Basic, il
faudra employer else, qui veut dire AUTRE. L’instruction ne sera donc executée que si la
condition n’est pas vrai :

var Age : Integer;

begin

  write(’Entrez votre age : ‘);

  read(Age);

  if Age > 18 then writeln(’C »est bon, vous êtes majeur.’) { SI Age > 18 ALORS …}

  else writeln(’Rentre chez toi, morveux !’);               { SI NON …}

end.

Vous remarquez que le désormais classique point-virgule se trouve maintenant sur la deuxième ligne.

Et si au lieu d’une seule instruction, on en avait plusieurs ? On ne va pas utiliser un if…then…else
par instruction. Cela marcherai, mais ça aurait pour conséquence de ralentir l’execution du programme
de manière affreuse.

On va donc créer un bloc d’instructions, ou plutôt une séquence d’instructions
comme il est écrit dans le fichier d’aide officiel.

Sans le savoir, vous êtes déjà familiarisé avec cette chose, puisqu’il s’agit ni plus, ni moins
du begin…end.

Une séquence d’instruction est considérée comme étant une seule instruction. Cela explique l’utilisation
du point-virgule dans l’exemple suivant :

begin

  begin

    writeln(’Ceci est un bloc d »instruction’);

  end;

end.

On peut comparer le begin…end aux accolades du C++, ou du JavaScript.

Voici un exemple de programme mariant les conditions et les blocs d’instructions :

var Age : Integer;

begin

  write(’Entrez votre age : ‘);

  read(Age);

  if Age > 18 then

  begin                                       { 1er bloc d’instructions }

    writeln(’C »est bon, vous êtes majeur.’);

    writeln(’Vous pouvez rentrer’);

  end                                         { Pas de point virgule }

  else

  begin                                       { 2eme bloc d’instructions }

    writeln(’Rentre chez toi, morveux !’);

    writeln(’Et que je ne te vois plus trainer par ici!’);

  end;                                        { Ici, un point virgule }

end.

En Pascal, il n’y a pas de ELSEIF comme en Basic.

On peut contourner l’obstacle en utilisant un >if…then…else dans le else
de l’instruction précedente et ainsi de suite :

var Age : Integer;

begin

  write(’Entrez votre age : ‘);

  read(Age);

  if Age < 18 then                            { SI Age < 18 ALORS...}

  begin

    writeln('Rentre chez toi, morveux !');

    writeln('Et que je ne te vois plus trainer par ici!');

  end                                         { Pas de point virgule }

  else if Age > 65 then                       { SINON SI Age > 65 ALORS…}

  begin

    writeln(’Vous me semblez bien vieux pour ce genre de choses…’);

    writeln(’Rentrez sagement chez vous’);

  end                                         { Pas de point virgule non plus}

  else                                        { SINON …}

  begin

    writeln(’C »est bon, vous êtes majeur.’);

    writeln(’Vous pouvez rentrer’);

  end;                                        { Ici, un point virgule }

end.

L’utilisation des cas est parfois plus adaptée à certaines situations que la classique structure
conditionnelle avec if…then.

Plutôt qu’un long discours, observez :

program Lescas;

var Couverts : Integer;
begin

  writeln(’Bienvenue au restaurant  »case of »’);

  writeln(’Combien de couverts désirez-vous ?’);

  read(Couverts);
  case Couverts of              { Début du Case Of }

    0 :                         { Premier cas : SI Couverts = 0 }

      writeln(’Vous connaissez la sortie…’);
    1 :                         { Deuxième cas : SI Couverts = 1 }

      writeln(’Une table pour une personne, une !’);
    2 :                         { Troisième cas : SI Couverts = 2 }

      writeln(’Haha! Un dîner en tête à tête ?’);
    7, 13 :                     { Quatrième cas : SI Couverts = 7 OU Couverts = 13 }

      write(’Désolé, ici on est superstiteux ‘);

      writeln(’et on ne sert pas ce nombre de couverts’);
    3..12 :                     { Cinquième cas : SI Couverts => 3 ET Couverts =< 6 }

      writeln('C''est un repas en famille ?');
    else                        { Sixième cas : Tous les autres cas }

      writeln('Très drôle');
   end;                         { Fin de la séléction de cas }

end.

Procédons par ordre :

• 0 :, 1 :, 2 : représentent des cas unitaires : si la variable Couverts
  vaut 0, 1 ou 2, le cas correspondant est traité.


• 7, 13 : correspond à une enumération. Si Couverts à la valeur de
  7 OU 13, le cas est traité.


• 3..12 : est un interval de valeurs. Si la valeur de Couverts est comprise
  dans celui ci, le cas est traité.


• else est executé si aucun des cas spécifiés ne sont traités.

Si vous avez déjà lu le QBasic (du même auteur ), vous constaterez
quelques similitudes dans les deux exemples traitants des cas…

Mais vous remarquerez aussi que la ligne CASE IS > 12 n’a pas d’équivalent en Pascal.

Pour pouvoir solutionner ce problème, il faut utiliser un if…then dans le cas
else :

program Lescas;

var Couverts : Integer;
begin

  writeln(’Bienvenue au restaurant  »case of »’);

  writeln(’Combien de couverts désirez-vous ?’);

  read(Couverts);
  case Couverts of              { Début du Case Of }

    0 :                         { Premier cas : SI Couverts = 0 }

      writeln(’Vous connaissez la sortie…’);
    1 :                         { Deuxième cas : SI Couverts = 1 }

      writeln(’Une table pour une personne, une !’);
    2 :                         { Troisième cas : SI Couverts = 2 }

      writeln(’Haha! Un dîner en tête à tête ?’);
    7, 13 :                     { Quatrième cas : SI Couverts = 7 OU Couverts = 13 }

      write(’Désolé, ici on est superstiteux ‘);

      writeln(’et on ne sert pas ce nombre de couverts’);
    3..12 :                     { Cinquième cas : SI Couverts => 3 ET Couverts =< 6 }

      writeln('C''est un repas en famille ?');
    else                        { Sixième cas : Tous les autres cas }

      if Couverts > 12 then

        writeln(’Mais vous êtes une armée !’)

      else

        writeln(’Très drôle’);

   end;                         { Fin de la séléction de cas }

end.

Bien entendu, on peut aussi utiliser un bloc d’instructions begin…end avec case of

Les instructions peuvent égualement s’écrirent sur la même ligne.

Les deux écritures suivantes du cas 0 sont donc équivalentes :

0 :

begin

  writeln(’Vous connaissez la sortie…’);

end;

ou :

0 : writeln(’Vous connaissez la sortie…’);

1. L’instruction GOTO

Un branchement peut être comparé à un pont. À chaque fois que le programme en rencontre un, il
va faire un pont de ce branchement jusqu’au label qui lui est indiqué.

Un branchement est donc définit par un label. Un label peut être un identificateur de votre choix.
Cependant, sa syntaxe doit répondre au même rêgles que celles énoncées pour les variables.

Le label peut aussi être un numéro (old school, façon Basic).

Tout label doit être déclaré préalablement en tête du programme, juste après program,
à l’aide du mot-clef label. Si il y en à plusieurs, il seront séparés par des virgules.

Dans le programme, le label est toujours suivit des doubles points (:) :

program Branchmt;

label Debut, Milieu, Fin;  { Déclaration de 3 labels. N’oubliez pas le ; }
begin

  Debut:                   { Label Debut }

  writeln(’Ceci est le début du programme’);
  Milieu:                  { Label Milieu }

  writeln(’Ceci est le milieu du programme’);
  Fin:                     { Label Fin }

  writeln(’Ceci est la fin du programme’);

end.

L’instruction GOTO

Maintenant, pour aller à ses labels, il faut utiliser l’instruction goto suivie du label
chosi, comme en Basic (en fait, tout est pareil. La seul chose en plus, c’est la déclaration des
labels).

L’exemple suivant illustre certaines des choses vues précedemment :

program Branchmt;

label Debut, Milieu, Fin;  { Déclaration de 3 labels. N’oubliez pas le ; }
var Ou : Integer;
begin

  writeln(’Où voulez-vous aller ?’);

  writeln(’  1 – Au début’);

  writeln(’  2 – Au milieu’);

  writeln(’  3 – À la fin’);

  read(Ou);
  if Ou = 1 then goto Debut;       { Selon la séléction, on effectue }

  if Ou = 2 then goto Milieu;      { le branchement correspondant }

  if Ou = 3 then goto Fin;
  Debut:                   { Label Debut }

  writeln(’Ceci est le début du programme’);
  Milieu:                  { Label Milieu }

  writeln(’Ceci est le milieu du programme’);
  Fin:                     { Label Fin }

  writeln(’Ceci est la fin du programme’);

end.

On aurait pu améliorer un peu :

program Branchmt;

label Debut, Milieu, Fin, Boucle;
var Ou : Integer;
begin

  writeln(’Où voulez-vous aller ?’);

  writeln(’  1 – Au début’);

  writeln(’  2 – Au milieu’);

  writeln(’  3 – À la fin’);

  Boucle: read(Ou);
  if Ou = 1 then goto Debut

  else if Ou = 2 then goto Milieu

  else if Ou = 3 then goto Fin

  else goto Boucle;                 { Retour au ‘Read’ si aucune

condition n’a été remplie }
  Debut:

  writeln(’Ceci est le début du programme’);
  Milieu:

  writeln(’Ceci est le milieu du programme’);
  Fin:

  writeln(’Ceci est la fin du programme’);

end.