Logo

Marco Cantù
L'essentiel sur Pascal

Traduit de l'anglais par Iannis Papageorgiadis ipapag@village.uunet.be

Chapitre 2
Écrire du code en Pascal

Avant d'aborder le sujet de l'écriture des instructions du langage Pascal, il importe de mettre en évidence quelques éléments du style d'encodage Pascal. La question que nous souhaitons traiter est la suivante : indépendamment des règles de syntaxe, comment devrait-on écrire du code ? Il n'y a pas qu'une seule réponse à cette question, puisque le goût personnel peut dicter à chacun différents styles. Cependant, il y a quelques principes que l'on doit connaître concernant les commentaires, les majuscules, les espaces, et tout ce qu'on appelle la belle impression. En général, chaque style d'écriture de code a pour but la clarté. Le style et les décisions de formatage que vous prenez sont une sorte de raccourci indiquant le but d'un morceau de code donné. Un outil essentiel pour arriver à la clarté est la cohérence; quel que soit le style que vous choisissez, assurez vous de le conserver à travers tout le projet.

Les commentaires

En Pascal, les commentaires se trouvent soit entre accolades, soit entre parenthèses suivies d'une étoile. Delphi accepte aussi le style de commentaires C++, qui peuvent couvrir la fin de la ligne :
{ceci est un commentaire}

(* ceci est un autre commentaire *)

// ceci est un commentaire jusqu'en fin de ligne
La première forme est plus courte et plus souvent utilisée. La seconde forme a souvent été préférée en Europe parce que sur plusieurs claviers européens manque le symbole de l'accolade. La troisième forme de commentaires a été empruntée au C++ et est disponible uniquement dans les versions 32 bits de Delphi. Les commentaires jusqu'en fin de ligne sont très utiles pour les commentaires courts et pour désactiver une ligne de code en la mettant en commentaire.

Dans les listings de ce livre, nous essaierons d'indiquer les commentaires en italiques (et les mots réservés en gras), pour rester cohérent avec la mise en évidence de la syntaxe par défaut de Delphi.

Disposer de trois formes différentes de commentaires peut être utile pour effectuer des commentaires imbriqués. Si vous souhaitez désactiver plusieurs lignes de code en les plaçant en commentaire et si ces lignes contiennent quelques véritables commentaires, vous ne pouvez pas utiliser le même identificateur de commentaire :

{... code

{commentaire, créant des problèmes}

... code}
Avec un second identificateur de commentaire, vous pouvez écrire le code suivant, qui est correct :
{ ... code

//ce commentaire est correct

... code}
Notez que si l'accolade ouverte ou la parenthèse-étoile est suivie du signe dollar ($), elle devient une directive de compilation, comme p. ex. dans {$X+}.

En fait, les directives de compilation sont aussi des commentaires. Par exemple, {$X+ Ceci est un commentaire} est permis. Cela constitue une directive valide et un commentaire, bien que quelques programmeurs auront probablement  tendance à séparer directives et commentaires.

L'utilisation des majuscules

