Langage de programmation - Free Pascal

Les jetons

Les jetons sont les éléments lexicaux de base du code source : ce sont les «mots» du langage : les caractères sont combinés en jetons selon les règles du langage de programmation. Il existe cinq classes de jetons :

Classes	Description
Mots réservés	Ce sont des mots ayant une signification fixe dans la langue. Ils ne peuvent pas être modifiés ou redéfinis.
Identifiants	Ce sont des noms de symboles définis par le programmeur. Ils peuvent être modifiés et réutilisés. Ils sont soumis aux règles de portée du langage.
Les opérateurs	Ce sont généralement des symboles pour des opérations mathématiques ou autres : +, -, *,...
Séparateurs	Il s'agit généralement d'un espace blanc.
Constantes	Les constantes numériques ou caractères sont utilisées pour désigner les valeurs réelles dans le code source, telles que 1 (constante entière) ou 2,3 (constante flottante) ou «Constante de chaîne de caractères» (une chaîne de caractères : un morceau de texte).

Dans cette page nous décrivons tous les mots réservés en Free Pascal, ainsi que les différentes manières de désigner des chaînes de caractères, des nombres, des identifiants,...

Symboles

Le Free Pascal autorise tous les caractères, chiffres et certains symboles de caractères spéciaux dans un fichier source Pascal.

Les caractères suivants ont une signification particulière :

' + - * / = < > [ ] . , ( ) : ^ @ { } $ # & %

et les paires de caractères suivantes également :

<< >> ** <> >< <= >= := += -= *= /= (* *) (. .) //

Lorsqu'elle est utilisée dans un spécificateur d'intervalle, la paire de caractères (. équivaut au crochet gauche [. De même, la paire de caractères .) est équivalente au crochet droit ]. Lorsqu'elle est utilisée pour les délimiteurs de commentaires, la paire de caractères (* équivaut à l'accolade gauche { et la paire de caractères *) est équivalente à l'accolade droite }. Ces paires de caractères conservent leur signification normale dans les expressions de chaîne de caractères.

Commentaires

Les commentaires sont des éléments du code source étant complètement supprimés par le compilateur. Ils n'existent que pour le programmeur, afin qu'il puisse expliquer certains morceaux de code. Pour le compilateur, c'est comme si les commentaires n'étaient pas présents.

Le morceau de code suivant illustre un commentaire :



(* La fonction Beaute renvoie un résultat intéressant *)

Function Beaute:Integer;

L'utilisation de (* et *) comme délimiteurs de commentaires date des tout premiers jours du langage Pascal. Il a été remplacé principalement par l'utilisation de { et } comme délimiteurs de commentaires, comme dans l'exemple suivant :



{ La fonction Beaute renvoie un résultat intéressant }

Function Beaute:Integer;

Le commentaire peut également s'étendre sur plusieurs lignes :



{

Ma fonction Beaute renvoie un résultat intéressant,

mais seulement si le paramètre A est inférieur à B.

}

Function Beaute(A,B:Integer):Integer;

Des commentaires sur une seule ligne peuvent également être faits avec le délimiteur // tirant ses origines du C++ :



// La fonction Beaute renvoie un résultat intéressant

Function Beaute:Integer;

Le commentaire s'étend du caractère // jusqu'à la fin de la ligne. Ce type de commentaire a été introduit par Borland dans le compilateur Delphi. Le Free Pascal prend en charge l'utilisation de commentaires imbriqués. Les constructions suivantes sont des commentaires valides :



