Eléments syntaxiques fondamentaux (Delphi)
Remonter à Eléments syntaxiques fondamentaux - Index
Les éléments syntaxiques fondamentaux, appelés tokens, se combinent pour former des expressions, des déclarations et des instructions.
Une instruction décrit une action algorithmique qui peut être exécutée dans un programme. Une expression est une unité syntaxique située dans une instruction et qui désigne une valeur. Une déclaration définit un identificateur (par exemple le nom d’une fonction ou d’une variable) qui peut être employé dans des expressions ou des instructions et, si c’est nécessaire, alloue de la mémoire à l’identificateur.
Cette rubrique présente le jeu de caractères du langage Delphi et décrit la syntaxe de déclaration :
- Identificateurs
- Nombres
- Chaînes de caractères
- Libellés
- Commentaires du code source
Le jeu de caractères Delphi
Le langage Delphi utilise l’encodage de caractères Unicode pour son jeu de caractères, qui comprend les caractères Unicode alphabétiques et alphanumériques ainsi que le caractère de soulignement. Delphi ne tient pas compte de la casse. Le caractère espace et les caractères de contrôle (U+0000 à U+001F, y compris U+000D, le caractère de retour ou de fin de ligne) sont des blancs.
Le compilateur RAD Studio accepte un fichier codé en UCS-2 ou UCS-4 si le fichier contient une marque d’ordre des octets. L’utilisation de formats autres que UTF-8 peut ralentir la compilation ; toutefois, l’utilisation d’UTF-8 est recommandée. Tous les caractères d’un fichier source codé en UCS-4 doivent pouvoir être représentés en UCS-2 sans paires de substitution. Les codages UCS-2 avec paires de substitution (y compris GB18030) ne sont acceptés que si l’option de compilation codepage est spécifiée.
Tokens
Au niveau le plus élémentaire, un programme est une suite de tokens délimités par des séparateurs. Un token est la plus petite unité de texte significative d’un programme. Un séparateur est soit un blanc, soit un commentaire. Strictement parlant, il n’est pas toujours nécessaire de placer un séparateur entre deux tokens ; par exemple le fragment de code suivant :
Size:=20;Price:=10;
Est parfaitement correct. Néanmoins, pour respecter la pratique courante et les exigences de lisibilité, il est préférable de l’écrire sur deux lignes, de la manière suivante :
Size := 20;
Price := 10;
Les tokens sont divisés en symboles spéciaux, identificateurs, mots réservés, directives, nombres, libellés et chaînes de caractères. La chaîne de caractères est le seul token qui peut contenir des séparateurs. Il doit obligatoirement y avoir un séparateur entre des identificateurs, mots réservés, nombres et libellés adjacents.
Symboles spéciaux
Les symboles spéciaux sont des caractères, ou des paires de caractères, non alphanumériques ayant un sens déterminé. Les caractères individuels suivants sont des symboles spéciaux :
# $ & ' ( ) * + , - . / : ; < = > @ [ ] ^ { }
Les paires de caractères suivantes sont également des symboles spéciaux :
(* (. *) .) .. // := <= >= <>
Le tableau suivant présente les paires de symboles utilisées dans Delphi et ayant des significations similaires (les paires de symboles {} et (* *) sont des caractères de commentaire décrits plus en détail dans Commentaires et directives de compilation) :
| Symboles spéciaux | Symboles spéciaux similaires |
|---|---|
| [ ] | (. .) |
| { } | (* *) |
Le crochet ouvrant [ est similaire à la paire de caractères composée d’une parenthèse ouvrante et d’un point (..
Le crochet fermant ] est similaire à la paire de caractères composée d’un point et d’une parenthèse fermante .).
L’accolade ouvrante { est similaire à la paire de caractères composée d’une parenthèse ouvrante et d’un astérisque (*.
L’accolade fermante } est similaire à la paire de caractères composée d’un astérisque et d’une parenthèse fermante *).
Identificateurs
Les identificateurs désignent les constantes, variables, champs, types, propriétés, procédures, fonctions, programmes, unités, bibliothèques et packages. La longueur d’un identificateur peut être quelconque, mais seuls les 255 premiers caractères sont significatifs. Un identificateur doit commencer par un caractère alphabétique, un caractère Unicode ou un caractère de soulignement (_) et ne peut contenir ni espace ni caractère Unicode considéré comme un espace. Les caractères alphanumériques, les caractères Unicode, les chiffres (y compris les caractères Unicode représentant des chiffres) et les caractères de soulignement sont autorisés après le premier caractère. Les mots réservés ne peuvent pas être utilisés comme identificateurs. Comme le langage Delphi ne tient pas compte de la casse, un identificateur tel que CalculateValue peut s’écrire de l’une des façons suivantes :
CalculateValue calculateValue calculatevalue CALCULATEVALUE
Comme les noms des unités correspondent aux noms des fichiers, des incohérences de casse peuvent parfois affecter la compilation. Pour plus d’informations, voir la section Références d’unité et la clause uses dans Programmes et unités (Delphi).
Identificateurs qualifiés
Quand vous utilisez un identificateur qui a été déclaré à plusieurs endroits, il est parfois nécessaire de qualifier l’identificateur. La syntaxe d’un identificateur qualifié est :
identificateur1.identificateur2
Où identificateur1 qualifie identificateur2. Si, par exemple, deux unités déclarent une variable appelée CurrentValue, vous pouvez spécifier que vous voulez accéder à CurrentValue dans Unit2 en écrivant :
Unit2.CurrentValue
Il est possible de chaîner les qualificateurs. Par exemple :
Form1.Button1.Click
appelle la méthode Click de Button1 dans Form1.
Si vous ne qualifiez pas un identificateur, son interprétation est déterminée par les règles de portée décrites dans Blocs et portée dans Déclarations et instructions (Delphi).
Identificateurs étendus
Il se peut que vous rencontriez des identificateurs (par exemple, des types ou des méthodes d’une classe) portant le même nom qu’un mot réservé du langage Delphi. Par exemple, une classe peut avoir une méthode appelée begin. Les mots réservés de Delphi, tels que begin, ne peuvent pas être utilisés comme noms d’identificateurs.
Si vous qualifiez complètement l’identificateur, il n’y a alors plus de problème. Par exemple, si vous voulez utiliser le mot réservé type de Delphi comme nom d’identificateur, vous devez utiliser son nom qualifié complet :
var TMyType.type
// Using a fully qualified name avoids ambiguity with Delphi language keyword.
Une solution plus concise consiste à utiliser l’opérateur esperluette (&) pour résoudre les ambiguïtés entre les identificateurs et les mots réservés du langage Delphi. Le symbole & empêche qu’un mot clé soit analysé comme tel (c’est-à-dire comme un mot réservé). Si vous rencontrez une méthode ou un type portant le même nom qu’un mot clé Delphi, vous pouvez omettre la spécification de l’espace de noms si vous faites précéder le nom de l’identificateur d’une esperluette. Mais lorsque vous déclarez un identificateur portant le même nom qu’un mot clé, vous devez utiliser le symbole & :
type
&Type = Integer;
// Prefix with '&' is ok.
Mots réservés
Les mots réservés suivants ne peuvent être redéfinis ou utilisés comme des identificateurs.
Mots réservés Delphi :
Directives
Delphi comporte plusieurs types de directives. Une des significations de "directive" est un mot qui est sensible à certains endroits du code source. Ce type de directive a une signification particulière en langage Delphi, mais à la différence d’un mot réservé, il apparaît seulement dans des contextes où il ne peut y avoir d’identificateurs définis par l’utilisateur. De ce fait, vous pouvez (même si cela est déconseillé) définir un identificateur identique à une directive.
Directives :
| absolute | export12 | name | protected | static |
| abstract | external | near1 | public | stdcall |
| assembler12 | far1 | nodefault | published | strict |
| automated | final | noreturn | read | stored |
| cdecl | forward | operator10 | readonly | unsafe |
| contains7 | helper8 | out | reference9
|
varargs |
| default | implements | overload | register | virtual |
| delayed | index | override | reintroduce | winapi6
|
| deprecated11 | inline2 | package7 | requires7 | write |
| dispid | library311
|
pascal | resident1
|
writeonly |
| dynamic | local4
|
platform11 | safecall | |
| experimental11 | message | private | sealed5
|
- far, near et resident sont obsolètes.
- inline est utilisé comme style de directive à la fin de la déclaration de la procédure ou de la fonction pour marquer la procédure ou la fonction "inline", , mais était un mot réservé pour Turbo Pascal.
- library est aussi un mot clé quand il est utilisé en tant que premier token du code source du projet ; il indique une cible DLL. Sinon, il marque un symbole, de telle sorte qu’il produit un avertissement de bibliothèque lors de son utilisation.
- local était une directive Kylix et est ignoré pour Delphi pour Win32.
- sealed est une directive de classe avec l’ancienne syntaxe : "class sealed". Une classe sealed ne peut pas être étendue ni dérivée (comme
finaldans C++). - winapi définit la convention d’appel de la plate-forme par défaut. Par exemple, sur Win32, winapi est identique à stdcall.
- package, quand il est utilisé en tant que premier token, indique une cible package et active la syntaxe de package. requires et contains sont des directives uniquement dans la syntaxe de package.
- helper indique "assistance de classe pour".
- reference indique une référence à une fonction ou à une procédure.
- operator indique un opérateur de classe.
- platform, deprecated, experimental et library sont des directives de conseil (ou d’avertissement). Ces directives produisent des avertissements à la compilation.
- Les directives assembler et export n’ont pas de signification. Elles existent uniquement pour des questions de compatibilité avec les versions précédentes.
Types de directives
Delphi a deux types de directives, en plus du type de directive sensible au contexte décrit dans le tableau Directives ci-dessus.
Une directive sensible au contexte peut être un identificateur -- pas typiquement un mot clé -- que vous placez à la fin d’une déclaration pour modifier la signification de la déclaration. Par exemple :
procedure P; forward;
Ou :
procedure M; virtual; override;
Ou :
property Foo: Integer read FFoo write FFoo default 42;
Le dernier type de directive est la directive de compilation officielle, un commutateur ou une option qui influe sur le comportement du compilateur. Une directive de compilation est entourée d’accolades ({}) et commence par un signe dollar ($), comme ceci :
{$POINTERMATH ON}
{$D+} // DEBUGINFO ON
Comme les autres types de directives, les directives de compilation ne sont pas des mots clés. Pour obtenir la liste des directives de compilation, voir la liste des directives de compilation Delphi.
Nombres
Les constantes entières et réelles peuvent être représentées en notation décimale comme une séquence de chiffres sans virgule ni espaces et préfixés par les opérateurs + ou - afin d’indiquer le signe. Par défaut les valeurs sont positives (ainsi 67258 est identique à +67258) et doivent se trouver à l’intérieur de l’intervalle du plus grand type prédéfini entier ou réel.
Les nombres avec un séparateur décimal ou un exposant désignent des réels, alors que les autres nombres désignent des entiers. Quand le caractère E ou e apparaît dans un réel, cela signifie "multiplié par dix à la puissance". Par exemple, 7E2 signifie 7 * 10^2, de même 12.25e+6 et 12.25e6 signifient tous les deux 12.25 * 10^6.
Le signe dollar utilisé comme préfixe indique un nombre hexadécimal, par exemple $8F. Les nombres hexadécimaux non précédés d’un opérateur unaire - sont considérés comme des valeurs positives. Lors d’une affectation, si une valeur hexadécimale se trouve hors de l’intervalle du type destinataire, une erreur est générée, sauf pour le type Integer (entier 32 bits), cas dans lequel un avertissement est généré. Dans ce cas, les valeurs dépassant l’intervalle positif du type Integer sont considérées comme négatives, conformément à la représentation entière en complément à deux. Pour plus d’informations sur les types réels et entiers, voir A propos des types de données (Delphi). Pour plus d’informations sur les types de données des nombres, voir Constantes déclarées.
Le signe pourcentage utilisé comme préfixe indique un nombre binaire, par exemple %0010. Les nombres binaires n’utilisent que les chiffres 0 et 1.
L’utilisation du caractère de soulignement _ comme séparateur de chiffres améliore la lisibilité. Lorsqu’il est correctement utilisé, ce caractère n’a aucune valeur et est ignoré par le compilateur. Les caractères de soulignement ne peuvent pas :
- Apparaître au début ou à la fin.
- Être placés à côté d’un préfixe.
- Être doublés.
Résumé :
| Type de nombre | Syntaxe | Exemple |
|---|---|---|
|
Décimal |
aucune |
5000 |
|
Hexadécimal |
|
|
|
Binaire |
|
%1010 |
|
Séparateur de chiffres |
|
2_000_000 |
|
Virgule flottante |
|
1.23e4 |
|
Code de caractère |
|
|
Libellés
Vous pouvez utiliser un identificateur ou un nombre entier non négatif en tant que libellé. Le compilateur Delphi autorise les libellés numériques allant de 0 à 4294967295 (intervalle uint32).
Les libellés sont utilisés dans les instructions goto. Pour plus d’informations sur les instructions goto et les libellés, voir Instructions Goto dans Déclarations et instructions (Delphi).
Chaînes de caractères
Une chaîne de caractères (appelée également littéral chaîne ou constante chaîne) est une chaîne délimitée, une chaîne de contrôle ou une combinaison de chaînes délimitées et de chaînes de contrôle. Il ne peut y avoir de séparateur qu’à l’intérieur des chaînes délimitées.
Une chaîne délimitée est une séquence de caractères, d’un jeu de caractères ANSI ou multi-octets, écrits sur une seule ligne et placés entre apostrophes. Une chaîne délimitée ne contenant rien entre les apostrophes est une chaîne vide. Deux apostrophes consécutives à l’intérieur d’une chaîne délimitée désigne un seul caractère : une apostrophe.
La chaîne est représentée en interne sous la forme d’une chaîne Unicode encodée en UTF-16. Les caractères du BMP (Basic Multilingual Plane) prennent 2 octets, et les autres caractères nécessitent 4 octets.
Par exemple :
'Embarcadero' { Embarcadero }
'You''ll see' { You'll see }
'アプリケーションを Unicode 対応にする'
'''' { ' }
'' { null string }
' ' { a space }
Une chaîne de contrôle est une séquence constituée d’un ou de plusieurs caractères de contrôle, chacun d’eux étant constitué du symbole # suivi d’une constante entière non signée comprise entre 0 et 65 535 (décimal) ou entre $0 et $FFFF (hexadécimal) dans l’encodage UTF-16 ; et désigne le caractère correspondant à une valeur de code spécifiée. Chaque entier est représenté en interne par 2 octets dans la chaîne. Cela est utile pour représenter des caractères de contrôle et des caractères multi-octets. La chaîne de contrôle :
#89#111#117
Est équivalente à la chaîne délimitée :
'You'
Il est possible de combiner les chaînes délimitées et les chaînes de contrôle pour constituer des chaînes plus longues. Par exemple, vous pouvez utiliser :
'Line 1'#13#10'Line 2'
pour placer une séquence retour chariot-passage à la ligne entre "Ligne 1" et "Ligne 2". Néanmoins, il n’est pas possible de concaténer deux chaînes délimitées en procédant ainsi, en effet deux apostrophes se suivant sont interprétées comme un seul caractère. Pour concaténer des chaînes délimitées, utilisez l’opérateur + ou combinez-les en une seule chaîne délimitée.
Une chaîne de caractères est compatible avec tout type de chaîne et avec le type PChar. Puisqu’un type AnsiString peut contenir des caractères multi-octets, une chaîne de caractères avec un caractère, mono ou multi-octets, est compatible avec tout type de caractère. Quand la syntaxe étendue est activée (avec la directive de compilation {$X+}), une chaîne de caractères non vide de longueur n est compatible avec des tableaux basés sur zéro et des tableaux compactés de n caractères. Pour de plus amples informations, voir A propos des types de données (Delphi).
Depuis RAD Studio 12.0, les littéraux chaîne peuvent dépasser 255 caractères ; en d’autres termes, les littéraux chaîne ne sont pas limités au type Pascal ShortString classique. Le langage ajoute le support des chaînes multilignes. Pour de plus amples information sur les chaînes multilignes, consultez notre page Types de chaînes (Delphi), sous Littéraux chaîne longs et multilignes.
Commentaires et directives de compilation
Les commentaires ne sont pas pris en compte par le compilateur sauf quand ils agissent comme séparateur (en délimitant des tokens consécutifs) ou comme directive de compilation.
Il y a plusieurs manières de construire des commentaires :
{ Text between left and right braces is a comment. }
(* Text between left-parenthesis-plus-asterisk and an
asterisk-plus-right-parenthesis is also a comment *)
// Text between double-slash and end of line is a comment.
Les commentaires de même type ne peuvent pas être imbriqués. Par exemple, (*{}*) fonctionne. Cette dernière forme est utile pour mettre en commentaire des sections de code contenant déjà des commentaires.
Voici quelques recommandations sur l’utilisation (comment et quand) des trois types de caractères de commentaire :
- Utilisez la double barre oblique (//) pour commenter des modifications temporaires effectuées durant la phase de développement. Vous pouvez utiliser le mécanisme
CTRL+/de l’éditeur de code afin d’insérer rapidement le caractère double barre oblique de commentaire tout en travaillant. - Utilisez les caractères parenthèse-étoile "(*...*)" à la fois pour les commentaires de développement et pour le commentaire d’un bloc de code contenant d’autres commentaires. Ce caractère de commentaire permet à plusieurs lignes de source, incluant d’autres types de commentaires, de ne pas être pris en compte par le compilateur.
- Utilisez les accolades ({}) pour la documentation du source que vous souhaitez conserver dans le code.
Un commentaire contenant le signe dollar ($) immédiatement après { ou (* est une directive de compilation. Par exemple :
{$WARNINGS OFF}
Indique au compilateur de ne pas générer de messages d’avertissement.