Utilisation de Turbo Pascal 7.0

Le langage pascal (Turbo en est une extension qui ajoute la programmation orientée objet) est créé à partir de mots en anglais : « begin », « procedure », « function », « end »… Je vous propose d'en apprendre les principaux. Pour commencer, sachez que ce langage ne fait pas la distinction entre les majuscules et les minuscules : « BeGIN », « begin », « BEGIN », « bEgIn » sont tous équivalents. Le retour à la ligne n'est pas obligatoire, seul le point-virgule « ; » l'est pour délimiter les instructions (mais l'éditeur de texte de Turbo Pascal 7.0 demande de ne pas écrire de lignes trop longues tout de même), c'est-à-dire : 

var i: LongInt; begin for i := 0 to 9 do begin WriteLn (i,' ',chr(i)); Writeln (i,'² = ',i*i); end; end.

est accepté… mais illisible à mon goût. Je préfère :

var
  i: LongInt;
begin
  for i := 0 to 9 do begin
    Writeln (i,' ',chr(i));
    Writeln (i,'² = ',i*i);
  end;
end.

Personnellement j'utilise des majuscules, un retour à la ligne après chaque instruction et j'ajoute deux espaces au début de chaque groupe d'instructions. C'est plus agréable à lire et ça facilite la compréhension du programme.

La directive « begin » est la directive-mère d'un programme : tout programme commence par « begin », qui d'ailleurs signifie « commence » en anglais. La directive « end » (fin) est obligatoirement complémentaire de « begin », elle clôt le programme ou la procédure. Voici un exemple (c'est toujours plus parlant) :

procedure Aurevoir;
begin
  Writeln ('Au revoir');
end;

(* ---- Programme principal ---- *)

begin
  Writeln ('Salut toi !');

  Aurevoir;
end.

Téléchargez l'exemple : Salut.pas.

Vous voyez donc que « begin » indique que le code (les instructions) commence et « end » clôt ce code.

La directive « end » est terminée par « ; » (fin d'instruction), sauf pour l'ultime « end », celui qui ferme le programme, qui est suivi d'un point (« end. »).

La seconde partie du texte de l'exemple est le programme principal, ou procédure principale ; elle n'est pas déclarée par une quelconque directive « procedure Principale; ». On la distingue des autres procédures car c'est la dernière procédure du code source et elle se termine par « end. » (et non « end; »).

La première partie du texte est une procédure. Toute procédure est déclarée par la directive « procedure NomProcedure; », où « NomProcedure » est (vous l'avez compris) le nom de la procédure. Il faut ensuite introduire la directive « begin » et ne pas oublier « end; ».

La procédure standard « WriteLn » signifie (dans ce cas) que ce qui suit doit être affiché à l'écran. Enfin, la procédure "Aurevoir;" a été créée par moi-même.

La procédure standard « Write » est l'une des plus utilisées dans Turbo Pascal. Elle permet à la fois d'écrire du texte à l'écran (« Write ('Salut !'); »), d'écrire dans un fichier en mode texte (« Write (F, 'Texte sans importance ...'); ») et d'écrire dans un périphérique défini (écran, fichier ou autre (« Write (Periph, 'Rien du tout'); »). En fait, Turbo Pascal s'occupe de comprendre à quel périphérique est destinée l'information et crée une procédure appropriée : pour l'écran une procédure qui modifie la VRAM, pour les fichiers une procédure qui appelle les procédures DOS. Si on lui ajoute les caractères « Ln », elle va à la ligne suivante après avoir écrit ses données.

Reprenons un exemple :

WriteLn ('Salut toi !');

Les paramètres de la procédure « WriteLn » sont entre parenthèses. Il s'agit ici d'une chaîne de caractères. Les chaînes de caractères sont délimitées par le caractère « ' » (un au début et un à la fin). L'instruction est terminée par le conventionnel point-virgule. Les paramètres peuvent être de tout type : une chaîne de caractères, un caractère, un nombre, une variable, etc. En voici quelques exemples :

var
  txt: String;
  i: Byte;
begin
  WriteLn ('Haypo !');     { Ecrit une chaîne de caractères }
  WriteLn (10);            { Ecrit le nombre 10 }
  WriteLn ('dix = ',10);   { Mélange de chaîne de caractères et de nombre }
  txt := 'Haypo Power !!!';
  WriteLn (txt);           { Ecrit le contenu de la variable "txt" }
  i := 123;
  WriteLn (i);             { Ecrit le contenu de la variable "i" }
end.

Téléchargez l'exemple : WriteLn.Pas.

Tiens, voici de nouveaux mots : « var », « string » et « byte ». Ho ! Des « {«  et des « } » !

Explications : « var » introduit les variables. Une variable est un petit morceau de mémoire où l'on peut stocker un certain type de données. Justement, « string » et « byte » sont deux types de données : « string » est une chaîne de caractères et « byte » est un octet (un nombre positif ayant une valeur entre 0 et 255). Les caractères « { » et « } » délimitent des commentaires.

Les commentaires sont des textes qui ne sont pas interprétés lors de la compilation du code source ; ils sont simplement ignorés. Ils sont vitaux pour la compréhension du code source : par exemple, le nom de la variable « NbrOctetLigne » n'est pas très clair, alors que si on ajoute le commentaire « { Nombre d'octets par ligne de l'écran vidéo } », tout est plus clair.

Merci à genthial pour ses corrections.