(* Ceci est un commentaire à l'ancienne *)

{ Ceci est un commentaire Turbo Pascal }

// Ceci est un commentaire Delphi. Tout est ignoré jusqu'à la fin de la ligne.

Les méthodes suivantes sont valables pour imbriquer des commentaires :



{ Commentaire 1 (* commentaire 2 *) }

(* Commentaire 1 { commentaire 2 } *)

{ commentaire 1 // Commentaire 2 }

(* commentaire 1 // Commentaire 2 *)

// commentaire 1 (* commentaire 2 *)

// commentaire 1 { commentaire 2 }

Les deux derniers commentaires doivent être sur une seule ligne. Les deux suivants donneront des erreurs :



// Commentaire valide { Commentaire plus valide !!

}



// Commentaire valide (* Commentaire plus valide !!

*)

Le compilateur réagira avec une erreur «caractère invalide» lorsqu'il rencontrera de telles constructions, quel que soit le commutateur -Mtp.

Remarque : En mode TP et Delphi, les commentaires imbriqués ne sont pas autorisés, pour une compatibilité maximale avec le code existant de ces compilateurs.

Mots réservés

Les mots réservés font partie du langage Pascal et, en tant que tels, ne peuvent pas être redéfinis par le programmeur. Tout au long des diagrammes de syntaxe, ils seront indiqués en caractères gras. Pascal n'est pas sensible à la casse, le compilateur acceptera donc toute combinaison de lettres majuscules ou minuscules pour les mots réservés.

Le Free Pascal fait une distinction entre les mots réservés Turbo Pascal et Delphi. En mode TP, seuls les mots réservés Turbo Pascal sont reconnus, mais ceux Delphi peuvent être redéfinis. Par défaut, Free Pascal reconnaît les mots réservés Delphi.

Mots réservés Turbo Pascal

Les mots-clefs suivants existent en mode Turbo Pascal :

absolute
and
array
asm
begin
case
const
constructor
destructor
div
do
downto
else
end
file
for
function
goto
if
implementation
in
inherited
inline
interface
label
mod
nil
not
object
of
operator
or
packed
procedure
program
record
reintroduce
repeat
self
set
shl
shr
string
then
to
type
unit
until
uses
var
while
with
xor

Mots réservés Objet Pascal

Les mots réservés d'Object Pascal (utilisés en mode Delphi ou Objfpc) sont les mêmes que ceux de Turbo Pascal, avec les mots clefs supplémentaires suivants :

as
class
dispinterface
except
exports
finalization
finally
initialization
inline
is
library
on
out
packed
property

Modificateurs

Ce qui suit est une liste de tous les modificateurs. Ce ne sont pas exactement des mots réservés dans le sens où ils peuvent être utilisés comme identifiants, mais à des endroits spécifiques, ils ont une signification particulière pour le compilateur, c'est-à-dire, par exemple, le compilateur les considère comme faisant partie du langage Pascal.

absolute
abstract
alias
assembler
bitpacked
break
cdecl
continue
cppdecl
cvar
default
deprecated
dynamic
enumerator
experimental
export
external
far
far16
forward
generic
helper
implements
index
interrupt
iocheck
local
message
name
near
nodefault
noreturn
nostackframe
oldfpccall
otherwise
overload
override
pascal
platform
private
protected
public
published
read
register
reintroduce
result
safecall
saveregisters
softfloat
specialize
static
stdcall
stored
strict
unaligned
unimplemented
varargs
virtual
winapi
write

Remarque : Les types prédéfinis comme Byte, Boolean et les constantes comme MaxInt ne sont pas des mots réservés. Ce sont des identifiants, déclarés dans l'unité System. Cela signifie que ces types peuvent être redéfinis dans d'autres unités. Le programmeur n'est cependant pas encouragé à le faire, car cela entraînerait beaucoup de confusion.

Remarque : Depuis la version 2.5.1 du Free Pascal, il est possible d'utiliser des mots réservés comme identifiants en les faisant échapper par le signe &. Cela signifie que ce qui suit est possible&nbps;:



Var

 &var:Integer;

 
BEGIN

 &var:=1;

 Writeln(&var);

END.

cependant, il n'est pas recommandé d'utiliser cette fonctionnalité dans un nouveau code, car elle rend le code moins lisible. Il est principalement destiné à corriger l'ancien code lorsque la liste des mots réservés change et englobe un mot qui n'était pas encore réservé.

Identifiants

Les identifiants désignent les noms définis par le programmeur pour des constantes, des types, des variables, des procédures et des fonctions, des unités et des programmes spécifiques. Tous les noms définis par le programmeur dans le code source - à l'exclusion des mots réservés - sont désignés comme identifiants.

Les identifiants sont constitués de 1 à 127 caractères significatifs (lettres, chiffres et caractère de soulignement), dont le premier doit être une lettre (a à z ou A à Z) ou un trait de soulignement (_). Le diagramme suivant donne la syntaxe de base des identifiants.

Comme les mots réservés en Pascal, les identifiants ne sont pas sensibles à la casse, c'est-à-dire :



maprocedure;



MaProcedure;

se reporte à la même procédure.

Remarque : Depuis la version 2.5.1, il est possible de spécifier un mot réservé comme identifiant en le faisant précéder d'une esperluette (&). Cela signifie que ce qui suit est possible :



Program TestDo;

 
Procedure &do;Begin

End;

 
BEGIN

&do;

END.

Le mot réservé do est utilisé comme identifiant pour la déclaration ainsi que pour l'appel de la procédure do.

Directives d'indice

La plupart des identifiants (constantes, variables, fonctions ou méthodes, propriétés) peuvent avoir une directive d'indice ajoutée à leur définition :

Chaque fois qu'un identifiant marqué avec une directive d'indice est rencontré ultérieurement par le compilateur, un avertissement sera affiché, correspondant à l'indice spécifié.

Directive d'indice	Description
deprecated	L'utilisation de cet identifiant est obsolète, utilisez plutôt une alternative. Le mot-clef obsolète peut être suivi d'une constante de chaîne de caractères avec un message. Le compilateur affichera ce message chaque fois que l'identifiant est rencontré.
experimental	L'utilisation de cet identifiant est expérimentale : il peut être utilisé pour signaler de nouvelles fonctionnalités qui doivent être utilisées avec prudence.
platform	Il s'agit d'un identifiant dépendant de la plateforme : il peut ne pas être défini sur toutes les plateformes.
unimplemented	Cela doit être utilisé uniquement sur les fonctions et les procédures. Il doit être utilisé pour signaler qu'une fonctionnalité particulière n'a pas encore été implémentée.

Voici des exemples :



Const

 AConst=12 deprecated;

 
Var

 P:Integer platform;

 
Function Something:Integer; Experimental;Begin

 Something:=P+AConst;

End;

 
BEGIN

 Something;

END.

Cela donnerait le résultat suivant :

testhd.pp(11,15) Warning: Symbol "p" is not portable
testhd.pp(11,22) Warning: Symbol "AConst" is deprecated
testhd.pp(15,3) Warning: Symbol "Something" is experimental

Les directives Hint peuvent suivre toutes sortes d'identifiants : unités, constantes, types, variables, fonctions, procédures et méthodes.

Nombres

Les nombres sont par défaut notés en notation décimale. Les nombres réels (ou décimaux) sont écrits en utilisant une notation technique ou scientifique (par exemple 0,314E1).

Pour les constantes de type entier, Free Pascal prend en charge quatre formats :

Format décimal normal (base 10). C'est le format standard.
Format hexadécimal (base 16), de la même manière que le Turbo Pascal. Pour spécifier une valeur constante au format hexadécimal, ajoutez-la au début du signe dollar ($). Ainsi, le $FF hexadécimal est égal à 255 décimal. Notez que la casse est insignifiante lors de l'utilisation de constantes hexadécimales.
Depuis la version 1.0.7, le format Octal (base 8) est également pris en charge. Pour spécifier une constante au format octal, ajoutez-la au début d'une esperluette (&). Par exemple, 15 est spécifié en notation octale sous la forme &17.
Notation binaire (base 2). Un nombre binaire peut être spécifié en le faisant précéder d'un signe de pourcentage (%). Ainsi, 255 peut être spécifié en notation binaire sous la forme %11111111.

Les diagrammes suivants montrent la syntaxe des nombres :

Remarque : Les notations Octale et Binaire ne sont pas supportées en mode de compatibilité TP ou Delphi.

Étiquettes

Une étiquette (LABEL) est le nom d'un emplacement dans le code source vers lequel il est possible d'accéder depuis un autre emplacement avec une instruction goto. Une étiquette est un identifiant standard ou une séquence de chiffres.

Remarque : Les commutateurs -Sg ou -Mtp doivent être spécifiés avant de pouvoir utiliser des étiquettes. Par défaut, Free Pascal ne prend pas en charge les instructions label et goto. La directive {$GOTO ON} peut également être utilisée pour autoriser l'utilisation d'étiquettes et de l'instruction goto.

Voici des exemples d'étiquettes valides :



Label

 123,

 abc;

Chaînes de caractères

Une chaîne de caractères (ou chaîne en abrégé) est une séquence de zéro ou plusieurs caractères (de la taille d'un octet), entourée de guillemets simples et sur une seule ligne du code source du programme : aucun retour chariot littéral ou caractère de saut de ligne ne peut apparaître dans la chaîne de caractères.

Un ensemble de caractères sans rien entre les guillemets ('') est une chaîne de caractères vide.

La chaîne de caractères se compose de caractères ASCII standard de 8 bits ou de caractères Unicode (normalement codés en UTF-8). La chaîne de caractères de contrôle peut être utilisée pour spécifier des caractères qui ne peuvent pas être saisis sur un clavier, comme #27 pour le caractère d'échappement.

Le guillemet simple peut être intégré dans la chaîne en le tapant deux fois. La construction C consistant à échapper des caractères dans la chaîne de caractères (à l'aide d'une barre oblique inverse) n'est pas prise en charge en Pascal.

Les constantes de chaîne de caractères suivantes sont valides :



'C''est une chaîne de caractères pascale'

''

'a'

'Un caractère de tabulation : '#9' est facile à intégrer'

La chaîne de caractères suivante est invalide :



'la chaîne commence ici
et continue ici'

La chaîne de caractères ci-dessus doit être saisie comme :



'la chaîne de caractères commence ici'#13#10' et continue ici'

ou :



'la chaîne de caractères commence ici '#10' et continue ici'

sur Unix (y compris Mac OS X), et comme :



'la chaîne de caractères commence ici '#13' et continue ici'

sur un système d'exploitation classique de type Mac.

Il est possible d'utiliser d'autres ensembles de caractères dans les chaînes de caractères : dans ce cas la page de codes du fichier source doit être spécifiée avec la directive {$CODEPAGE XXX} ou avec l'option de ligne de commande -Fc pour le compilateur. Dans ce cas, les caractères d'une chaîne de caractères seront interprétés comme des caractères de la page de codes spécifiée.

Dernière mise à jour : Mercredi, le 28 juin 2023

Section courante

A propos

Section administrative du site