Eléments syntaxiques fondamentaux (Delphi)

De RAD Studio
Aller à : navigation, rechercher

Remonter à Eléments syntaxiques fondamentaux - Index


Les éléments syntaxiques fondamentaux, appelés des 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 des caractères Unicode pour son jeu de caractères, comprenant des 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 appelés des blancs.

Le compilateur RAD Studio acceptera un fichier codé en UCS-2 ou UCS-4 si le fichier contient une marque d'ordre des octets (BOM). La vitesse de compilation est toutefois susceptible d'être pénalisée par l'utilisation de formats autres que UTF-8. Tous les caractères d'un fichier source codé UCS-4 doivent être représentables en UCS-2 sans paires de substitution. Les codages UCS-2 avec paires de substitution (incluant GB18030) sont acceptés uniquement 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, par habitude et par souci 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, ayant des significations similaires (les paires de symboles {} et (* *) sont des caractères de commentaires qui sont décrits plus loin dans Commentaires et directives de compilation):

Symboles spéciaux   Symboles spéciaux similaires

[    ]

(.   .)

{    }

(*    *)


Le crochet ouvrant [ est équivalent à la paire de caractères parenthèse ouvrante suivie d'un point (..

Le crochet droit ] est similaire à la paire de caractères point suivie d'une parenthèse droite .).

L'accolade gauche { est similaire à la paire de caractères parenthèse gauche suivie d'un astérisque (*.

L'accolade droite } est similaire à la paire de caractères astérisque suivie d'une parenthèse droite *).

Remarque : Les caractères %, ?, \, !, " (guillemet), _ (souligné), | (barre oblique) et ~ (tilde) ne sont pas des caractères spéciaux.

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 d'espaces. Les caractères alphanumériques, les caractères Unicode, les chiffres et les caractères de soulignement sont autorisés après le premier caractère. Les mots réservés ne peuvent être utilisés comme identificateurs. Comme le langage Delphi ne tient pas compte des différences majuscules/minuscules, un identificateur comme CalculateValue peut être écrit dans n'importe laquelle des formes 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 de plus amples 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

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 au sein de la rubrique Déclarations et instructions (Delphi).

Identificateurs étendus

Il se peut que vous rencontriez des identificateurs (c'est-à-dire des types ou des méthodes dans une classe) de même nom qu'un mot réservé du langage Delphi. Par exemple, une classe peut posséder une méthode appelée begin. Les mots réservés de Delphi tels que begin ne peuvent pas être utilisés pour un nom d'identificateur.

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 pour un nom d'identificateur, vous devez utiliser son nom qualifié complet :

 var TMyType.type
 // Using a fully qualified name avoids ambiguity with {{Delphi}} language keyword.

Comme alternative abrégée, l'opérateur perluète (&) peut être utilisé pour résoudre les ambiguïtés entre identificateurs et mots réservés du langage Delphi. Le symbole & empêche un mot clé d'être analysé en tant que mot clé (c'est-à-dire, 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 nommage si vous préfixez le nom de l'identificateur avec une esperluette. Mais lorsque vous déclarez un identificateur de même nom qu'un mot clé, vous devez utiliser & :

 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 :

and

end

interface

record

var

array

except

is

repeat

while  

as

exports

label

resourcestring    

with        

asm

file

library3

set    

xor

begin

finalization   

mod

shl

           case

finally

nil

shr

           class

for

not

string

           const

function

object

then


constructor

goto

of

threadvar


destructor

if

or

to


dispinterface     

implementation    

packed

try


div

in

procedure    

type


do

inherited

program      

unit


downto

initialization   

property

until


else

inline

raise

uses


Remarque : Outre les mots spécifiés dans le tableau ci-dessus, private, protected, public, published et automated se comportent comme des mots réservés à l'intérieur des déclarations du type de classe, et sont traités ailleurs comme des directives. Les mots at et on ont aussi des significations spéciales, et doivent être traités comme des mots réservés. Les mots clés of object sont utilisés pour définir les pointeurs de méthodes.

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

public

stdcall

abstract

external

near1

published

strict

assembler12

far1

nodefault

read

stored

automated

final

operator10

readonly

unsafe

cdecl

forward

out

reference9

varargs

contains7

helper8

overload

register

virtual

default

implements

override

reintroduce

winapi6

delayed

index

package7

requires7

write

deprecated11

inline2

pascal


resident1

writeonly

dispid

library311

platform11

safecall


dynamic

local4

private

sealed5


experimental11

message

protected

static


Remarques :  1. far, near et resident sont obsolètes.  2. 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. 3. 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.  4. local était une directive Kylix et est ignoré pour Delphi pour Win32.  5. sealed est une directive de classe ayant la syntaxe : 'class sealed'. Une classe sealed ne peut pas être étendue ni dérivée (comme final dans C++). 6. winapi définit la convention d'appel de la plate-forme par défaut. Par exemple, sur Win32, winapi est identique à stdcall. 7. 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 de la syntaxe de package. 8. helper indique "assistance de classe pour". 9. reference indique une référence à une fonction ou à une procédure. 10. operator indique un opérateur de classe. 11. platform, deprecated, experimental et library sont des directives de conseil (ou d'avertissement).Ces directives produisent des avertissements à la compilation. 12. Les directives assembler et export n'ont pas de signification. Elles existent uniquement pour des raisons de compatibilité ascendante.

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, qui représente un commutateur ou une option affectant le comportement du compilateur. Une directive de compilation est entourée par des 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 préfixe signe dollar 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. Durant une assignation, si une valeur hexadécimale se trouve en dehors de la portée du type recevant, une erreur est déclenchée, sauf dans le cas du type Integer (32 bits) où un avertissement est déclenché. Dans ce cas, les valeurs dépassant la portée positive pour Integer sont considérées comme des valeurs négatives d'une manière cohérente avec la représentation entière en complément à 2.

Pour plus d'informations sur les types réels et entiers, voir A propos des types de données (Delphi). Pour de plus amples informations sur les types de données numériques, voir Constantes déclarées.

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 'Line 1' et 'Line 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).

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.

Voir aussi