Le compilateur Pascal (contrairement à celui d'autres langages) ne fait pas de différence entre les majuscules et les minuscules. Donc, les identificateurs Monnom, MonNom, monnom, monNom et MONNOM sont parfaitement équivalents. Dans l'ensemble, ceci est positif puisque dans les langages sensibles à la casse, plusieurs erreurs de syntaxe sont dues à une écriture incorrecte.

Remarque : Il y a une seule exception à la règle de l'insensibilité à la casse de Pascal : la procédure Register d'un paquet de composants doit commencer par un R majuscule, pour une question de compatibilité avec C++ Builder.

Il existe cependant deux légers inconvénients. Premièrement, vous devez être conscient que ces identificateurs sont réellement les mêmes; de la sorte, vous éviterez de les utiliser comme étant des éléments différents. Deuxièmement, vous devrez essayer d'être cohérent dans l'utilisation des majuscules, pour améliorer la lisibilité du code.

Une utilisation cohérente des majuscules n'est pas imposée par le compilateur, mais c'est une bonne habitude à prendre. Une approche fréquente consiste à mettre une majuscule à la première lettre de chaque identificateur. Lorsqu'un identificateur est composé de plusieurs mots consécutifs (vous ne pouvez pas insérer un espace dans un identificateur), la première lettre de chaque mot devrait être une majuscule:

MonLongIdentificateur

MonTresLongEtPresqueIdiotIdentificateur
D'autres éléments complètement ignorés par le compilateur sont les espaces, les nouvelles lignes et les tabulations que vous ajoutez dans le code source. Tous ces éléments sont connus sous le nom collectif de espace. Ils sont utilisés uniquement pour améliorer la lisibilité du code; ils n'affectent pas la compilation.

Le Pascal, au contraire du BASIC, permet l'écriture d'une instruction sur plusieurs lignes de code, en coupant une longue instruction en deux ou plusieurs lignes. L'inconvénient (du moins pour certains programmeurs BASIC) d'allouer plus d'une ligne aux instructions est qu'il faut se rappeler d'ajouter un point-virgule pour indiquer la fin d'une instruction, ou plus exactement pour séparer une instruction de la suivante. Notez que la seule restriction à la disposition des instructions de programmation sur plusieurs lignes est qu'une chaîne littérale ne peut occuper plusieurs lignes.

Encore une fois, il n'existe pas de règles établies pour l'utilisation des espaces et des instructions sur plusieurs lignes; il n'existe que quelques règles empiriques :

La belle impression

La dernière suggestion pour l'utilisation des espaces est liée au style d'écriture typiquement Pascal. La règle est simple : chaque fois que l'on doit écrire une instruction composée, on l'indente du reste de l'instruction courante de deux espaces vers la droite. Une instruction composée dans une autre instruction composée sera indentée de quatre espaces, et ainsi de suite:
if ... then

  instruction;



if ... then

begin

  instruction1;

  instruction2; 

end;



if ... then

begin

  if ... then

    instruction1;

  instruction2;

end;

La mise en forme ci-dessus est basée sur la "belle impression", mais les programmeurs interprètent différemment cette règle générale. Quelques uns indentent begin et end au niveau du code interne; quelques autres indentent begin et end et indentent une fois de plus le code interne; d'autres encore placent le begin dans la même ligne que le if de la condition. C'est là une question de goût personnel.
On utilise souvent une indentation similaire pour les listes de variables ou les listes des types de données, ou encore pour continuer une instruction se trouvant sur la ligne précédente :

type

  Letters = set of Char;

var

  Name: string;

begin

   { long commentaire et longue instruction se poursuivant sur la ligne

     suivante et indentée de deux espaces}

   MessageDlg ('Ceci est un message',

     mtInformation, [mbOk], 0);
Bien sûr, de telles conventions ne constituent qu'une suggestion afin de rendre le code plus lisible à d'autres programmeurs, et sont complètement ignorées par le compilateur. Nous avons essayé d'utiliser ces règles dans tous les exemples et dans tous les fragments de code de cet ouvrage. Le code source des manuels de Delphi et les exemples de l'aide utilisent un style de formatage semblable à celui-ci.

La mise en évidence de la syntaxe

L'éditeur de Delphi possède une caractéristique, appelée mise en évidence de la syntaxe, qui rend plus faciles l'écriture et la lecture du code Pascal. En fonction de leur signification en Pascal, les mots que vous tapez dans l'éditeur sont affichés en différentes couleurs. Par défaut, les mots réservés sont en gras, les chaînes et les commentaires en couleur (et souvent en italiques), et ainsi de suite.

Les mots réservés, les commentaires et les chaînes sont probablement les trois éléments auxquels cette caractéristique est la plus profitable. Vous pouvez repérer en un coup d' oeil un mot mal écrit, une chaîne qui n'est pas terminée correctement, et la longueur d'un commentaire sur plusieurs lignes.

Vous pouvez facilement personnaliser l'organisation de la mise en évidence en vous servant de la page Couleurs de la boîte de dialogue Options d'environnement du menu Outils (fig. 2.1). Si vous travaillez seul, choisissez les couleurs qui vous plaisent. Si vous travaillez en collaboration avec d'autres programmeurs, vous devriez vous accorder sur un standard de couleurs. A notre avis, travailler sur un ordinateur avec un coloriage de la syntaxe différent de celui auquel on est habitué est vraiment difficile.

FIGURE 2.1 : La boîte de dialogue utilisée pour définir la mise en évidence de la syntaxe


 

Remarque : Dans ce livre nous avons essayé d'appliquer aux listings du code source une sorte de mise en évidence de la syntaxe. Nous espérons que cela les rendra effectivement plus lisibles.

L'utilisation des modèles de code

Delphi 3 a introduit une nouvelle fonctionnalité relative à l'édition du code source. Vu que, en écrivant du code en Pascal vous utilisez souvent la même séquence de mots réservés, Borland a prévu une nouvelle fonctionnalité appelée "Modèles de Code". Un Modèle de Code est simplement un morceau de code lié à un raccourci. Vous tapez le raccourci, et ensuite vous pressez Ctrl+J et l'entièreté du code apparaît. Par exemple, si vous tapez arrayd, et vous pressez ensuite Ctrl+J, l'éditeur Delphi complétera votre texte pour qu'il devienne:
array [0..] of ;
Puisque les Modèles de Code prédéfinis contiennent habituellement plusieurs versions du même assemblage, le raccourci se termine généralement par une lettre indiquant la version qui vous intéresse. Toutefois vous pouvez aussi ne taper que la partie initiale du raccourci. Par exemple, si vous tapez ar et que vous pressez Ctrl+J, l'éditeur affichera un menu local avec une liste des choix disponibles accompagnée d'une courte description, comme vous pouvez le voir à la figure 2.2.

Figure 2.2: Choix des modèles de code

Vous pouvez personnaliser les Modèles de Code en modifiant ceux qui existent ou en ajoutant vos morceaux de code habituels. Si vous le faites, pensez que le texte du Modèle de Code comprend généralement le caractère "|" pour indiquer la position où se trouvera le curseur après l'opération, c'est-à-dire l'endroit où vous pouvez commencer à taper pour compléter le Modèle de Code avec le code personnalisé.

Les instructions du langage

Dès que vous avez défini quelques identificateurs, vous pouvez les utiliser dans les instructions et les expressions faisant partie de quelques instructions. Pascal offre plusieurs instructions et expressions. Voyons pour commencer les mots réservés, les expressions et les opérateurs.

Les mots réservés

Les mots réservés sont tous des identificateurs réservés du Pascal Objet qui ont un rôle dans le langage. L'aide de Delphi distingue les mots réservés et les directives : les mots réservés ne peuvent pas être utilisés en tant qu' identificateurs, tandis que les directives ne devraient pas être utilisées comme tels bien que le compilateur les accepte. Pratiquement, on ne devrait utiliser aucun mot réservé en tant qu'identificateur.

La table 2.1 reprend la liste complète des identificateurs jouant un rôle spécifique dans Pascal Objet (en Delphi 4).

Table 2.1 : Les mots réservés du Pascal Objet
 
Mot réservé  Rôle
absolue  directive (variables)
abstrait  directive (méthode)
and  opérateur (booléen)
array  type
as  opérateur (RTE)
as  instruction
assembler  compatibilité ascendante
ta  instruction (exceptions)
automate  spécificateur d'accès (classe)
begin  marqueur de bloc
case  instruction
cdecl  fonction de convention d'appel
class  type
const  déclaration ou directive (paramètres)
constructor  méthode spéciale
contains  opérateur (ensemble)
default  directive (propriété)
destructor  méthode spéciale
dispid  spécificateur d'interface de répartition
dispinterface type
div  opérateur
do  instruction
downto  instruction (for)
dynamic  directive (méthode)
else  instruction (if ou case)
end  marqueur de bloc
except  instruction (exceptions)
export  compatibilité ascendante (classe)
exports  déclaration
external  directive (fonctions)
far  compatibilité ascendante (classe)
file  type
finalization structure d'unité
finally  instruction (exceptions)
for  instruction
forward  directive de fonction
function  déclaration
goto  instruction
if  instruction
implementation structure d'unité
implements  directive (propriété)
in  opérateur (ensemble) - structure de projet
index  directive (interface de répartition)
inherited  instruction
initialization structure d'unité
inline  compatibilité ascendante (voir as)
interface  type
is  opérateur (RTE)
label  déclaration
library  structure de programme
message  directive (méthode)
mod  opérateur (math)
name  directive (fonction)
near  compatibilité ascendante (class)
nil  valeur
nodefault  directive (propriété)
not  opérateur (booléen)
object  compatibilité dascendante (class)
of  instruction (case)
on  instruction (exceptions)
or  opérateur (booléen)
out  directive (paramètres)
overload  directive de fonction
override  directive de fonction
package  structure de programme (paquets)
packed  directive (enregistrement)
pascal  convention d'appel de fonction
private  spécificateur d'accès (classe)
procedure  déclaration
program  structure de programme
property  déclaration
protected  spécificateur d'accès (class)
public  spécificateur d'accès (class)
published  spécificateur d'accès (class)
raise  instruction exceptions
read  spécificateur de propriété
readonly  spécificateur d'interface
record  type
register  convention d'appel de fonction
reintroduce  directive de fonction
repeat  instruction
requires  structure de programme (paquets)
resident  directive (fonctions)
resourcestring type
safecall  convention d'appel de fonction
set  type
shl  opérateur (math)
shr  opérateur (math)
stdcall  convention d'appel de fonction
stored  directive (propriété)
string  type
then  instruction (if)
threadvar  déclaration
to  instruction (for)
try  instruction (exceptions)
type  déclaration
unit  structure d'unité
until  instruction
uses  structure d'unité
var  déclaration
virtual  directive (méthode)
while  instruction
with  instruction
write  spécificateur de propriété
writeonly  spécificateur d'interface de répartition
xor  opérateur (booléen)

Les expressions et les opérateurs

Il n'y a pas de règle générale pour construire des expressions, puisqu'elles dépendent principalement des opérateurs qui sont utilisés; Pascal en comporte plusieurs. Il y a les opérateurs logiques, arithmétiques, booléens, relationnels, et les opérateurs sur des ensembles, plus quelques autres. Les expressions peuvent être utilisées pour déterminer la valeur à assigner à une variable, pour calculer le paramètre d'une fonction ou d'une procédure, ou pour tester une condition. Les expressions peuvent également contenir des appels à des fonctions. Chaque fois que vous effectuez une opération sur la valeur d'un identificateur, au lieu d'utiliser l'identificateur même, vous avez une expression.

Les expressions sont communes à plusieurs langages de programmation. Une expression est toute combinaison valide de constantes, de variables, de valeurs littérales, d'opérateurs, et de résultats de fonctions. Les expressions peuvent aussi être passées aux paramètres valeur des procédures et fonctions, mais pas aux paramètres variables (qui exigent qu'une valeur puisse leur être assignée).

