Section courante

A propos

Section administrative du site

Les premiers pas

Imaginez apprendre à parler une langue avec un dictionnaire comme seule ressource. Chaque mot que vous recherchez est référencé à une douzaine d'autres, et chacun d'eux est référencé à une douzaine d'autres. Au moment où vous recherchez le troisième mot de la chaîne de caractères, le premier mot est réapparu dans le cadre de la définition suivante. Pire encore, chaque nouveau mot que vous découvrez conduit à des ensembles entièrement nouveaux de définitions circulaires.

Si vous n'avez aucune connaissance préalable de la langue, le dictionnaire n'a pratiquement aucune valeur. Vous savez que le langage a du sens, mais vous ne pouvez pas vous empêcher d'être frustré par la complexité de l'entrelacement des significations. (L'apprentissage de l'anglais n'est évidemment pas un processus linéaire avec un point de départ clair.)

Un programme QuickPascal typique

Une loi non écrite semble exiger que tous les textes informatiques commencent par un programme affichant le message «Bonjour!» à l'écran. Dans QuickPascal, vous pouvez écrire un tel programme en une seule ligne :

  1. BEGIN Write('Bonjour!');END.

Le mot BEGIN identifie le début du programme. Le mot END (suivi d'un point) indique la fin du programme. L'unique instruction significative consiste en une procédure Write copiant le message "Bonjour!" à l'écran.

Notez que les guillemets simples identifient les limites du message, tout comme BEGIN et END marquent les limites du programme. En raison des guillemets, le QuickPascal considère les 13 caractères du message comme une seule donnée, tout comme il afficherait les 13 chiffres 1234567890123 comme un seul grand nombre.

Un programme n'est rien de plus qu'un ensemble d'instructions que vous voulez que l'ordinateur exécute. Les programmes QuickPascal sont orientés action (les programmes n'effectuant aucune action valent rarement la peine d'être exécutés). Autrement dit, le QuickPascal est un langage se composant entièrement de phrases impératives.

Style de programme

Bien que les programmes QuickPascal aient à la fois l'apparence et la fonction de phrases impératives, aucun programme réel n'est jamais écrit sur une seule ligne. Dans le programme Bonjour! par exemple, des combinaisons significatives de caractères, de nombres et de symboles (comme les mots BEGIN, END et Write) peuvent être distinguées en tant qu'entités indépendantes car elles sont séparées par des espaces.

En plus de l'espace, un séparateur QuickPascal valide peut consister en une tabulation, un saut de ligne, un saut de page ou un retour chariot - à peu près tous les caractères de mise en forme que vous souhaitez. Le nombre réel de séparateurs n'a pas d'importance, tant que vous en utilisez au moins un. Par conséquent, au lieu d'utiliser un seul espace, vous pouvez insérer des lignes vides, étendre des instructions sur plusieurs lignes, indenter des colonnes avec des tabulations ou des blancs et inclure des sauts de page - le tout sans affecter les performances de vos programmes.

Parce que le message Bonjour! est placé entre guillemets, l'espace qu'il contient est traité comme un autre caractère à afficher, et non comme un séparateur.

L'apparition finale de votre programme est entièrement une question de style et de goût personnels ; aucune disposition particulière n'est meilleure qu'une autre. En règle générale, cependant, vous devez formater votre programme pour améliorer sa clarté globale. Par exemple, puisque BEGIN et END identifient un bloc de code entier, toutes les instructions qu'ils contiennent sont généralement identifiées, comme suit :

  1. BEGIN 
  2.  Write('Bonjour!');
  3. END.

Réorganiser le programme en insérant des sauts de ligne supplémentaires, des retours chariot et des espaces n'aura aucun effet sur la taille ou la vitesse d'exécution du programme compilé. Contrairement à de nombreux autres compilateurs Pascal, le QuickPascal n'impose pas l'utilisation d'un entête de programme. Cependant, vous devez en utiliser un, en commençant chaque programme QuickPascal par une ligne contenant un entête de programme composé du mot-clef PROGRAM, d'un nom de programme et d'un point-virgule.

  1. Program Bonjour;
  2.  
  3. BEGIN 
  4.  Write('Bonjour!');
  5. END.

Si vous savez que vous ne compilerez jamais votre programme sur un autre système, vous pouvez omettre l'entête. Cependant, l'entête aide à documenter le but du programme.

Commentaires

Pour faire avancer la cause d'une bonne documentation, le QuickPascal vous permet d'inclure des commentaires avec le texte source de votre programme. Les commentaires vous permettent d'entreposer des informations, des explications et des rappels simples. Un commentaire est une séquence de caractères que le compilateur ignore complètement. Pour être plus précis, le compilateur traite un commentaire comme si vous aviez écrit un seul espace. Par conséquent, un commentaire comme si vous aviez écrit un seul espace. Par conséquent, un commentaire est un séparateur et peut apparaître partout où un espace serait autorisé. De ce fait, les commentaires n'ont aucun effet sur la taille ou la vitesse d'exécution du programme compilé, même si un seul commentaire peut occuper plusieurs lignes de texte source.

Rédiger des commentaires

Vous pouvez rédiger un commentaire de deux manières. Vous pouvez placer le texte entre accolades, comme dans la syntaxe suivante :

{ Ceci est un commentaire }

ou dans les paires astérisque-parenthèse, comme dans :

(* Ceci est un commentaire *)

Vous pouvez utiliser l'une ou l'autre méthode, mais veillez à ne pas mélanger les symboles - c'est-à-dire, ne placez pas de commentaire entre une accolade à une extrémité et un astérisque et une parenthèse à l'autre. Pour simplifier les choses, on utiliserai désormais des accolades pour les commentaires. Si votre ordinateur dispose d'un moniteur couleur, notez que l'éditeur QuickPascal affiche les commentaires dans une couleur différente du reste du texte. Bien que les commentaires soient souvent importants, l'exemple suivant montre à quel point trop de commentaires peuvent encombrer un programme autrement lisible :

  1. Program Comment; { Un commentaire de programme de démonstration }
  2.  { Le fichier .EXE produit par ce programme est identique en taille et en vitesse
  3. d'exécution à celui produit par le programme Bonjour. }
  4. BEGIN 
  5.  Write('Bonjour!'); { Message de bienvenue }
  6. END.

Dans certains langages de programmation, les commentaires sont essentiels ; des langages comme APL et C sont presque indéchiffrables sans eux. Heureusement, le texte source de Pascal a tendance à être compréhensible par lui-même. Un ou deux commentaires suffisent à la plupart des programmes.

Commentaires d'imbrication

Vous pouvez imbriquer des commentaires - c'est-à-dire que vous pouvez en placer un en utilisant un ensemble différent de symboles de fin. La possibilité d'imbriquer des commentaires est extrêmement utile lors du débogage d'un programme. Par exemple, si le programme problématique est un éditeur de rapports, vous ne voulez pas vraiment que votre imprimante éjecte des pages vierges en continu pendant que vous essayez de découvrir la cause d'une erreur de sous-total. L'imbrication demande au compilateur de contourner plusieurs lignes de code, même si ces lignes contiennent des commentaires. Le compilateur lit les lignes suivantes comme un seul commentaire :

  1. (* Commentez les lignes suivantes
  2. If NewDept <> PriorDept Then Begin
  3.  DoSubTots; { Imprime le sous-totals }
  4.  PageEject; { Routine de saut de page }
  5.  PriorDept := NewDept; { Réinitialise le champ d'arrêt }
  6. Ends;
  7. *)

Une fois que le compilateur a détecté le symbole d'ouverture «(*», il recherche le symbole de fermeture correspondant, «*)», ignorant tout le texte intermédiaire (y compris les accolades).

Directives

Si un commentaire contient un signe dollar ($) comme premier caractère, le compilateur traite le commentaire comme une directive. Une directive est une instruction spéciale indiquant au compilateur comment compiler le programme. Par exemple, {$R+} demande à QuickPascal de compiler le programme avec la vérification d'intervalle activée.

Structures

Même si vous n'avez jamais vu ou entendu parler de QuickPascal, la signification de la procédure Write est assez évidente d'après son contexte - elle place le message Bonjour! à l'écran. Cela peut sembler simple, mais la seule commande Write déclenche en fait une séquence sophistiquée d'activités en coulisses : le message doit être situé dans la mémoire de l'ordinateur, une position d'écran de départ doit être déterminée et le message doit être déplacé vers l'écran un caractère à la fois, chaque caractère déplaçant le curseur sur un espace.

L'instruction Write doit également identifier le message comme une chaîne de caractères (les nombres sont affichés différemment). De plus, la procédure doit déterminer la couleur à utiliser pour l'arrière-plan de l'affichage, la couleur et l'intensité de chaque caractère, et si oui ou non les caractères doivent clignoter.

En fait, la procédure Write est en fait l'une des sous-routines les plus sophistiquées de la bibliothèque QuickPascal. L'instruction Write est appelé un sous-programme car il se compose d'un ensemble complet d'instructions au niveau de la machine, étant toutes exécutées chaque fois que vous invoquez la commande.

Dans QuickPascal, un sous-programme est appelé procédure lorsqu'il exécute un ensemble d'instructions, telles que l'affichage de caractères à l'écran. Une fonction est un sous-programme qui renvoie également une valeur. Voici quelques procédures courantes :

  1. BEGIN
  2.  ClrScr;                { Efface l'écran }
  3.  Write('Bonjour');      { Affiche "Bonjour" à l'écran }
  4.  WriteLn('Bonjour');    { Affiche "Bonjour" à l'écran, alors déplace le curseur vers le début de la ligne suivante }
  5.  ReadLn(x,y,z);         { Entrez les valeurs x, y and z à partir du clavier }
  6. END.

Les lignes suivantes montrent comment vous pouvez utiliser certaines fonctions numériques courantes :

  1. Var
  2.  x,y,z:Real;
  3. BEGIN
  4.  x:=Sqr(4);     { Fixe X au carré de 4 }
  5.  y:=Sqrt(25);   { Fixe X à la racine carré de 25 }
  6.  z:=Abs(-3);    { Fixe Z à la valeur absolue de -3 }
  7. END.

Vous appelez à la fois des procédures (PROCEDURE) et des fonctions (FUNCTION) en indiquant le nom du sous-programme suivi de ses paramètres (le cas échéant) entre parenthèses. Les procédures sont des instructions indépendantes tandis que les fonctions ne peuvent être utilisées que lorsque les constantes du même type (caractères contre nombres, par exemple) sont autorisées.

Pour l'instant, la distinction entre procédures et fonctions n'est pas très importante. N'oubliez pas que chaque fois que vous utilisez le nom d'un sous-programme, le compilateur exécute automatiquement les instructions individuelles que contient le sous-programme.

Mots clefs

Les mots clefs PROGRAM, BEGIN et END appartiennent à une famille de mots, appelés mots-clefs, définissant la structure d'un programme QuickPascal. Dans l'exemple «Bonjour», les mots clefs PROGRAM, BEGIN et END ont servi de marqueurs de limite pour les lignes de code associées PROGRAM ont alerté le compilateur du texte source QuickPascal était les points d'arrivée des déclarations du programme. Le tableau suivant présente la liste complète des mots-clefs QuickPascal :

Nom Description
ABSOLUTE Ce mot réservé permet de fixer l'emplacement d'une variable au même endroit qu'une autre ou à un emplacement mémoire physique absolue.
AND Cet opérateur permet d'effectuer un Et logique sur des booléens ou Et binaire sur des valeurs numériques.
ARRAY Ce mot réservé permet de définir des tableaux avec des valeurs scalaires.
BEGIN Cette instruction permet de définir le début d'un bloc d'instruction.
CASE OF Cette instruction permet de définir le début d'un bloc d'instruction.
CONST Ce mot réservé permet de définir une constante ou de définir une variable avec une valeur constante au lancement du programme.
CSTRING Cet identificateur de type permet de définir une variable ou constantes avec une série d'au plus 255 caractères finissant par un octet nulle (0), comme pour le langage C.
DIV Cet opérateur permet d'effectuer la division entière de nombre entier par un second.
END Ce mot réservé permet de définir la fin d'un bloc d'instruction, d'un enregistrement (RECORD) ou d'une évaluation de cas (CASE OF).
EXTERNAL Ce mot réservé permet d'inclure des sous-programmes externes (n'étant pas compiler avec le QuickPascal).
FILE Ce type d'identificateur permet de définir une variable de format fichier.
FOR Ce mot réservé permet de produire un compteur de boucle.
FORWARD Ce mot réservé permet de définir l'entête d'une procédure et fonction sans définir immédiatement le corps.
FUNCTION Ce mot réservé permet de définir une fonction utilisateur.
GOTO Ce mot réservé permet d'effectuer un branchement à une instruction correspondant à l'emplacement de l'étiquette.
IF Ce mot réservé permet d'effectuer des branchements d'instruction ou de bloc d'instruction en fonction de certaines conditions.
IMPLEMENTATION Ce mot réservé permet de spécifier la zone privé où sont décrits le code de l'unité.
IN Ce mot réservé permet d'indiquer une correspondance avec l'ensemble spécifié.
INLINE Ce mot réservé permet d'inclure directement du code machine en ligne dans le code du compilateur.
INTERFACE Ce mot réservé permet de définir la zone publique et les entêtes dans une unité.
INTERRUPT Ce mot réservé permet de définir une procédure écrite par le compilateur de manière à être appelable en tant qu'interruption.
LABEL Ce mot réservé permet de définir des étiquettes utilisable habituellement par l'instruction «GOTO» ou comme adressage dans le code assembleur.
MOD Cet opérateur permet d'effectuer un Modulo, c'est-à-dire le restant d'une division.
NIL Cette constante permet d'indiquer que le pointeur pointe sur une valeur nulle ou sur rien.
NOT Cet opérateur permet d'effectuer un Non logique sur des booléens ou Non binaire sur des valeurs numériques.
OBJECT Ce mot réservé permet de définir des objets (classe) dans la POO (Programmation Orienté Objet).
OR Cet opérateur permet d'effectuer un Ou logique sur des booléens ou Ou binaire sur des valeurs numériques.
OVERRIDE Ce mot réservé permet de redéfinir une méthode parente provenant d'une opération «New».
PACKED Ce mot réservé permet d'indiquer au compilateur d'utiliser le moins de mémoire possible pour la définition de la structure.
PROCEDURE Ce mot réservé permet de définir une procédure.
PROGRAM Ce mot réservé permet le nom du programme Pascal.
RECORD Ce mot réservé permet de définir des structures d'enregistrement contenu dans des variables.
REPEAT Ce mot réservé permet d'effectuer des boucles d'instructions à répétition tant que la condition n'est pas vraie.
SET Ce mot réservé permet de définir des ensembles.
SHL Cet opérateur permet d'effectuer un décalage de bit vers la gauche.
SHR Cet opérateur permet d'effectuer un décalage de bit vers la droite.
STRING Ce type d'identificateur permet de définir une variable de chaîne de caractères de format String.
TYPE Ce mot réservé permet de définir des types utilisateur.
UNIT Ce mot réservé permet de définir l'entête d'une unité.
USES Ce mot réservé permet d'indiquer les unités devant être utilisé par le programme ou l'unité courante.
VAR Ce mot réservé permet de définir des variables.
WHILE Ce mot réservé permet de produire une boucle exécuté tant et aussi longtemps que la condition est vrai.
WITH Ce mot réservé permet de définir la structure d'enregistrement courante devant être utilisé pour les variables.
XOR Cet opérateur permet d'effectuer un Ou exclusif logique sur des booléens ou Ou exclusif binaire sur des valeurs numériques.

Chaque mot-clef a un objectif spécifique et déclenche une action spécifique. Par exemple, vous ne pouvez utiliser le mot-clef PROGRAM qu'au début du texte source, vous ne pouvez utiliser BEGIN que pour introduire une séquence d'instructions de programme et vous ne pouvez utiliser END que pour terminer une séquence d'instructions. L'utilisation inappropriée d'un mot-clef provoquera inévitablement une erreur de compilation.

Les mots clefs ne doivent pas obligatoirement être écrits en lettres majuscules mais la convention de l'écriture des mots clefs en majuscule est assez commun en QuickPascal. Si votre ordinateur dispose d'un moniteur couleur, vous remarquerez que l'éditeur QuickPascal affiche les mots-clefs dans une couleur différente du reste du texte.

Identificateurs

Un identificateur est un nom (autre qu'un mot-clef) apparaissant dans votre texte source. Un identificateur est utilisé pour désigner le nom du programme lui-même, ainsi que le nom de toute unité, étiquette, constante, variable ou sous-programme que le programme définit ou utilise.

Dans le programme Bonjour, Bonjour était un identificateur pour le nom de l'ensemble du programme, et Write était un identifiant pour une procédure affichant un message à l'écran.

Les règles de nommage des identificateurs QuickPascal sont simples. Un identificateur est un nombre quelconque de caractères valides, constitué en :

La seule restriction à retenir est que vous devez utiliser une lettre ou un trait de soulignement comme premier caractère. L'autre limitation, que QuickPascal ignorera tous sauf les 63 premiers caractères du nom de l'identificateur, est une que vous ne remarquerez probablement jamais.

Compte tenu de ces règles, les identificateurs suivants sont valides :

x
Acct_Num
_InterestRate
_123
One

Les identificateurs suivants sont invalides :

30_day_interest_rate { Il ne faut pas qu'il commence par un chiffre }
File { Ne peut pas être un mot clef }
ItemName$ { Il contient un caractère invalide }

Le dernier exemple est une erreur particulièrement courante commise par les programmeurs BASIC. En BASIC, un signe dollar ($) indique qu'une variable contient une chaîne de caractères. En QuickPascal, rien sur cet identificateur (hormis son nom) n'indique le type d'information qu'il contient. C'est l'une des raisons pour lesquelles Pascal vous encourage à choisir des noms significatifs. Dans un identificateur QuickPascal, la casse d'une lettre importe peu. Ainsi, l'identificateur :

oPeNiNgCustomerBalaNce

Peut ressembler à un message sur une demande de rançon, mais pour le compilateur, il est identique à tout ce qui suit :

OPENINGCUSTOMERBALANCE
OPENINGCustomerBALANCE
openingcustomerbalance

Différents programmeurs utilisent évidemment différentes conventions de nommage pour les identificateurs. Vous pourriez, par exemple, vouloir utiliser toutes les majuscules ou éviter les traits de soulignement - cela n'a pas vraiment d'importance. Ce qui compte, c'est que le style que vous choisissez est le style avec lequel vous devez vivre. Des noms d'identificateurs QuickPascal bien choisis peuvent ajouter considérablement à la clarté de votre programme.

L'organisation d'un programme QuickPascal

Un programme informatique se compose généralement d'informations (données) et d'instructions (code) manipulant les données. Dans QuickPascal, les données et le code sont écrits dans des zones bien définies du texte source. Le format général d'un programme QuickPascal est le suivant :

PROGRAM Declaration

USES Declarations

Declarations_d_etiquettes
Declaration_de_constantes
Declaration_de_variables

Declarations_de_sous_routine

BEGIN
{ Instructions de code }
END.

Les instructions de code et toutes les déclarations sont facultatives. Seuls les deux mots clefs BEGIN et END (y compris le point final) doivent être présents dans chaque programme.

La déclaration du programme

La déclaration de programme (également appelée entête de programme) se compose du mot-clef PROGRAM, du nom du programme et d'un point-virgule. Un nom de programme est un identificateur ; par conséquent, il peut consister en n'importe quelle combinaison valide de lettres, de chiffres et de traits de soulignement. Les exemples suivants sont des entêtes de programme valides :

PROGRAM Affiche_Le_Cheque_De_Paye;
PROGRAM Calcul_1990_Avant_Tax;
PROGRAM Calcul_Trajectoire_A_Intercepter_Jupiter

Un nom de programme a plus généralement une relation avec le nom du fichier DOS où réside le texte source. Un nom de programme significatif peut constituer une excellente documentation sur la fonction ou l'emplacement d'entreposage d'un programme. Par conséquent, un programme nommé SPRDSHET est susceptible d'être entreposé dans le fichier SPRDHET.PAS. Vous avez vu plus haut qu'un programme n'a pas besoin d'entête pour s'exécuter dans QuickPascal. Cependant, un entête augmente la portabilité de vos programmes, car de nombreux compilateurs Pascal nécessitent un entête et éventuellement les noms de tous les fichiers externes référencés par le programme.

L'instruction USES

Chaque sous-programme réside dans l'une des unités suivantes : Crt, DOS, Graph, MSGraph, Printer ou System. Chaque unité n'est rien de plus qu'un fichier entreposant des collections utiles de données et de code prédéfinis.

Les sous-programmes de l'unité SYSTEM sont automatiquement disponibles pour votre programme. C'est le cas de la procédure Write que nous avons utiliser dans les exemples Bonjour.

Observez maintenant la procédure ClrScr. La procédure ClrScr agit comme la commande CLS dans DOS ou CLS dans GWBASIC, effaçant l'écran et déplaçant le curseur vers le coin supérieur gauche. Supposons que vous souhaitiez utiliser la procédure pour effacer l'écran avant d'afficher votre message. Étant donné que ClrScr réside dans l'unité Crt, vous devez indiquer au compilateur d'utiliser l'unité Crt en plus de l'unité SYSTEM. Pour ce faire, utilisez le mot-clef USES, comme suit :

  1. Program SimpleBonjour;
  2.  
  3. Uses Crt;
  4.  
  5. BEGIN
  6.  ClrScr;
  7.  Write('Bonjour');
  8. END.

Notez comment un point-virgule est utilisé pour séparer l'instruction ClrScr de l'instruction Write. Chaque unité ne doit être répertoriée qu'une seule fois, quel que soit le nombre de ses sous-programmes apparaissant dans le programme. Vous ne devez utiliser qu'une seule instruction USES dans un programme ; si plusieurs unités sont requises, utilisez des virgules pour séparer chaque nom d'unité, comme suit :

  1. Uses Crt,Dos,Printer;

L'identificateur d'unité final doit être suivi d'un point-virgule. Placez toujours l'instruction USES immédiatement après la déclaration du programme.

Déclarations de données

En pratique, les données sont bien plus qu'un ensemble de simples nombres et chaînes de messages. Un élément de données est tout identificateur étant consulté, lu, modifié ou autrement manipulé par le programme. Les éléments de données sont, en bref, les informations dont un programme a besoin pour s'exécuter avec succès.

Vous spécifiez ces informations avec les déclarations suivantes :

Le QuickPascal vous permet de déclarer des étiquettes, des constantes, des types et des variables dans n'importe quel ordre, tant que chaque identificateur est déclaré avant d'être utilisé. De plus, vous pouvez répéter l'une d'entre elles autant de fois que vous le souhaitez.

Déclarations d'étiquettes (LABEL)

Toute instruction de code QuickPascal peut commencer par un identificateur, appelé étiquette (LABEL), suivi de deux points. Une étiquette est analogue à un numéro de ligne dans un programme BASIC - elle sert uniquement de référence et n'a aucun effet sur l'exécution de l'instruction elle-même. Vous pouvez utiliser des étiquettes pour améliorer la documentation du programme, comme suit :

  1. AfficheAvertissement:  Write('Etes-vous certains ?');
  2. AccepteLaReponse:      ReadLn(Reponse);
  3. TestPourEgalite:       If Reponse = 'O'Then EffaceFichier;

Les étiquettes sont plus couramment utilisées avec les instructions GOTO pour transférer le contrôle du flux d'un programme. Par exemple, en exécutant l'instruction :

  1. Goto RoutineErreur;

fait sauter le programme à la ligne commençant par l'étiquette nommée RoutineErreur.

Comme tous les identificateurs, les étiquettes (LABEL) doivent être déclarés avant de pouvoir être utilisés. Vous déclarez les étiquettes avec le mot-clef LABEL, suivi d'une liste des identificateurs. Vous pouvez déclarer plusieurs étiquettes sur la même ligne en séparant chaque identificateurs. Vous pouvez déclarer plusieurs étiquettes sur la même ligne en séparant chaque identifiant par une virgule. Le dernier nom de l'étiquette doit être suivi d'un point-virgule.

Dans le programme suivant, l'étiquette nommée Ennuyeux est utilisée avec une instruction GOTO pour créer une boucle infinie. Si vous exécutez le programme, le message "Bonjour" sera affiché en continu jusqu'à ce que vous appuyiez sur Ctrl+Break.

  1. Program BonjourXfois;
  2. Label Ennuyeux;
  3. BEGIN
  4. Ennuyeux: Write('Bonjour!');
  5.  Goto Ennuyeux;
  6. END.

(L'espace après le point d'exclamation empêche les messages de se croiser). Une étiquette peut être déclarée soit un identificateur standard, tel que TakeRoot, soit un entier non négatif compris entre 0 et 9999, tel que 444. Cependant, des constructions telles que 4Front et 30WeightOil, n'étant ni des identificateurs valides ni des entiers valides, généreront des erreurs de compilation.

Parce que les étiquettes sont normalement utilisées avec les instructions GOTO, et parce que les instructions GOTO violent les principes de la programmation structurée.

Déclarations de variables

Une variable est une donnée dont la valeur peut changer au cours de l'exécution du programme. Toutes les variables sont déclarées dans une section du programme commençant par le mot-clef VAR. Chaque variable individuelle est écrite sous la forme d'un identifiant suivi de deux points (:), du type de la variable et d'un point-virgule.

Une variable peut être déclarée comme étant de n'importe quel type standard ou défini par l'utilisateur. Le compilateur réserve un espace d'entreposage pour une variable bien que sa valeur initiale ne soit pas définie.

Le type d'une variable Pascal définit comment peut être la donnée devant être réservée, l'intervalle de valeurs pouvant être affectée et les opérations pouvant être effectuées.

Les types de données suivants sont généralement utilisés dans les programmes :

Voici quelques déclarations de variables typiques :

  1. Var
  2.  QuantiteEnMain:Integer;    { Nombres entiers }
  3.  PrixDeVenteUnitaire:Real;  { Nombres décimaux }
  4.  NomArticle:String;         { Nom alphanumérique }
  5.  CodeCategorie:Char;        { Caractère unique }
  6.  TaxeDeVenteRequis:Boolean; { Seulement TRUE ou FALSE }

Dans le programme suivant, le message d'accueil «Bonjour» est affecté à une variable nommée Message, ayant a été déclarée en tant que STRING :

  1. Program BonjourVar;
  2.  
  3. Var
  4.  Message:String;
  5.  
  6. BEGIN
  7.  Message:='Bonjour';
  8.  Write(Message);
  9. END.

Déclarations de type

Comme vous l'avez vu, QuickPascal fournit une grande variété de types de données standard intégrés pour gérer des éléments de données aussi divers que des nombres, des chaînes de caractères alphanumériques et des conditions (si votre programme utilise uniquement ces types standard, aucune section de déclaration de type n'est requise). Parfois, cependant, vous pouvez avoir besoin de structures de données plus complexes (telles que des enregistrements, des ensembles et des tableaux). La section de déclaration de type est utilisée pour déclarer les types de données et les structures appropriés définis par l'utilisateur.

Une section de déclaration de type commence par le mot-clef TYPE (=), une description du type et un point-virgule. Dans le programme suivant, la variable Message est déclarée d'un type appelé DisplayFormat, lui-même déclaré comme nom de type STRING[13] :

  1. Program BonjourType;
  2. Type
  3.  DisplayFormat = String[13];
  4.  
  5. Var
  6.  Message:DisplayFormat; { Une chaîne de caractères }
  7.  
  8. BEGIN
  9.  Message:='Bonjour';
  10.  Write(Message);
  11. END.

Déclarations constantes

Une constante est un identificateur étant déclaré avec une valeur initiale. Toutes les constantes sont déclarées dans une section du programme commençant par le mot-clef CONST. Chaque constante individuelle est déclarée avec un identificateur, un signe égal (=), la valeur à affecter et un point-virgule. Comme les constantes sont si souvent utilisées pour définir les caractéristiques clefs des programmes, la plupart des programmeurs placent des déclarations de constantes en haut de leurs programmes. Les constantes suivantes conservent leurs valeurs tout au long de l'exécution du programme.

  1. Const
  2.  Title='Comment faire bouillir de l''eau';
  3.  PointBouillir=212;
  4.  CoutDuLivreDeCuisine=19.95;
  5.  VeritableAffaire=False;

Lorsqu'une constante est utilisée dans un programme, le compilateur agit comme si la ligne avait été écrite avec la valeur elle-même. Dans le programme suivant, le message affiché à l'écran avec la procédure Write est identique au contenu de la constante Message :

  1. Program ToujoursB;
  2. Const
  3.  Message = 'Bonjour';
  4.  
  5. BEGIN
  6.  Write(Message);
  7. END.

Constantes de types

Dans les premières versions de Pascal, une constante était un identificateur représentant une valeur unique, spécifique et immuable. Le but principal d'une constante, cependant, est de définir un identificateur possédant une valeur initiale. Les constantes typées (portant parfois le nom malheureux de constantes variables) sont des identificateurs déclarés avec une valeur initiale, mais que vous pouvez utiliser comme variables tout au long du programme. En d'autres termes, une constante typée n'est rien de plus qu'une variable avec une valeur initiale.

Chaque constante typée est écrite sous la forme d'un identificateur, d'un deux-points, d'un type de données, d'un signe égal, d'une valeur initiale et d'un point-virgule.

Voici les déclarations de trois constantes typées :

  1. Const
  2.  MilesAerien:Integer=2456;
  3.  Destination:String='Sept-Iles';
  4.  CoutTotal:Real=452.77;

La valeur de MilesAerien, Destination, CoutTotal peut tous être modifié si nécessaire plus tard dans le programme. Il faut bien comprendre que la valeur est une constante au démarrage d'un programme et qu'elle devient variable (modifiable) durant l'exécution du programme.

Expressions constantes

Les valeurs constantes initiales sont fréquemment interdépendantes. Si, par exemple, la valeur initiale d'une constante dépend entièrement d'autres valeurs que vous avez précédemment affectées, vous pouvez déclarer la valeur initiale une expression constante, comme suit :

  1. Const
  2.  LargeurDuBureau=72;
  3.  ProfondeurDuBureau=36;
  4.  HauteurDuBureau=30;
  5.  EcritRegion=LargeurDuBureau*ProfondeurDuBureau;
  6.  PoucesCubique=EcritRegion*HauteurDuBureau;
  7.  PiedCubique=PoucesCubique/(12*12*12);

Ici, QuickPascal calcule les valeurs initiales de EcritRegion, PoucesCubique et PiedCubique. Les calculs ne sont effectués qu'une seule fois, lors de la compilation d'origine. Étant donné que tous les identificateurs doivent être déclarés avant de pouvoir être utilisés, tous les identificateurs doivent être déclarés avant de pouvoir être utilisés, tous les identificateurs apparaissant doivent avoir été déclarés au moment où l'expression est rencontrée. Cela signifie que les expressions constantes peuvent référencer d'autres constantes, mais les références à des variables ou à des constantes de types sont illégales car leurs valeurs ne seront définies qu'une fois le programme exécuté. L'utilisation de la plupart des opérateurs arithmétiques est autorisée, mais l'opérateur d'adresse (discuté plus loin) ne peut pas être utilisé. De plus, une expression constante peut utiliser l'une des fonctions suivantes :

Fonctions Description
ABS Cette fonction retourne la valeur absolue d'une expression numérique.
CHR Cette fonction permet de retourner le caractère correspondant au code ASCII numérique.
FIRST Cette fonction permet de retourner la première valeur d'un type de données ordinales, pouvant être un type prédéfini, une sous-intervalle ou un type énuméré défini par l'utilisateur.
HI Cette fonction permet de demander la partie haute de l'entier (physiquement le deuxième octet de l'entier).
LAST Cette fonction permet de retourner la dernière valeur d'un type de données ordinales, pouvant être un type prédéfini, une sous-intervalle ou un type énuméré défini par l'utilisateur.
LENGTH Cette fonction permet d'indiquer la longueur d'une chaîne de caractères de format standard Pascal.
LO Cette fonction permet de demander la partie base de l'entier (physiquement le premier octet de l'entier).
ODD Cette fonction indique si la valeur entière est un nombre impair.
ORD Cette fonction permet de connaître le rang de la valeur scalaire, par exemple on peut connaître le numéro de code ASCII d'un caractère de cette manière.
PRED Cette fonction permet de retourner la valeur précédente de l'expression.
PTR Cette fonction retourne un pointeur à partir de l'adresse combiné du Segment et le déplacement (Offset).
ROUND Cette fonction retourne la valeur arrondie d'un nombre réel.
SIZEOF Ce mot réservé permet de connaître la taille en octet d'une variable ou d'un type.
SUCC Cette fonction permet de retourner la valeur suivante de l'expression.
SWAP Cette fonction permet de retourner l'inversion des octets de poids fort et faible.
TRUNC Cette fonction retourne la partie entière d'un nombre réel.

Déclarations de sous-programmes

Lorsque les procédures et fonctions standard intégrées de QuickPascal sont inadéquates pour le travail, vous pouvez définir un sous-programme personnalisé au moyen d'une déclaration de procédure ou de fonction. Vous pouvez ensuite appeler le nouveau sous-programme de la même manière que vous invoquez les routines standard.

Dans l'exemple suivant, la procédure SalutionEclaire contient le code réel pour afficher un message. Le message s'affiche lorsque SalutionEclaire est appelé dans le corps principal du programme :

  1. Program BonjProc;
  2.  
  3. Procedure SalutionEclaire;Begin
  4.  Write('Bonjour');
  5. End;
  6.  
  7. BEGIN
  8.  SalutionEclaire;
  9. END.

Instructions de code de programme

Le code du programme se compose d'instructions orientées vers l'action étape par étape que le compilateur traduira en instructions finales au niveau de la machine.

Les instructions de code, ainsi que les mots-clefs BEGIN et END les entourant, sont collectivement appelés un bloc. Chaque fois que plusieurs déclarations entre elles, sont collectivement appelées un bloc. Chaque fois que plusieurs instructions apparaissent dans le même bloc, vous devez séparer les instructions apparaissant dans le même bloc, vous devez les séparer les unes des autres par des points-virgules. Parce que chaque point-virgule est généralement placé à la fin d'une ligne, le point-virgule n'a pas de sens syntaxique dans l'instruction :

  1. Continent:='Antarctique';

Au lieu de cela, il alerte simplement le compilateur qu'une autre instruction peut suivre. Puisque le compilateur ignore un point-virgule à la fin de la dernière ligne du bloc (la ligne avant le mot-clef END), la plupart des programmeurs Pascal terminent généralement chaque instruction par un point-virgule. (Ceci est très différent de C, où un point-virgule doit terminer chaque instruction.)

La déclaration d'affectation

Une instruction d'affectation remplace par une nouvelle valeur la valeur courante d'une variable ou d'une constante typée. L'identificateur de la valeur à modifier est indiqué en premier, suivi de l'opérateur d'affectation (:=) et de la nouvelle valeur. Ainsi, la déclaration :

  1. x := Y + 5;

est lu «la valeur actuelle de x est remplacée par la valeur de y plus 5.»

Le QuickPascal est un langage fortement typé. C'est une façon élégante de dire qu'il existe des règles strictes pour quel type de données peut être affecté à quel type d'identifiant. Par exemple, un typage fort est affecté à quel type d'identificateur. Par exemple, un typage fort est ce qui vous empêche d'affecter la chaîne de caractères 'Bonjour' à une variable déclarée comme un entier.

N'oubliez pas que l'opérateur := (un deux-points suivi d'un signe égal) représente une affectation plutôt qu'une égalité. Une déclaration telle que :

  1. NombreDeGars := TailleTotalDeClasse - NombreDeFilles;

ne semble être qu'une identité algébrique. Si les 3 identificateurs avaient été déclarés en tant que variables, les 3 variables pourraient ensuite être modifiées indépendamment. Une égalité, en revanche, est écrite avec le signe égal (=) et n'apparaît que dans un test de condition. Ainsi, dans la déclaration :

  1. If AnnieAge = WilliamAge + 2 Then Write('Annie est deux plus vieilles que William');

AnnieAge est inchangé à la suite du test IF. Un exemple plus subtil est la déclaration suivante :

  1. AnnnieEstDeuxAnsPlusAgees := AnnieAge = WilliamAge + 2;

Ici AnnnieEstDeuxAnsPlusAgees est une variable booléenne ne pouvant être affectée qu'à TRUE ou FALSE. Le côté droit de l'instruction d'affectation est la condition à tester. Si AnnieAge est égal à WilliamAge + 2, AnnnieEstDeuxAnsPlusAgees sera attribué TRUE, sinon, FALSE sera attribué. Dans tous les cas, les valeurs d'origine d'AnnieAge et de WilliamAge restent inchangées.

L'instruction CASE

L'instruction CASE sélectionne une instruction à exécuter dans une liste de plusieurs, en fonction de la valeur d'une expression.

  1. Case Reponse of 
  2.  'M','m':Write('Vous avez répondu: Mâle');
  3.  'F','f':Write('Vous avez répondu: Femelle');
  4.  Else Write('S.V.P. refaite un choix');
  5. End;

Ici, Reponse est appelé le sélecteur de cas. Si Reponse est égal à l'une des constantes de casse 'M' ou 'm', le premier message s'affiche. Si, par contre, Reponse est égal à l'une des constantes de casse, 'F' ou 'f', le deuxième message est affiché. L'instruction définie par le mot-clef ELSE est exécutée uniquement si Reponse n'est égal à aucune des quatre constantes de casse spécifiées.

L'instruction ELSE est facultative. S'il n'apparaît pas et que le sélecteur de casse ne correspond à aucune des constantes de casse, l'instruction 'CASE' est ignorée et l'instruction suivant immédiatement le mot-clef END sera exécutée.

  1. WriteLn('Joyeux anniversaire');
  2. Case Age Of
  3.  18:WriteLn('Enregistre à voté!');
  4.  35:WriteLn('Bienvenue à l''age moyen');
  5.  62:WriteLn('Applique pour la sécurité social');
  6. End;
  7. WriteLn('Vous vous amusez bien dans votre fête !');

Jusqu'à présent, nous utilisions la procédure Write pour afficher quelque chose à l'écran. Cet exemple utilise à la place WriteLn (prononcé "write line"). L'instruction WriteLn est identique à Write, sauf que lorsqu'il a terminé avec l'affichage, il déplace le curseur sur la ligne courante, immédiatement après ce qui a été affiché. L'utilisation de WriteLn garantit ainsi que chacun des messages précédents apparaîtra sur sa propre ligne à l'écran.

Instruction FOR

L'instruction FOR exécute une instruction à plusieurs reprises tandis qu'une séquence de valeurs est affectée à une variable de contrôle. Dans la déclaration :

  1. For i:=1 to 10 do WriteLn(i,' au carré est ',i*i);

l'instruction WriteLn est exécutée dix fois. La première fois, la valeur de i est fixée à 1 ; la deuxième fois, i est égal à 2. Ce processus se poursuit jusqu'à ce que i soit égal à 10. Vous pouvez également utiliser l'instruction FOR pour diminuer les valeurs avec chaque cycle. Pour cette opération, utilisez le mot-clef DOWNTO à la place du mot-clef TO, comme suit :

  1. For CountDown := 10 downto 1 do WriteLn('Décompte');

Instruction GOTO

L'instruction GOTO transfère le flux du programme à la première instruction suivant une étiquette spécifiée. Par exemple, l'instruction :

  1. GOTO Start;

Instruction IF

L'instruction IF teste une condition et exécute des actions en fonction du résultat. Si la condition est TRUE, l'instruction suivant immédiatement le mot-clef THEN est exécutée.

  1. If CompteurLigne > LongueurPage Then EjectLaPage;

Si vous souhaitez qu'une instruction s'exécute lorsque la condition est TRUE et qu'une autre instruction s'exécute lorsque la condition est FALSE, vous pouvez ajouter une clause ELSE, comme suit :

  1. If Temperature > 75 Then WriteLn('Temps de plage !');
  2.                     Else WriteLn('Rester à la maison');

La clause ELSE est totalement facultative. Si aucune clause ELSE n'est présente et que la condition est fausse, l'intégralité de l'instruction IF est ignorée. Si l'instruction exécutée de manière conditionnelle est elle-même une autre instruction IF, toutes les clauses ELSE sont supposées faire référence à l'instruction IF la plus récemment exécutée, comme suit :

  1. If Note = 100 Then WriteLn('Un test parfait ! Félicitation !') Else
  2. If Note > 94 Then WriteLn('Excellent travail ! Vous avez un A!') Else
  3. If Note > 84 Then WriteLn('Bon travail ! Vous avez un B!') Else
  4. If Note > 74 Then WriteLn('Sans inspiration ! Vous avez un C!') Else
  5. If Note > 64 Then WriteLn('A peine correcte ! Vous avez un D!')
  6.              Else WriteLn('S.V.P., venez me voir après la classe');

Comme vous pouvez le voir dans cet exemple, les instructions IF imbriquées sont souvent difficiles à suivre ; ils doivent être évités. Vous pouvez fréquemment remplacer un escalier d'instructions IF imbriquées par une seule instruction CASE.

Instruction REPEAT

L'instruction REPEAT répète une série d'instructions jusqu'à ce qu'une condition spécifiée devienne TRUE, comme dans ce qui suit :

  1. Repeat
  2.  Write('Continuer (O/N) ?');
  3.  ReadLn(Reponse);
  4. Until (Reponse = 'O')or(Reponse = 'N');

Toutes les instructions entre les mots clefs REPEAT et UNTIL sont exécutées avant le premier test. Par conséquent, vous pouvez considérer une instruction REPEAT comme une instruction longue s'exécutant au moins une fois. La condition spécifiée dans la clause UNTIL est testée après chaque passage. Une expression n'étant jamais TRUE crée une boucle infinie. Vous n'avez pas besoin d'utiliser les mots-clefs BEGIN et END pour identifier les énoncés dans la boucle.

Instruction WHILE

L'instruction WHILE teste une condition. Si la condition est TRUE, l'instruction suivant le mot-clef DO est exécutée à plusieurs reprises, jusqu'à ce que la condition d'origine devienne FALSE. Cependant, si la condition d'origine était fausse, l'instruction suivant le mot-clef DO ne sera pas du tout exécutée.

  1. Total := 0;
  2. ReadLn(NextValue);
  3. While NextValue<>0 do Begin
  4.  Total := Total + NextValue;
  5.  ReadLn(NextValue);
  6. End;
  7. WriteLn('La valeur total est ',Total);

Contrairement à la boucle REPEAT...UNTIL, le premier test de condition est effectué avant l'exécution de l'instruction suivant WHILE...DO.

Instruction WITH

L'instruction WITH vous permet de référencer les champs d'un enregistrement sans identifier le nom de l'enregistrement à chaque utilisation. Voici un exemple simple. Supposons que l'enregistrement DonneesEtudiantes contienne ici des champs, NomDeFamille, Niveau et GPA. Au lieu de dire :

  1. DonneesEtudiantes.NomDeFamille='Maltais';
  2. DonneesEtudiantes.Niveau='Deuxième année';
  3. DonneesEtudiantes.GPA='3.943';

l'instruction WITH permet une structure plus élégante :

  1. With DonneesEtudiantes do
  2.  NomDeFamille='Maltais';
  3.  Niveau='Deuxième année';
  4.  GPA='3.943';
  5. End;

Déclarations composées

Le QuickPascal considère toujours un bloc BEGIN et END comme une seule instruction, quel que soit le nombre réel d'instructions dans le bloc. Pour cette raison, un bloc - étant souvent appelé instruction composée - peut être utilisé partout où une seule instruction est autorisée. Par exemple, au lieu d'utiliser la paire d'instructions suivantes :

  1. If ValeurEntree > MaximumAllouee Then WriteLn('Cette valeur est trop large.');
  2. If ValeurEntree > MaximumAllouee Then WriteLn('SVP retypé');

vous pouvez utiliser une instruction composée :

  1. If ValeurEntree > MaximumAllouee Then Begin
  2.  WriteLn('Cette valeur est trop large.');
  3.  WriteLn('SVP retypé');
  4. End;

Remarquez comment les indentations facilitent la compréhension de l'intention du programmeur.

Instructions vides

La construction suivante est autorisée puisque le compilateur traite chaque bloc BEGIN...END comme une seule déclaration légale, et depuis qu'une déclaration composée peut elle-même contenir n'importe quelle déclaration légale :

  1. Program BonjVide;
  2.  
  3. BEGIN
  4.  Write('Bonjour');
  5.  Begin End;
  6. END.

Ici, BEGIN et END dans le bloc de programme principal (étant lui-même une instruction composée) font une instruction vide. Des instructions vides sont également créées lorsqu'un point-virgule inutile est utilisé. Notez que les instructions les plus vides sont inoffensives et n'ont aucun effet direct sur la taille ou la vitesse d'exécution du programme compilé.

Le programme suivant contient une instruction vide masquée :

  1. Program Bonjour2;
  2. BEGIN
  3.  WriteLn('Bonjour!');
  4.  WriteLn('Encore bonjour!');
  5. END.

Vous avez appris plus tôt à utiliser un point-virgule pour séparer deux instructions. Dans le programme Bonjour2, la deuxième instruction WriteLn est suivie d'un point-virgule même si aucune instruction n'apparaît sur la ligne suivante. En conséquence, le compilateur insère simplement une instruction vide entre le deuxième WriteLn et le mot-clef END. (D'un autre côté, une erreur de compilation se produira inévitablement lorsque vous oubliez d'utiliser un point-virgule.)

Pour prouver que les instructions vides n'ont aucun effet sur la taille des programmes compilés, comparez les fichiers .EXE et .QDB créés à partir du programme Bonjour d'origine avec ceux générés par la monstruosité parfaitement légale suivante :

  1. Program Bonjour3;
  2. BEGIN
  3.  Write('Bonjour!');;;;
  4.  BEGIN ;; END;;
  5. END.

Vous constaterez que les tailles de fichiers sont identiques. L'instruction vide créée par un point-virgule supplémentaire est une cause fréquente de surprises à l'exécution. Supposons qu'un programme de traitement de fichiers semble s'exécuter correctement, mais se termine anormalement chaque fois qu'il atteint la fin du fichier d'entrée. Un examen de la déclaration suivante :

  1. If Not FinDuFichierCourant Then;
  2. TraiteProchainEnregistrement;

révèle un point-virgule indésirable. Ici, le compilateur interprète le point-virgule après THEN comme l'instruction vide exécutée de manière conditionnelle par le IF. La procédure TraiteProchainEnregistrement est traitée comme une instruction indépendante (rappelez-vous que le compilateur ignore toute indentation dans le texte source). TraiteProchainEnregistrement sera toujours exécuté, quelle que soit la valeur de FinDuFichierCourant.

Supposons maintenant que l'instruction suivante apparaisse dans un programme conçu pour afficher les carrés des 10 premiers entiers :

  1. Program Boucle;
  2. Var
  3.  I:Integer;
  4. BEGIN
  5.  i:=1;
  6.  While i < 10 do;
  7.  Begin
  8.   WriteLn('Le carre est ',i,' est ',i*i);
  9.   i := i + 1;
  10.  End;
  11. END.

Ici, le compilateur interprète le point-virgule après le DO comme une instruction vide appartenant au WHILE. L'instruction composée suivant immédiatement le point-virgule est supposée indépendante. Encore une fois, l'indentation n'a aucun effet sur la façon dont QuickPascal compile un programme. Puisque i est initialisé pour être inférieur à dix, la condition WHILE est toujours vraie - et par conséquent, le programme se bloque dans une boucle infinie.



Dernière mise à jour : Mercredi, le 15 décembre 2021