Opérateurs et priorité

Si vous avez déjà écrit un programme, vous savez ce qu'est qu'une expression. Ici, nous mettrons en évidence les éléments spécifiques aux opérateurs Pascal. Vous trouverez une liste des opérateurs du langage, groupés par priorité, à la table 2.2.

Contrairement à beaucoup d'autres langages, la priorité des opérateurs and et or est comparable à celle des opérateurs relationnels. Ainsi, si vous écrivez a < b and c < d, le compilateur essaiera d'effectuer en premier lieu l'opération and; une erreur de compilation sera alors produite. C'est pour cette raison que vous devriez placer ces expressions dans des parenthèses : (a < b) and (c < d).

Remarquez que quelques-uns des opérateurs courants ont des significations différentes en fonction des types de données. Par exemple, l'opérateur + peut être utilisé pour additionner deux nombres, concaténer deux chaînes, effectuer l'union de deux ensembles, et même additionner un déplacement (offset) à un pointeur PChar. Cependant, vous ne pouvez pas additionner deux caractères, comme cela est permis en C.

Div est un autre opérateur étrange. En Pascal, vous pouvez diviser deux nombres (réels ou entiers) à l'aide de l'opérateur / et dans les deux cas vous obtiendrez comme résultat un réel. Si vous devez diviser deux entiers et que vous souhaitez un résultat entier, utilisez par contre l'opérateur div.

Table 2.2 : Les opérateurs Pascal groupés par ordre de priorité
 
Opérateurs unaires (la plus haute priorité)
@ Adresse de la variable ou de la fonction (retourne un pointeur)
not Booléen ou négation binaire
Opérateurs multiplicatifs et binaires
* Multiplication arithmétique ou intersection de deux ensembles
/ Division avec virgule flottante
div Division entière
mod Modulo (reste de la division entière)
as Transtypage contrôlé (RTE)
and Booléen ou Et binaire
shl Décalage à gauche binaire
shr Décalage à droite binaire
Opérateurs d'addition
+ Addition arithmétique, union de deux ensembles, concaténation de chaînes, addition de décalage et de pointeur
- Soustraction arithmétique, différence de deux ensembles, soustraction déplacement pointeur
or Booléen ou Ou binaire
xor Booléen ou Ou exclusif binaire
Opérateurs Relationnels et de comparaison (la plus basse priorité)
= égal
<> différent
< inférieur
> supérieur
<=  inférieur ou égal, ou  sous-ensemble de
>= supérieur ou égal, ou sur ensemble de 
in membre de
is Vérification de type dynamique (un autre opérateur RTE)

Les opérateurs d'ensembles

Les opérateurs d'ensembles sont l'union (+), la différence (-), l'intersection (*), membre de (in), plus quelques opérateurs relationnels. Pour ajouter un élément à un ensemble, vous pouvez effectuer l'union de l'ensemble avec un autre qui contient uniquement l'élément dont vous avez besoin. Voici un exemple en Delphi relatif aux styles des fontes:
Style := Style + [fsBold];

Style := Style + [fsBold, fsItalic] - [fsUnderline];
Vous pouvez également utiliser les procédures standard Include et Exclude, qui sont nettement plus efficaces (mais qui ne peuvent pas être utilisées avec les propriétés des composants du type ensemble, parce qu'elles exigent un paramètre valeur compatible avec le type de base de l'ensemble) :
Include (Style, fsBold);

Conclusion

Maintenant que nous connaissons le cadre de base d'un programme Pascal, nous sommes prêts à comprendre en détail sa signification. Nous commencerons par explorer la définition des types de données prédéfinis et de ceux définis par l'utilisateur; ensuite nous examinerons l'utilisation des mots réservés pour réaliser des instructions de programmation.

Chapitre suivant: Types, Variables, et Constantes

 
© Copyright Marco Cantù, Wintech Italia Srl 1995-99