Directives du compilateur

Le Free Pascal prend en charge les directives du compilateur dans le fichier source : essentiellement les mêmes directives que dans les compilateurs pascal Turbo Pascal, Delphi et Mac OS. Certains sont reconnus uniquement pour leur compatibilité et n'ont aucun effet.

Une directive de compilateur est toujours spécifiée sous forme de commentaire à l'aide d'accolades :

L'ancienne notation «(*» et «*)» ou la notation C++ «//» ne peut pas être utilisée pour les directives.

Le fait qu'une directive soit spécifiée comme un commentaire signifie qu'il ne s'agit pas d'une instruction Pascal. Cela signifie à son tour que si une directive inexistante est spécifiée, le compilateur ne génère pas d'erreur, il donne simplement un avertissement concernant une directive invalide/inconnue.

Il existe une distinction entre les directives locales et globales :

• Les directives locales prennent effet à partir du moment où elles sont rencontrées jusqu'à ce qu'elles soient modifiées par une autre directive ou la même directive avec un paramètre différent : elles peuvent être spécifiées plusieurs fois dans un fichier source.
• Les directives globales ont un effet sur tout le code compilé. Ils ne peuvent, en général, être spécifiés qu'une seule fois par fichier source. Cela signifie également que leur effet se termine lorsque l'unité courante est compilée ; l'effet ne se propage pas à une autre unité.

Certaines directives ne peuvent prendre qu'une valeur booléenne, un '+' pour les activer ou un '-' pour les désactiver. Ces directives sont également appelées commutateurs. De nombreux commutateurs ont également une forme longue. Si tel est le cas, le nom du formulaire long est également indiqué.

Pour les interrupteurs longs, le caractère + ou - pour activer ou désactiver l'option, peut être remplacé par les mots clefs ON ou OFF.

Ainsi {$I+} est équivalent à {$IOCHECKS ON} ou {$IOCHECKS +} et {$C-} est équivalent à {$ASSERTIONS OFF} ou {$ASSERTIONS -}

Les formes longues des commutateurs sont les mêmes que leurs homologues Delphi.

Il convient de mentionner que lorsque des valeurs par défaut sont indiquées, cela signifie des valeurs par défaut en l'absence d'un fichier de configuration. Les fichiers de configuration distribués avec FPC modifieront certaines des valeurs par défaut mentionnées ici.

Directives locales

Les directives locales peuvent apparaître plusieurs fois dans une unité ou un programme. Si elles ont un équivalent en ligne de commande, le paramètre de ligne de commande est restauré par défaut pour chaque fichier compilé. Les directives locales influencent le comportement du compilateur à partir du moment où elles sont rencontrées jusqu'au moment où un autre commutateur annule leur comportement, ou la fin de l'unité ou du programme en cours est atteinte.

$A ou $ALIGN : Aligner les données

La directive {$ALIGN} peut être utilisée pour sélectionner la stratégie d'alignement des données du compilateur pour les enregistrements. Il prend un argument numérique pouvant être 1, 2, 4, 8, 16 ou 32, spécifiant la limite d'alignement en octets. Pour ces valeurs, elle a le même effet que la directive {$PACKRECORDS}. Ainsi, ce qui suit :

est équivalent à :

En mode MACPAS, il peut en plus prendre les valeurs suivantes :

Ces valeurs ne sont pas disponibles dans la directive {$PACKRECORDS}

$A1, $A2,$A4 et $A8

Ces directives sont identiques à la directive $PACKRECORDS, mais elles ont le spécificateur d'alignement intégré dans la directive. Ainsi ce qui suit :

est équivalent à :

Notez que les cas particuliers de $PACKRECORDS ne peuvent pas être exprimés de cette façon.

$ASMMODE : mode assembleur (Intel 80x86 uniquement)

La directive {$ASMMODE XXX} informe le compilateur du type d'assembleur qu'il peut attendre dans un bloc asm. Le XXX doit être remplacé par l'un des éléments suivants :

Ces commutateurs sont locaux et conservent leur valeur jusqu'à la fin de l'unité compilée, sauf s'ils sont remplacés par une autre directive du même type. Le commutateur de ligne de commande correspondant à ce commutateur est -R.

Le lecteur assembleur par défaut est le lecteur AT&T.

$B ou $BOOLEVAL : Évaluation booléenne complète

Par défaut, le compilateur utilise une évaluation booléenne raccourcie, c'est-à-dire que l'évaluation d'une expression booléenne est arrêtée une fois que le résultat de l'expression totale est connu avec certitude. Le commutateur {$B} peut être utilisé pour modifier ce comportement : si son paramètre est +, le compilateur évaluera toujours tous les termes de l'expression. Si c'est - (valeur par défaut), le compilateur n'évaluera que le nombre de termes nécessaires pour déterminer le résultat de l'expression complète.

Ainsi, dans l'exemple suivant, la fonction BooleanFunction, ayant un résultat booléen, ne sera jamais appelée.

Une conséquence de cela est que toutes les actions supplémentaires effectuées par BooleanFunction ne sont pas exécutées. Si compilé avec {$B+}, alors BooleanFunction sera appelé de toute façon.

$C ou $ASSERTIONS : support des assertions

Le commutateur {$ASSERTIONS} détermine si les déclarations assert sont compilées dans le binaire ou non. Si le commutateur est activé, l'instruction :

Sera compilé dans le binaire. Si BooleanExpression prend la valeur False, la RTL vérifiera si AssertErrorProc est défini. S'il est défini, il sera appelé avec comme paramètres le message AssertMessage, le nom du fichier, le LineNumber et l'adresse. S'il n'est pas défini, une erreur d'exécution 227 est générée.

Le AssertErrorProc est défini comme :

Cela peut être utilisé principalement à des fins de débogage. L'unité système définit AssertErrorProc sur un gestionnaire affichant un message sur stderr et se termine simplement avec une erreur d'exécution 227. L'unité sysutils intercepte l'erreur d'exécution 227 et déclenche une exception EAssertionFailed.

$BITPACKING : Activer l'emballage en bits

La directive $BITPACKING indique au compilateur s'il doit utiliser le bitpacking ou non lorsqu'il rencontre le mot-clef compressé pour un type structuré. Les valeurs possibles sont ON et OFF. Si cette option est activée, le compilateur assemblera les structures bitpack lorsqu'il rencontrera le mot-clef Packed.

Dans l'exemple suivant, l'enregistrement TMyRecord sera bitpacké :

Noter que :

• La directive $BITPACKING est ignorée en mode macpas, où les enregistrements compressés sont toujours compressés.
• Le mot-clef bitpacked peut toujours être utilisé pour forcer le compactage au niveau du bit, quelle que soit la valeur de la directive $BITPACKING et quel que soit le mode.

$CALLING : spécifiez la convention d'appel

La directive {$CALLING } indique au compilateur quelle convention d'appel doit être utilisée si aucune n'est spécifiée :

Par défaut, c'est REGISTER. Les conventions d'appel suivantes existent :

Dans un cas particulier, DEFAULT peut être utilisé pour restaurer la convention d'appel par défaut.

$CHECKPOINTER : Vérifie les valeurs des pointeurs

La directive {$CHECKPOINTER} active (valeur ON) ou désactive (valeur OFF) la vérification du pointeur de tas. Si la vérification du pointeur de tas est activée et que le code est compilé avec l'option -gh (heaptrace) activée, une vérification est insérée lors du déréférencement d'un pointeur. La vérification vérifiera que le pointeur contient une valeur valide, c'est-à-dire qu'il pointe vers un emplacement accessible par le programme : la pile ou un emplacement dans le tas. Sinon, une erreur d'exécution 216 ou 204 est générée.

Si le code est compilé sans l'option -gh, cette directive n'a aucun effet. Notez que cela ralentit considérablement le code.

$CODEALIGN : définit l'alignement du code

Ce commutateur définit l'alignement du code. Il prend un argument qui spécifie l'alignement pour un type particulier de code généré par le compilateur. La forme générale est :

Où PARAM est le paramètre à régler et la valeur VAR est une valeur numérique spécifiant un alignement. PARAM peut être l'une des chaînes suivantes :

Par défaut, la taille d'une structure de données détermine l'alignement :

• Un SmallInt sera aligné sur 2 octets.
• Un LongInt sera aligné sur 4 octets.
• Un Int64 sera aligné sur 8 octets.

Avec les commutateurs ci-dessus, l'alignement minimum requis et un alignement maximum utilisé peuvent être spécifiés. L'alignement maximal autorisé n'a de sens que s'il est inférieur à la taille naturelle. c'est-à-dire qu'en définissant l'alignement maximum (par exemple VARMAX) sur 4, l'alignement est forcé à 4 octets au maximum : l'Int64 sera alors également aligné à 4 octets. Le SmallInt sera toujours aligné sur 2 octets.

Ces valeurs peuvent également être spécifiées sur la ligne de commande comme :

$COPERATORS : Autoriser les opérateurs de type C

Ce commutateur booléen détermine si les opérateurs d'affectation de type C sont autorisés. Par défaut, ces affectations ne sont pas autorisées. Après la déclaration suivante :

Les opérateurs suivants sont autorisés :

$DEFINE ou $DEFINEC : Définir un symbole

La directive :

définit le nom du symbole. Ce symbole reste défini jusqu'à la fin du module courant (c'est-à-dire l'unité ou le programme), ou jusqu'à ce qu'une directive de nom $UNDEF soit rencontrée.

Si le nom est déjà défini, cela n'a aucun effet. Le nom est insensible à la casse.

Les symboles définis dans une unité ne sont pas enregistrés dans le fichier d'unité, ils ne sont donc pas non plus exportés à partir d'une unité.

En mode Mac Pascal, la directive $DEFINEC est équivalente à la directive $DEFINE et est fournie pour la compatibilité Mac Pascal.

{$DEFINE} peut également être utilisé pour définir des macros ou des constantes de compilation :

redéfinira le modificateur standard cdecl en tant que stdcall.

La directive {$DEFINE} a un équivalent en ligne de commande, -d :

définira le nom du symbole. En utilisant :

on peut redéfinir le modificateur standard cdecl en stdcall depuis la ligne de commande.

$ELSE : Changer la compilation conditionnelle

Le {$ELSE} bascule entre la compilation et l'ignorance du texte source délimité par le {$IFxxx} précédent et le {$ENDIF} suivant. Tout texte après le mot-clef ELSE mais avant l'accolade est ignoré :

est le même que

Ceci est utile pour indiquer de quel commutateur il s'agit.

$ELSEC : basculer la compilation conditionnelle

En mode MACPAS, cette directive peut être utilisée comme alternative à la directive $ELSE. Il est pris en charge pour la compatibilité avec les compilateurs pascal Mac OS existants.

$ELSEIF ou $ELIFC : Changer la compilation conditionnelle

Cette directive peut être utilisée comme raccourci pour une nouvelle directive {$IF } dans une clause {$ELSE } :

est équivalent à :

La directive est suivie d'une expression comme celles reconnues par la directive {$IF }. La variante {$ELIFC} n'est autorisée qu'en mode MACPAS.

$ENDC : Terminer la compilation conditionnelle

En mode MACPAS, cette directive peut être utilisée comme alternative à la directive $ENDIF. Il est pris en charge pour la compatibilité avec les compilateurs pascal Mac OS existants.

$ENDIF : Fin de la compilation conditionnelle

La directive {$ENDIF} termine la compilation conditionnelle initiée par la dernière directive {$IFxxx}. Tout texte après le mot-clef ENDIF mais avant l'accolade fermante est ignoré :

est le même que :

Ceci est utile pour indiquer quel commutateur doit être terminé.

$ERROR ou $ERRORC : Génère un message d'erreur

Le code suivant :

affichera un message d'erreur lorsque le compilateur le rencontrera et augmentera le nombre d'erreurs du compilateur. Le compilateur continuera à compiler, mais aucun code ne sera émis.

La variante $ERRORC est fournie pour la compatibilité Mac Pascal.

$ENDREGION : Fin d'une région réductible

Cette directive est analysée pour la compatibilité Delphi mais sinon ignorée. Dans Delphi, il marque la fin d'une région réductible dans l'IDE.

$EXTENDEDSYM : ignoré

Cette directive est analysée pour la compatibilité Delphi mais sinon ignorée. Un avertissement s'affichera lorsque cette directive sera rencontrée.

$EXTERNALSYM : ignoré

Cette directive est analysée pour la compatibilité Delphi mais sinon ignorée.

$F : Fonctions lointaines ou courtes

Cette directive est reconnue pour sa compatibilité avec Turbo Pascal. Dans les modèles de programmation 32 bits et 64 bits, le concept d'appels courts et lointains n'a pas de sens, la directive est donc ignorée. Un avertissement s'affiche à l'écran, en guise de rappel.

A titre d'exemple, le morceau de code suivant :

Génère la sortie de compilateur suivant :

On peut voir que le niveau de verbosité a été défini pour afficher les avertissements.

Lors de la déclaration d'une fonction en tant que Far (ceci a le même effet que de la définir entre les directives {$F+} ...{$F-}), le compilateur génère également un avertissement :

La même histoire est vraie pour les procédures déclarées comme proches. L'avertissement affiché dans ce cas est :

$FATAL : Génère un message d'erreur fatale

Le code suivant :

affichera un message d'erreur lorsque le compilateur le rencontrera, et le compilateur arrêtera immédiatement le processus de compilation.

Ceci est principalement utile en conjonction avec les instructions {$IFDEF} ou {$IFOPT}.

$FPUTYPE : sélectionnez le type de coprocesseur

Cette directive sélectionne le type de coprocesseur utilisé pour effectuer des calculs en virgule flottante. La directive doit être suivie du type d'unité à virgule flottante. Les valeurs autorisées dépendent du CPU cible :

Cette directive correspond à l'option de ligne de commande -Cf.

$GOTO : Prise en charge de Goto et de l'étiquette

Si {$GOTO ON} est spécifié, le compilateur prendra en charge les instructions Goto et les déclarations Label. Par défaut, $GOTO OFF est supposé. Cette directive correspond à l'option de ligne de commande -Sg. A titre d'exemple, le code suivant peut être compilé :

Remarque : lors de la compilation du code assembleur à l'aide des lecteurs assembleur en ligne, toutes les étiquettes utilisées dans le code assembleur doivent être déclarées et la directive {$GOTO ON} doit être utilisée.

$H ou $LONGSTRINGS : Utiliser AnsiStrings

Si {$LONGSTRINGS ON} est spécifié, le mot-clef String (pas de spécificateur de longueur) sera traité comme AnsiString, et le compilateur traitera la variable correspondante comme une ansistring, et générera le code correspondant. Ce commutateur correspond à l'option de ligne de commande -Sh.

Par défaut, l'utilisation des ansistrings est désactivée, correspondant à {$H-}. L'unité System est compilée sans ansistrings, toutes ses fonctions acceptent des paramètres shortstring. Il en va de même pour toutes les unités RTL, à l'exception de l'unité sysutils, qui est compilée avec ansistrings.

Cependant, l'instruction {$MODE} influence la valeur par défaut de {$H} : une directive {$MODE DELPHI} implique une instruction {$H+}, tous les autres modes la désactivent. Par conséquent, vous devez toujours mettre {$H+} après une directive de mode. Ce comportement a changé, dans les anciennes versions de Free Pascal ce n'était pas le cas.

$HINT : Génère un message d'astuce

Si la génération d'astuces est activée, via l'option de ligne de commande -vh ou la directive {$HINTS ON}, alors :

affichera un message d'indication lorsque le compilateur le rencontrera. Par défaut, aucun conseil n'est généré.

$HINTS : émet des conseils

{$HINTS ON} active la génération d'astuces. {$HINTS OFF} désactive la génération d'astuces. Contrairement à l'option de ligne de commande -vh, il s'agit d'un commutateur local, utile pour vérifier des parties du code.

$HPPEMIT : ignoré

Cette directive est analysée pour garder la compatibilité avec Delphi mais sinon elle est ignorée.

$IF : Démarrer la compilation conditionnelle

La directive {$IF expr} continuera la compilation si l'expression booléenne expr est évaluée à True. Si la compilation est évaluée à False, alors la source est ignorée à la première directive {$ELSE} ou {$ENDIF}.

Le compilateur doit être capable d'évaluer l'expression au moment de l'analyse. Cela signifie que les variables ou les constantes définies dans la source ne peuvent pas être utilisées. Des macros et des symboles peuvent cependant être utilisés.

$IFC : Démarrer la compilation conditionnelle

En mode MACPAS, cette directive peut être utilisée comme alternative à la directive $IF. Il est pris en charge pour la compatibilité avec les compilateurs pascal Mac OS existants.

$IFDEF Name : Démarre la compilation conditionnelle

Si le symbole Name n'est pas défini, le {$IFDEF name} ignorera la compilation du texte le suivant jusqu'à la première directive {$ELSE} ou {$ENDIF}. Si Name est défini, la compilation continue comme si la directive n'était pas là.

La directive $IFDEF ne vérifiera que le premier mot de ce qui suit, tout le reste est ignoré. Cela signifie que le code après un :

et

et

ne sera analysé que si RED est défini. Les autres mots sont ignorés. En particulier, l'existence de BLUE ne sera pas vérifiée pour le dernier cas. Si vous devez vérifier plusieurs valeurs, vous devez utiliser la construction {$IF} à la place.

$IFNDEF : Démarrer la compilation conditionnelle

Si le symbole Name est défini, le {$IFNDEF name} ignorera la compilation du texte le suivant à la première directive {$ELSE} ou {$ENDIF}. Si elle n'est pas définie, la compilation continue comme si la directive n'était pas là.

Semblable à $IFDEF, la directive $IFNDEF ne vérifiera que le premier mot de ce qui suit, tout le reste est ignoré. Cela signifie que le code après a :

et

et

ne sera analysé que si RED n'est pas défini. Les autres mots sont ignorés. En particulier, l'existence de BLUE ne sera pas vérifiée pour le dernier cas. Si vous devez vérifier plusieurs valeurs, vous devez utiliser la construction {$IF} à la place.

$IFOPT : Démarrer la compilation conditionnelle

Le {$IFOPT switch} compilera le texte le suivant si le commutateur switch est actuellement dans l'état spécifié. S'il n'est pas dans l'état spécifié, la compilation continue après la directive {$ELSE} ou {$ENDIF} correspondante.

Par exemple :

Compilera l'instruction WriteLn uniquement si la génération des informations de type est activée. Remarque : La directive {$IFOPT} n'accepte que les options courtes, c'est-à-dire que {$IFOPT TYPEINFO} ne sera pas accepté.

$IMPLICITEXCEPTIONS : Génération de code de finalisation implicite

Le compilateur génère un cadre try...finally implicite autour de chaque procédure nécessitant l'initialisation ou la finalisation des variables, et finalise les variables dans le bloc finally. Cela ralentit ces procédures (jusqu'à 5 à 10% parfois). Avec cette directive, la génération de telles trames peut être désactivée. Il faut être prudent avec cette directive, car elle peut entraîner des fuites de mémoire si une exception se produit à l'intérieur de la routine. Par conséquent, il est réglé sur ON par défaut.

$INFO : Générer un message d'information

Si la génération d'informations est activée, via l'option de ligne de commande -vi, alors :

affichera un message d'information lorsque le compilateur le rencontrera.

Ceci est utile en conjonction avec la directive {$IFDEF}, pour afficher des informations sur la partie du code étant compilée.

$INLINE : Autoriser le code en ligne.

La directive {$INLINE ON} indique au compilateur que le modificateur de procédure Inline doit être autorisé. Les procédures déclarées en ligne sont copiées aux emplacements où elles sont appelées. Cela a pour effet qu'il n'y a pas d'appel de procédure réel, le code de la procédure est simplement copié là où la procédure est nécessaire, cela se traduit par une vitesse d'exécution plus rapide si la fonction ou la procédure est beaucoup utilisée.

Par défaut, les procédures en ligne ne sont pas autorisées. Cette directive doit être spécifiée pour utiliser du code en ligne. La directive est équivalente au commutateur de ligne de commande -Si.

$INTERFACES: spécifiez le type d'interface.

La directive {$INTERFACES} indique au compilateur ce qu'il devrait prendre en tant qu'interface parent d'une déclaration d'interface ne spécifiant pas explicitement une interface parent. Par défaut, l'interface Windows COM IUnknown est utilisée. D'autres implémentations d'interfaces (CORBA ou Java) n'ont pas nécessairement cette interface, et pour de tels cas, cette directive peut être utilisée. Il accepte les trois valeurs suivantes :

$I ou $IOCHECKS : vérification des entrées/sorties

La directive {$I-} ou {$IOCHECKS OFF} indique au compilateur de ne pas générer de code de vérification d'entrée/sortie dans le programme. Par défaut, le compilateur génère un code de vérification d'entrée/sortie. Ce comportement peut être contrôlé globalement avec le commutateur -Ci.

Lors de la compilation à l'aide du commutateur de compilateur -Ci, le compilateur Free Pascal insère un code de vérification d'entrée/sortie après chaque appel d'entrée/sortie dans le code. Si une erreur s'est produite lors de l'entrée ou de la sortie, une erreur d'exécution sera générée. Ce commutateur peut également être utilisé pour éviter ce comportement.

Si aucun code de vérification d'entrée/sortie n'est généré, pour vérifier si quelque chose s'est mal passé, la fonction IOResult peut être utilisée pour voir si tout s'est déroulé sans problème.

Inversement, {$I+} réactivera la vérification des erreurs, jusqu'à ce qu'une autre directive soit rencontrée qui la désactive à nouveau.

Remarque : Lorsqu'une erreur d'entrée/sortie se produit et que la génération du code de vérification d'entrée/sortie est désactivée, toutes les opérations d'entrées/sorties suivantes sont ignorées jusqu'à ce que le code d'état d'erreur d'entrées/sorties soit effacé.

Lorsque la fonction IOResult de l'unité centrale est appelée, elle renvoie le code d'état IO actuel et le réinitialise.

L'effet de ceci est que IOResult doit être vérifié après chaque opération d'entrée/sortie pour que les opérations d'entrées/sorties suivantes réussissent.

L'utilisation la plus courante de ce commutateur est de vérifier si l'ouverture d'un fichier s'est déroulée sans problème, comme dans le morceau de code suivant :

$IEEEERRORS : Activer la vérification des erreurs IEEE pour les constantes

Cette directive booléenne active ou désactive la vérification des erreurs IEEE (virgule flottante) pour les constantes. C'est l'équivalent local du commutateur de ligne de commande global -C3.

Ce qui suit active la vérification des erreurs IEEE (virgule flottante) pour les constantes :

$I ou $INCLUDE : Inclure le fichier

La directive {$I filename} ou {$INCLUDE filename} indique au compilateur de lire d'autres instructions à partir du fichier filename. Les instructions qui y sont lues seront insérées comme si elles apparaissaient dans le fichier courant.

Si le fichier avec le nom de fichier donné existe, il sera inclus. Si aucune extension n'est donnée, le compilateur ajoutera l'extension .pp au fichier et essaiera avec ce nom de fichier. Aucune autre extension n'est essayée.

Le nom du fichier peut être placé entre guillemets simples, ils ne seront pas considérés comme faisant partie du nom du fichier. En effet, si le nom du fichier contient un espace, alors il doit être entouré de guillemets simples :

essaiera d'inclure le fichier my file name ou my file name.pp.

va essayer d'inclure le fichier my ou my.pp.

Si le nom de fichier est un astérisque (*), le compilateur utilisera le nom de l'unité ou du programme comme nom de fichier et essaiera de l'inclure. Le code suivant :

inclura le fichier testi ou testi.pp s'ils existent.

Des précautions doivent être prises avec ce mécanisme, car le nom de l'unité doit déjà correspondre au nom de fichier de l'unité, ce qui signifie très probablement que l'unité s'inclura elle-même de manière récursive.

Les fichiers d'inclusion peuvent être imbriqués, mais pas à une profondeur infinie. Le nombre de fichiers est limité au nombre de descripteurs de fichiers disponibles pour le compilateur Free Pascal.

Contrairement à Turbo Pascal, les fichiers d'inclusion peuvent traverser des blocs. C'est à dire, un bloc peut commencer dans un fichier (avec un mot-clef Begin) et se terminer dans un autre (avec un mot-clef End). La plus petite entité dans un fichier inclus doit être un jeton, c'est-à-dire un identifiant, un mot-clef ou un opérateur.

Le compilateur recherchera le fichier à inclure aux emplacements suivants :

• Il cherchera dans le chemin spécifié dans le nom du fichier inclus.
• Il cherchera dans le répertoire où se trouve le fichier source actuel.
• il cherchera dans tous les répertoires spécifiés dans le chemin de recherche du fichier inclus.

Des répertoires peuvent être ajoutés au chemin de recherche du fichier inclus avec l'option de ligne de commande -Fi.

$I ou $INCLUDE : Inclut les informations du compilateur

Sous cette forme :

la directive {$INCLUDE} insère une chaîne de caractères constante dans le code source.

Ici, XXX peut être l'un des suivants :

Si XXX n'est rien de ce qui précède, il est supposé être le nom d'une variable d'environnement. Sa valeur sera extraite de l'environnement, s'il existe, sinon une chaîne vide est insérée. Par conséquent, cela générera une macro avec la valeur du spécificateur XXX, comme s'il s'agissait d'une chaîne (ou, dans le cas de LINENUM, un entier).

Par exemple, le programme suivant :

Crée la sortie suivante :

Remarque : Notez que l'inclusion de DATE et TIME ne forcera pas le compilateur à recompiler l'unité à chaque utilisation : la date et l'heure seront la date et l'heure de la dernière compilation de l'unité.

$J ou $WRITEABLECONST : Autoriser les affectations aux constantes typées

Ce commutateur booléen indique au compilateur si les affectations aux constantes typées sont autorisées ou non. La valeur par défaut est d'autoriser les affectations aux constantes typées.

L'instruction suivante désactivera les affectations aux constantes typées :

Après ce changement, l'instruction suivante ne sera plus compilée :

Mais une variable initialisée compilera toujours :

$L ou $LINK : Lien fichier objet

La directive {$L filename} ou {$LINK filename} indique au compilateur que le fichier filename doit être lié au programme. Cela ne peut pas être utilisé pour les bibliothèques.

Le compilateur recherchera ce fichier aux emplacements suivants :

• Dans le chemin spécifié dans le nom du fichier objet.
• Dans le répertoire où se trouve le fichier source actuel.
• Dans tous les répertoires spécifiés dans le chemin de recherche du fichier objet.

Des répertoires peuvent être ajoutés au chemin de recherche du fichier objet avec l'option de ligne de commande -Fo.

Sur les systèmes LINUX et sur les systèmes d'exploitation avec des systèmes de fichiers sensibles à la casse (tels que les systèmes UNIX), le nom est sensible à la casse et doit être saisi exactement tel qu'il apparaît sur votre système.

Remarque : veillez à ce que le fichier objet que vous liez soit dans un format que l'éditeur de liens comprenne. De quel format il s'agit, dépend de la plate-forme sur laquelle vous vous trouvez. Taper ld ou ld -help sur la ligne de commande donne une liste des formats que ld connaît.

D'autres fichiers et options peuvent être transmis à l'éditeur de liens à l'aide de l'option de ligne de commande -k. Plusieurs de ces options peuvent être utilisées, et elles seront transmises à l'éditeur de liens, dans l'ordre dans lequel elles ont été spécifiées sur la ligne de commande, juste avant les noms des fichiers objets qui doivent être liés.

$LIBEXPORT : Ignoré

Cette directive est reconnue pour les compilateurs pascal Darwin, mais est autrement ignorée.

$LINKFRAMEWORK : Lien vers un cadre d'application

Le {$LINKFRAMEWORK name} sera lié à un cadre d'application nommé name. Ce commutateur est disponible uniquement sur la plate-forme Darwin.

$LINKLIB : Lien vers une bibliothèque

Le {$LINKLIB name} sera lié à un nom de bibliothèque. Cela a pour effet de transmettre -lname à l'éditeur de liens. A titre d'exemple, considérons l'unité suivante :

Si l'on émettait la commande :

où foo.pp a l'unité ci-dessus dans sa clause uses, alors le compilateur lierait le programme à la bibliothèque c, en passant l'éditeur de liens l'option -lc.

La même chose peut être obtenue en supprimant la directive linklib dans l'unité ci-dessus et en spécifiant -k-lc sur la ligne de commande :

Notez que l'éditeur de liens recherchera la bibliothèque dans le chemin de recherche de la bibliothèque de l'éditeur de liens : il ne faut jamais spécifier un chemin complet vers la bibliothèque. Le chemin de recherche de la bibliothèque de l'éditeur de liens peut être défini avec l'option de ligne de commande -Fl.

$M ou $TYPEINFO : Génère les informations de type

Pour les classes compilées dans l'état {$M+} ou {$TYPEINFO ON}, le compilateur générera des informations de type d'exécution (RTTI). Toutes les classes descendantes d'une classe ayant été compilée dans l'état {$M+} obtiendront également des informations RTTI. Toute classe utilisée comme champ ou propriété dans une section publiée obtiendra également des informations RTTI.

Par défaut, aucune information de type d'exécution n'est générée pour les sections publiées, ce qui les rend équivalentes aux sections publiques. Ce n'est que lorsqu'une classe (ou l'une de ses classes parentes) a été compilée dans l'état {$M+} que le compilateur générera un RTTI pour les méthodes et les propriétés de la section publiée.

L'objet TPersistent étant présent dans l'unité de classes (partie de la RTL) est généré dans l'état {$M+}. La génération de RTTI permet aux programmeurs de diffuser des objets et d'accéder aux propriétés publiées des objets, sans connaître la classe réelle de l'objet.

Les informations de type d'exécution sont accessibles via l'unité TypInfo, faisant partie de la bibliothèque d'exécution Free Pascal.

Remarque : Le système de flux de données implémenté par Free Pascal nécessite que tous les composantes de flux de données soient des descendants de TPersistent. Il est possible de créer des classes avec des sections publiées qui ne descendent pas de TPersistent, mais ces classes ne seront pas diffusées correctement par le système de diffusion de l'unité Classes.

$MACRO : Autoriser l'utilisation de macros.

Dans l'état {$MACRO ON}, le compilateur permet l'utilisation de macros de style C (mais pas aussi élaborées). Les macros fournissent un moyen de substitution de texte simple. Cette directive est équivalente à l'option de ligne de commande -Sm. Par défaut, les macros ne sont pas autorisées.

$MAXFPUREGISTERS : Nombre maximum de registres FPU pour les variables

La directive {$MAXFPUREGISTERS XXX} indique au compilateur combien de variables à virgule flottante peuvent être conservées dans les registres du processeur à virgule flottante sur un microprocesseur Intel x86. Ce commutateur est ignoré sauf si l'optimisation -Or (utiliser les variables de registre) est utilisée.

C'est assez délicat car la pile Intel FPU est limitée à 8 entrées. Le compilateur utilise un algorithme heuristique pour déterminer combien de variables doivent être placées sur la pile : dans les procédures feuille, il est limité à 3 et dans les procédures non feuille à 1. Mais dans le cas d'un arbre d'appel profond ou, pire encore, d'une procédure récursive , cela peut toujours conduire à un débordement de pile FPU, de sorte que l'utilisateur peut indiquer au compilateur combien de variables (virgule flottante) doivent être conservées dans les registres.

La directive accepte les paramètres suivants :

Remarque : Cette directive est valable jusqu'à la fin de la procédure en cours.

$MESSAGE : Génère un message défini par l'utilisateur

La directive $MESSAGE permet d'insérer un avertissement, un conseil ou une note définis par l'utilisateur. Elle est équivalente à l'une des directives $FATAL, $ERROR, $WARNING, $HINT ou $NOTE. Il doit être suivi d'un des mots ERROR WARNING HINT ou NOTE, puis du message à afficher, comme suit :

Cela affichera un message d'avertissement lorsque le compilateur le rencontrera. L'effet est le même que la directive {$WARNING}. Cela signifie que les éléments suivants :

est tout à fait équivalent à :

Notez que si le commutateur -Sew est utilisé, le message WARNING sera traité comme une erreur et le compilateur s'arrêtera.

$MINENUMSIZE : spécifiez la taille minimale de l'énumération

Cette directive est fournie pour la compatibilité Delphi : elle a le même effet que la directive $PACKENUM.

$MINFPCONSTPREC : spécifie la précision constante en virgule flottante

Ce commutateur est l'équivalent du commutateur de ligne de commande -CF. Normalement, le compilateur définit la précision d'une constante à virgule flottante sur la précision minimale requise pour la représenter exactement.

Ce commutateur peut être utilisé pour s'assurer que le compilateur n'abaisse jamais la précision en dessous de la valeur spécifiée. Les valeurs prises en charge sont 32, 64 et DEFAULT. 80 n'est pas pris en charge pour des raisons d'implémentation.

Notez que cela n'a rien à voir avec la précision réelle utilisée par les calculs : le type de la variable déterminera la précision utilisée. Ce commutateur détermine uniquement avec quelle précision une déclaration de constante est entreposée :

Le type de la constante ci-dessus sera double même s'il peut être représenté exactement en utilisant Single.

Notez qu'une valeur de 80 (précision étendue) n'est pas prise en charge.

$MMX : Prise en charge d'Intel MMX (Intel 80x86 uniquement)

Free Pascal prend en charge l'optimisation pour le processeur MMX Intel (voir aussi la page Prise en charge d'Intel MMX).

Cela optimise certaines parties de code pour le microprocesseur MMX Intel, améliorant ainsi considérablement la vitesse. La vitesse est surtout remarquée lors du déplacement de grandes quantités de données. Les choses changeant sont :

• Les données dont la taille est un multiple de 8 octets sont déplacées à l'aide de l'instruction assembleur MOVQ, déplaçant 8 octets à la fois.

Remarque : Le support MMX n'est pas émulé sur les systèmes non-MMX, c'est-à-dire que si le microprocesseur n'a pas les extensions MMX, les optimisations MMX ne peuvent pas être utilisées.

Lorsque le support MMX est activé, il n'est pas autorisé de faire de l'arithmétique en virgule flottante. Il est permis de déplacer des données à virgule flottante, mais aucune arithmétique ne peut être effectuée. Si des calculs en virgule flottante doivent être effectués de toute façon, le support MMX doit d'abord être désactivé et le FPU doit être effacé à l'aide de la fonction emms de l'unité centrale.

L'exemple suivant rendra cela plus clair :

$NODEFINE : Ignoré

Cette directive est analysée pour la compatibilité Delphi mais est sinon ignorée.

$NOTE : Générer un message de note

Si la génération de notes est activée, via l'option de ligne de commande -vn ou la directive {$NOTES ON}, alors :

affichera un message de note lorsque le compilateur le rencontrera.

$NOTES : émettre des notes

{$NOTES ON} active la génération de notes. {$NOTES OFF} désactive la génération de notes. Contrairement à l'option de ligne de commande -vn, il s'agit d'un commutateur local, utile pour vérifier des parties du code.

Par défaut, {$NOTES} est désactivé.

$OBJECTCHECKS : vérifier l'objet

Ce commutateur booléen détermine si le code pour tester le pointeur SELF est inséré dans les méthodes. Par défaut, il est désactivé. Par exemple :

Si le pointeur SELF est NIL, une erreur d'exécution 210 (contrôle d'intervalle) sera générée. Ce commutateur est également activé par l'option de ligne de commande -CR.

$OPTIMIZATION : Activer les optimisations

Ce commutateur permet l'optimisation. Il peut prendre les valeurs possibles suivantes :

Les chaînes de caractères suivantes sont prises en charge :

Vous pouvez désactiver une certaine optimisation en préfixant la valeur par NO. Exemple :

est équivalent à :

Plusieurs optimisations peuvent être spécifiées avec :

Désactivez le déroulement de la boucle avec :

Ce commutateur est également activé par le commutateur de ligne de commande -Ooxxx. Notez le petit 'o' : il s'agit de -Oo suivi du nom du commutateur.

$PACKENUM ou $Z : Taille minimale du type d'énumération

Cette directive indique au compilateur le nombre minimum d'octets qu'il doit utiliser lors de l'entreposage des types énumérés. Il est de la forme suivante :

Où le formulaire avec $MINENUMSIZE est pour la compatibilité Delphi. xxx peut être 1, 2 ou 4, ou NORMAL ou DEFAULT (ou 0).

La taille d'énumération par défaut dépend du mode de compilation :

• En mode Delphi et TP, la taille est 1.
• En mode MacPas, la taille est 2.
• Dans tous les autres modes, la valeur par défaut est 4.

Comme forme alternative, on peut utiliser {$Z1}, {$Z2} {$Z4}. La forme {$Z} prend un argument +/-, où + est équivalent à {$Z4} et - est équivalent à {$Z1}.

Donc le code suivant :

utilisera 1 octet pour entreposer une variable de type Days, alors qu'il utiliserait normalement 4 octets. Le code ci-dessus est équivalent à :

ou équivalent à :

$PACKRECORDS : Alignement des éléments d'enregistrement

Cette directive contrôle l'alignement des octets des éléments dans une définition de type d'enregistrement, d'objet ou de classe. Il est du format suivant :

Où n est l'un des 1, 2, 4, 8, 16, 32, C, NORMAL ou DEFAULT (ou 0).

Cela signifie que les éléments d'un enregistrement ayant un alignement ABI supérieur à n seront alignés sur des limites de n octets. Les éléments dont la taille est inférieure ou égale à n seront alignés sur l'alignement ABI pour la plate-forme. La valeur spéciale C est utilisée pour spécifier l'alignement comme par le compilateur C de la plate-forme. Il doit être utilisé lors de la création d'unités d'importation pour C structuré.

L'alignement par défaut (pouvant être sélectionné avec DEFAULT) est l'alignement ABI.

Vous trouverez plus d'informations à ce sujet et un exemple de programme dans le guide de référence, dans la section sur les types d'enregistrement.

Les raccourcis suivants peuvent être utilisés pour cette directive :

$PACKSET : spécifiez la taille de l'ensemble

La directive $PACKSET prend un paramètre numérique de 1, 2, 4 ou 8. Ce nombre détermine le nombre d'octets utilisés pour entreposer un ensemble : le compilateur arrondit le nombre d'octets nécessaires pour entreposer l'ensemble au multiple le plus proche de le paramètre PACKSET, à l'exception que les ensembles de 3 octets sont toujours arrondis à des ensembles de 4 octets.

Les autres valeurs autorisées sont FIXED, DEFAULT (ou 0) ou NORMAL. Avec ces valeurs, le compilateur entrepose les ensembles avec moins de 32 éléments dans 4 octets, et les ensembles avec moins de 256 éléments dans 32 octets.

$POP : restaure les paramètres du compilateur

La directive $POP restaure les valeurs de toutes les directives locales du compilateur avec les dernières valeurs entreposées dans la pile des paramètres. Les paramètres sont ensuite supprimés de la pile.

Les paramètres peuvent être entreposés sur la pile avec la directive $PUSH.

Notez que les paramètres globaux ne sont pas restaurés par cette directive.

$PUSH : Enregistrer les paramètres du compilateur

La directive $PUSH enregistre les valeurs actuelles de toutes les directives locales du compilateur sur la pile des paramètres. Jusqu'à 20 ensembles de paramètres peuvent être entreposés sur la pile.

Les paramètres peuvent être restaurés à partir de la pile à l'aide de la directive $POP.

Notez que les paramètres globaux (chemins de recherche, etc.) ne sont pas enregistrés par cette directive.

La pile des paramètres est conservée à travers les unités, c'est-à-dire que lorsque le compilateur commence à compiler une nouvelle unité, la pile n'est pas vidée.

$Q ou $OV ou $OVERFLOWCHECKS : contrôle de débordement

La directive {$Q+} ou {$OV+} (mode MACPAS uniquement) ou {$OVERFLOWCHECKS ON} active la vérification du dépassement d'entier. Cela signifie que le compilateur insère du code pour vérifier le débordement lors des calculs avec des entiers. Lorsqu'un débordement se produit, la bibliothèque d'exécution génère une erreur d'exécution 215 : elle affiche un message Overflow at xxx et quitte le programme avec le code de sortie 215.

Remarque : Le comportement de la vérification des débordements n'est pas le même qu'en Turbo Pascal puisque toutes les opérations arithmétiques sont effectuées via des valeurs 32 bits ou 64 bits. De plus, les procédures système standard Inc() et Dec() sont vérifiées pour le débordement dans Free Pascal, alors qu'elles ne le sont pas dans Turbo Pascal.

L'utilisation du commutateur {$Q-} (ou du commutateur {$OV-} en mode MACPAS) désactive la génération du code de contrôle de débordement.

La génération du code de vérification de débordement peut également être contrôlée à l'aide de l'option de compilateur de ligne de commande -Co.

Dans Delphi, la vérification de débordement n'est commutable qu'au niveau de la procédure. En Free Pascal, la directive {$Q} peut être utilisée au niveau de l'expression.

Remarque : La vérification de débordement et la vérification de l'intervalle sont fondamentalement la même erreur, sauf que l'une est détectée en vérifiant le drapeau de débordement du microprocesseur et l'autre en comparant explicitement les intervalles.

Sur les microprocesseurs 64 bits, l'arithmétique des entiers est effectuée à l'aide d'entiers 64 bits Parce que, par convention en Pascal, les expressions sont évaluées à l'aide du type d'entier signé natif, sur les microprocesseurs 64 bits, l'arithmétique des entiers est effectuée à l'aide d'entiers 64 bits.

Par conséquent, les débordements ne peuvent pas se produire lors de l'exécution d'une arithmétique 32 bits, mais une erreur d'intervalle se produit lors de l'affectation du résultat à une variable 32 bits.

$R ou $RANGECHECKS : Vérification de l'intervalle

Par défaut, le compilateur ne génère pas de code pour vérifier les plages d'indices de tableau, les types d'énumération, les types de sous-intervalle,... La spécification du commutateur {$R+} indique à l'ordinateur de générer du code pour vérifier ces indices. Si, au moment de l'exécution, un type d'index ou d'énumération est spécifié en dehors de la plage déclarée du compilateur, une erreur d'exécution est générée et le programme se termine avec le code de sortie 201. Cela peut se produire lors d'un transtypage. (implicite ou explicite) sur un type énumération ou sous-intervalle.

Le commutateur {$RANGECHECKS OFF} indique au compilateur de ne pas générer de code de vérification de l'intervalle. Cela peut entraîner un comportement défectueux du programme, mais aucune erreur d'exécution ne sera générée.

Remarque : Les fonctions standard val et Read vérifieront également les intervalles lorsque l'appel est compilé en mode {$R+}.

Dans Delphi, la vérification de l'intervalle n'est commutable qu'au niveau de la procédure. En Free Pascal, la directive {$R } peut être utilisée au niveau de l'expression.

Remarque : Voir la note sur l'évaluation des expressions sur les systèmes 64 bits et les conséquences pour la vérification de l'intervalle et la vérification de débordement.

$REGION : marque le début de la région réductible

La directive $REGION est reconnue pour la compatibilité Delphi uniquement. Dans Delphi, il sert à marquer le début d'une région réductible dans l'IDE.

$R ou $RESOURCE : inclure la ressource

Cette directive inclut une ressource dans le binaire. Le paramètre de cette directive est le fichier de ressources à inclure dans le binaire :

Inclura le fichier icons.res en tant que ressource dans le binaire. Jusqu'à la version 2.2.N, les ressources sont prises en charge uniquement pour Windows (les ressources natives sont utilisées) et pour les plateformes utilisant les binaires ELF (Linux, BSD). Depuis la version 2.3.1, des ressources ont été implémentées pour toutes les plates-formes prises en charge.

L'astérisque peut être utilisé comme espace réservé pour le nom de fichier de l'unité/du programme actuel :

inclura myunit.res.

$SATURATION : Opérations de saturation (Intel 80x86 uniquement)

Cela ne fonctionne que sur le compilateur Intel et le support MMX doit être activé ({$MMX +}) pour que cela ait un effet.

$SAFEFPUEXCEPTIONS Attendre lors de l'entreposage des valeurs FPU sur Intel x86

Cette directive booléenne contrôle la génération de code pour entreposer les valeurs FPU. S'il est activé, le compilateur insère un opcode FWAIT après avoir stocké une valeur à virgule flottante. Cela garantit que toute erreur est signalée immédiatement. Le code généré est plus lent, mais les erreurs sont signalées à l'endroit où l'instruction a été exécutée.

$SCOPEDENUMS Contrôle l'utilisation des types d'énumération délimités

La directive booléenne $SCOPEDENUMS contrôle la manière dont les valeurs de type énumération sont insérées dans les tables de symboles. Les valeurs d'énumération sont toujours insérées dans une portée.

Dans son état par défaut (OFF), les valeurs d'énumération sont en outre insérées directement dans la table des symboles de la portée actuelle. Cela signifie que les 2 affectations suivantes sont valides :

Si la directive est définie sur ON, les valeurs d'énumération ne sont pas insérées dans la portée globale. Cela signifie que l'affectation doit être faite comme suit :

c'est-à-dire que dans l'état ON de la directive, la valeur doit toujours être précédée du nom du type.

$SETC : Définir et attribuer une valeur à un symbole

En mode MACPAS, cette directive peut être utilisée pour définir les symboles du compilateur. C'est une alternative à la directive $DEFINE pour les macros. Il est pris en charge pour la compatibilité avec les compilateurs Mac OS Pascal existants. Il définira un symbole avec une certaine valeur (appelée expression de variable de compilateur).

La syntaxe de l'expression est similaire aux expressions utilisées dans les macros, mais l'expression doit être évaluée au moment de la compilation par le compilateur. Cela signifie que seuls certains opérateurs arithmétiques et logiques de base peuvent être utilisés, et quelques possibilités supplémentaires telles que les opérateurs TRUE, FALSE et UNDEFINED :

Le symbole d'affectation := peut être remplacé par le symbole =.

Notez que cette commande ne fonctionne qu'en mode MACPAS, mais indépendamment de l'option de ligne de commande -Sm ou de la directive {$MACRO }.

$S : vérification de la pile

La directive {$S+} indique au compilateur de générer un code de vérification de pile. Cela génère du code pour vérifier si un débordement de pile s'est produit, c'est-à-dire pour voir si la pile a dépassé sa taille maximale autorisée. Si la pile dépasse la taille maximale, une erreur d'exécution est générée et le programme se termine avec le code de sortie 202.

Spécifier {$S-} désactivera la génération du code de vérification de la pile.

Le commutateur de compilateur de ligne de commande -Ct a le même effet que la directive {$S+}.

Par défaut, aucune vérification de pile n'est effectuée.

Remarque : La vérification de la pile ne peut être utilisée que pour fournir une aide lors du débogage, pour essayer de suivre les routines utilisant une quantité excessive de mémoire locale. Il n'est pas prévu et ne peut pas être utilisé pour gérer en toute sécurité de telles erreurs. Peu importe que la gestion des erreurs se fasse par le biais de la gestion des exceptions ou autrement.

Lorsqu'une erreur de pile se produit, il s'agit d'une erreur fatale et l'application ne peut pas continuer à fonctionner correctement, ni dans un environnement de production, ni en débogage.

$STOP : Génère un message d'erreur fatale

Le code suivant :

affichera un message d'erreur lorsque le compilateur le rencontrera. Le compilateur arrêtera immédiatement le processus de compilation.

Elle a le même effet que la directive {$FATAL}

$STRINGCHECKS : Ignoré

Cette directive est reconnue pour la compatibilité Delphi, mais est actuellement ignorée. Dans Delphi, il contrôle la génération de code vérifiant l'intégrité des variables de chaîne de caractères et des paramètres.

$T ou $TYPEDADDRESS : Opérateur d'adresse typée (@)

Dans l'état {$T+} ou {$TYPEDADDRESS ON}, l'opérateur @, lorsqu'il est appliqué à une variable, renvoie un résultat de type ^T, si le type de la variable est T. Dans l'état {$T-}, l'opérateur result est toujours un pointeur non typé, étant compatible avec tous les autres types de pointeurs.

Par exemple, le code suivant ne compilera pas :

Le compilateur donnera une erreur d'incompatibilité de type :

Par défaut cependant, l'opérateur d'adresse renvoie un pointeur non typé.

$UNDEF ou $UNDEFC : Annuler la définition d'un symbole

La directive :

Annule la définition du nom du symbole s'il a déjà été défini. Le nom est insensible à la casse. En mode Mac Pascal, $UNDEFC est équivalent à $UNDEF et est fourni pour la compatibilité Mac Pascal.

$V ou $VARSTRINGCHECKS : vérification de chaîne de caractères de variables

Le {$VARSTRINGCHECKS } détermine la rigueur du compilateur lors de la vérification de la compatibilité des types de chaînes de caractères pour les chaînes de caractères passées par référence. Lorsqu'il est à l'état + ou ON, le compilateur vérifie que les chaînes de caractères passées en paramètres sont du même type de chaîne de caractères que les paramètres déclarés de la procédure. Par défaut, le compilateur suppose que toutes les chaînes courtes sont de type compatible. C'est-à-dire que le code suivant compilera :

Les types de Arg et S sont à proprement parler incompatibles : le paramètre Arg est une chaîne de caractères de longueur 10, et la variable S est une chaîne de caractères de longueur 12 : la valeur sera silencieusement tronquée en une chaîne de caractères de longueur 10. Dans le {$ V+}, ce code déclenchera une erreur du compilateur :

Notez que cela ne concerne que les chaînes passées par référence, pas les chaînes de caractères passées par valeur.

$W ou $STACKFRAMES : Génère des cadres de pile

La directive de commutateur {$W} contrôle la génération des cadres de pile. Dans l'état ON, le compilateur générera un cadre de pile pour chaque procédure ou fonction.

Dans l'état OFF, le compilateur omettra la génération d'un cadre de pile si la procédure ou la fonction satisfait les conditions suivantes :

• il n'a pas de paramètres.
• il n'a pas de variables locale
s.
• ce n'est pas une procédure assembleur, c'est-à-dire qu'elle ne doit pas avoir de asm ...end ; bloc.
• ce n'est pas un constructeur ou un destructeur.

Le cadre de pile ne sera omis que si toutes ces conditions sont satisfaites.

$WAIT : attend que la touche Entrée soit enfoncée

Si le compilateur rencontre un :

directive, il ne reprendra la compilation qu'après que l'utilisateur aura appuyé sur la touche Enter. Si la génération de messages d'information est activée, alors le compilateur affichera le message suivant :

avant d'attendre une pression sur une touche.

Remarque : Cela peut interférer avec les processus de compilation automatique. Il ne doit être utilisé qu'à des fins de débogage du compilateur.

$WARN : Contrôle l'émission d'avertissements

Cette directive permet d'activer ou de désactiver sélectivement l'émission d'avertissements. Il prend la forme suivante :

ON ou + active l'émission de l'avertissement. Les valeurs OFF ou - suppriment l'avertissement. ERROR transforme l'avertissement en erreur et le compilateur le traitera comme tel.

L'IDENTIFIER est le nom d'un message d'avertissement. Les noms suivants sont reconnus :

Outre les identifiants de texte ci-dessus, l'identificateur peut également être un numéro de message. Les numéros des messages sont affichés lorsque l'option de ligne de commande -vq est utilisée.

$WARNING : Génère un message d'avertissement

Si la génération d'avertissements est activée, via l'option de ligne de commande -vw ou la directive {$WARNINGS ON}, alors :

affichera un message d'avertissement lorsque le compilateur le rencontrera.

$WARNINGS : Émet des avertissements

{$WARNINGS ON} active la génération d'avertissements. {$WARNINGS OFF} désactive la génération d'avertissements. Contrairement à l'option de ligne de commande -vw, il s'agit d'un commutateur local, utile pour vérifier des parties de votre code. Par défaut, aucun avertissement n'est émis.

$Z1, $Z2 et $Z4

Ce commutateur est l'équivalent du commutateur {$PACKENUM }.

Directives globales

Les directives globales affectent l'ensemble du processus de compilation d'une seule unité de compilation (programme, unité, bibliothèque). Ils ont également un équivalent en ligne de commande, étant donné pour chacune des directives. Ils doivent être spécifiés avant la première instruction différente de la clause program, unit ou library dans un fichier source, sinon ils n'auront aucun effet.

$APPID : spécifiez l'ID de l'application.

Utilisé sur le Palm OS uniquement, il peut être configuré pour spécifier le nom de l'application, pouvant être affiché sur le Palm uniquement. Cette directive n'a de sens que dans un fichier source de programme, pas dans une unité.

$APPNAME : spécifiez le nom de l'application.

Utilisé sur le Palm OS uniquement, il peut être défini pour spécifier le nom de l'application pouvant être affiché sur le Palm uniquement. Cette directive n'a de sens que dans un fichier source de programme, pas dans une unité.

$APPTYPE : spécifiez le type d'application.

Cette directive n'est actuellement prise en charge que sur les cibles suivantes : Win32, Mac, OS2 et AmigaOS. Sur les autres cibles, la directive est ignorée.

Le {$APPTYPE XXX} accepte un paramètre spécifiant quel type d'application est compilé. Il peut prendre les valeurs suivantes :

Des précautions doivent être prises lors de la compilation des applications GUI ; les fichiers d'entrée et de sortie ne sont pas disponibles dans une application GUI et toute tentative de lecture ou d'écriture dans ceux-ci entraînera une erreur d'exécution.

Il est possible de déterminer le type d'application d'une application WINDOWS ou AMIGA lors de l'exécution. La constante IsConsole, déclarée dans les unités système Win32 et Amiga comme :

contient True si l'application est une application console, False si l'application est une application GUI.

$CODEPAGE : définit la page de code source

Ce commutateur définit la page de code du reste du fichier source. La page de codes n'est prise en compte que lors de l'interprétation de chaînes de caractires littérales, le code réel doit être en US-ASCII. Le paramètre de ce commutateur est le nom de la page de codes à utiliser.

La page de code 'UTF-8' peut être spécifiée comme 'UTF-8' ou 'UTF8'. La liste des pages de code prises en charge est la liste des pages de code prises en charge par l'unité charset de la RTL.

$COPYRIGHT spécifier les informations de droit d'auteur

Ceci est destiné à la version NETWARE du compilateur : il spécifie les informations de droit d'auteur pouvant être visualisées sur un module pour un système d'exploitation Netware. Par exemple :

$D ou $DEBUGINFO : Symboles de débogage

Lorsque ce commutateur est activé, le compilateur insère des informations de débogage GNU dans l'exécutable. L'effet de ce commutateur est le même que le commutateur de ligne de commande -g. Par défaut, l'insertion d'informations de débogage est désactivée.

$DESCRIPTION : Description de l'application

Ce commutateur est reconnu pour la compatibilité uniquement, mais est complètement ignoré par le compilateur. À un stade ultérieur, ce commutateur peut être activé.

$E : Émulation de coprocesseur

Cette directive contrôle l'émulation du coprocesseur. Il n'y a pas d'équivalent en ligne de commande pour cette directive.

Remarque : Par défaut, l'émulation est activée pour les cibles non Unix. Pour les cibles Unix, l'émulation en virgule flottante (si nécessaire) est gérée par le système d'exploitation et est désactivée par défaut.

$EXTENSION : Extension du binaire généré.

Cette directive peut apparaître dans un fichier source de programme ou de bibliothèque : elle définit l'extension du binaire/de la bibliothèque générés. Le point initial (parfois associé à l'extension) peut ne pas être présent. Exemple :

définira l'extension sur 'cgi'.

$FRAMEWORKPATH : spécifiez le chemin du cadre d'application

Cette option sert à spécifier le chemin de recherche du cadre d'application sur Darwin, où le compilateur recherche les fichiers du cadre d'application. Utilisé comme :

il ajoutera XXX au chemin du cadre d'application. La valeur XXX peut contenir un ou plusieurs chemins, séparés par des points-virgules ou des deux-points.

$G : Générer le code 80286

Cette option est reconnue pour la compatibilité Turbo Pascal, mais est ignorée, car le compilateur ne fonctionne que sur les microprocesseurs 32 bits et 64 bits.

$IMAGEBASE : Spécifiez l'emplacement de base de l'image DLL.

Cette option peut être utilisée pour définir l'emplacement de base d'une DLL sur les systèmes Windows. La directive a besoin d'un emplacement mémoire en option (utilisez $ pour spécifier une valeur hexadécimale). C'est l'équivalent de l'option de ligne de commande -WB.

Ce qui suit définit l'emplacement de base sur 0x00400000 :

$INCLUDEPATH : spécifiez le chemin d'inclusion

Cette option sert à spécifier le chemin d'inclusion, où le compilateur recherche les fichiers d'inclusion. Utilisé comme :

il ajoutera XXX au chemin d'inclusion. La valeur XXX peut contenir un ou plusieurs chemins, séparés par des points-virgules ou des deux-points. Par exemple :

ajoutera les répertoires ../inc et ../i386 au chemin d'inclusion du compilateur. Le compilateur cherchera le fichier strings.inc dans ces deux répertoires et inclura le premier fichier trouvé. Cette directive est équivalente au commutateur de ligne de commande -Fi.

La prudence est de mise lors de l'utilisation de cette directive : si vous distribuez des fichiers, les emplacements des fichiers peuvent ne pas être les mêmes que sur votre machine ; de plus, la structure du répertoire peut être différente. En général, il serait juste de dire que vous devriez éviter d'utiliser des chemins absolus. Au lieu de cela, il convient d'utiliser uniquement des chemins relatifs, comme dans l'exemple ci-dessus.

$L ou $LOCALSYMBOLS : informations sur les symboles locaux

Ce commutateur (à ne pas confondre avec la directive locale de liaison de fichiers {$L file}) est reconnu pour la compatibilité Turbo Pascal, mais est ignoré. La génération des informations de symbole est contrôlée par le commutateur $D.

$LIBPREFIX : Spécifiez le préfixe du nom de fichier de la bibliothèque.

La directive LIBPREFIX a une fonction similaire à celle des directives de compilation {$EXTENSION } et {$LIBSUFFIX } : elle définit le préfixe de la bibliothèque. C'est par défaut 'lib' sur Unix, et vide sur Windows. Le nom est simplement ajouté au nom du fichier.

Exemple :

se traduira par un nom de fichier librarytl.so sur Linux, ou librarytl.dll sur Windows.

$LIBRARYPATH : spécifiez le chemin de la bibliothèque

Cette option sert à spécifier le chemin de la bibliothèque, où l'éditeur de liens recherche les bibliothèques statiques ou dynamiques. {$LIBRARYPATH XXX} ajoutera XXX au chemin de la bibliothèque. XXX peut contenir un ou plusieurs chemins, séparés par des points-virgules ou des deux-points. Par exemple :

ajoutera les répertoires /usr/X11/lib et /usr/local/lib au chemin de la bibliothèque de l'éditeur de liens. L'éditeur de liens recherchera la bibliothèque libX11.so dans ces deux répertoires et utilisera le premier fichier trouvé. Cette directive est équivalente au commutateur de ligne de commande -Fl.

La prudence est de mise lors de l'utilisation de cette directive : si vous distribuez des fichiers, les emplacements des bibliothèques peuvent ne pas être les mêmes que sur votre machine ; de plus, la structure du répertoire peut être différente. En général, il serait juste de dire que vous devriez éviter d'utiliser cette directive. Si vous n'êtes pas sûr, il est préférable d'utiliser des makefiles et des variables makefile.

$LIBSUFFIX : définit le suffixe de la bibliothèque

Semblable aux directives {$EXTENSION } et {$LIBPREFIX }, la directive $LIBSUFFIX définit le suffixe de la bibliothèque. Ceci est généralement utilisé pour les numéros de version, étant simplement ajoutés au nom du fichier de sortie, suivis de l'extension. Exemple :

se traduira par un nom de fichier libtl-1.2.3.so sur Linux, ou libtl-1.2.3.dll sur Windows.

$MAXSTACKSIZE : définit la taille maximale de la pile

Le {$MAXSTACKSIZE} définit la taille de pile maximale pour un exécutable sur les systèmes Windows. Il a besoin d'un paramètre, la taille (en octets) de la pile. La valeur maximale est $7FFFFFFF, la valeur minimale est 2048 ou la valeur de $MINSTACKSIZE si elle a été spécifiée.

L'exemple suivant définit la taille maximale de la pile sur $FFFFFF octets :

$M ou $MEMORY : Tailles de mémoire

Ce commutateur peut être utilisé pour définir le tas et la taille de la pile. Son format est le suivant :

où StackSize et HeapSize doivent être deux valeurs entières, supérieures à 1024. Le premier nombre définit la taille de la pile et le second la taille du tas. Le paramètre de taille de pile est ignoré sur les plates-formes Unix à moins que la vérification de pile ne soit activée : dans ce cas, le code de vérification de pile utilisera la taille définie ici comme taille de pile maximale.

Sur ces systèmes, en plus de la taille de la pile définie ici, le système d'exploitation ou l'environnement d'exécution peut avoir défini d'autres limites (éventuellement plus strictes) sur la taille de la pile à l'aide des appels système ulimit du système d'exploitation.

Les deux nombres peuvent être définis sur la ligne de commande à l'aide des commutateurs -Ch et -Cs.

$MINSTACKSIZE : Définir la taille minimale de la pile

Le {$MINSTACKSIZE} définit la taille de pile minimale pour un exécutable sur les systèmes Windows. Il a besoin d'un paramètre, la taille (en octets) de la pile. Ce doit être un nombre supérieur à 1024.

L'exemple suivant définit la taille de pile minimale sur 2 048 octets :

$MODE : définit le mode de compatibilité du compilateur

Le {$MODE} définit le mode de compatibilité du compilateur. Cela équivaut à définir l'une des options de ligne de commande -So, -Sd, -Sp ou -S2. Il a les paramètres suivants :

$MODESWITCH : sélection des fonctions du mode

Depuis FPC 2.3.1, la directive {$MODESWITCH} peut être utilisée pour sélectionner certaines des fonctionnalités qu'une directive {$MODE } sélectionnerait.

Il peut être utilisé pour activer des fonctionnalités linguistiques qui ne seraient autrement pas disponibles dans le mode actuel. Par exemple, vous programmez peut-être en mode TP, mais souhaitez utiliser les paramètres Out, qui ne sont disponibles qu'en mode Delphi.

La directive {$MODESWITCH } active ou désactive les fonctionnalités de mode individuelles sans changer le mode actuel du compilateur.

Ce commutateur est un commutateur global et peut être utilisé partout où le commutateur {$MODE} peut être utilisé. La syntaxe est la suivante :

Les deux premiers activeront la fonctionnalité XXX, le dernier la désactivera. La fonctionnalité XXX peut être l'une des suivantes :

D'où ce qui suit :

Activera la prise en charge du type de paramètre out en mode TP. Cela équivaut à :

$N : Traitement numérique

Ce commutateur est reconnu pour la compatibilité Turbo Pascal, mais est sinon ignoré, car le compilateur utilise toujours le coprocesseur pour les mathématiques à virgule flottante.

$O : Optimisations de niveau 2

Dans les versions antérieures de FPC, ce commutateur était reconnu pour la compatibilité Turbo Pascal, mais était par ailleurs ignoré : le concept de code superposé n'est pas nécessaire dans les programmes 32 bits ou 64 bits.

Dans les nouvelles versions de FPC (certainement à partir de la 2.0.0), ce commutateur est devenu un commutateur compatible Delphi : il a la même signification que le commutateur {$OPTIMIZATION ON/OFF}, activant ou désactivant les optimisations de niveau 2.

$OBJECTPATH : Spécifiez le chemin de l'objet.

Cette option sert à spécifier le chemin de l'objet, où le compilateur recherche les fichiers objets. {$OBJECTPATH XXX} ajoutera XXX au chemin de l'objet. XXX peut contenir un ou plusieurs chemins, séparés par des points-virgules ou des deux-points.

Par exemple :

ajoutera les répertoires ../inc et ../i386 au chemin de l'objet du compilateur. Le compilateur cherchera le fichier strings.o dans ces deux répertoires et liera le premier fichier trouvé dans le programme. Cette directive est équivalente au commutateur de ligne de commande -Fo.

La prudence est de mise lors de l'utilisation de cette directive : si vous distribuez des fichiers, les emplacements des fichiers peuvent ne pas être les mêmes que sur votre machine ; de plus, la structure du répertoire peut être différente. En général, il serait juste de dire que vous devriez éviter d'utiliser des chemins absolus, mais plutôt des chemins relatifs, comme dans l'exemple ci-dessus. N'utilisez cette directive que si vous êtes certain des emplacements où résident les fichiers. Si vous n'êtes pas sûr, il est préférable d'utiliser des makefiles et des variables makefile.

$P ou $OPENSTRINGS : Utiliser des chaînes ouvertes

Si ce commutateur est activé, tous les paramètres de fonction ou de procédure de type chaîne sont considérés comme des paramètres de chaîne de caractères ouverte ; ce paramètre n'a d'effet que pour les chaînes courtes, pas pour les ansistrings.

Lors de l'utilisation de chaînes ouvertes, le type déclaré de la chaîne peut être différent du type de chaîne réellement transmis, même pour les chaînes transmises par référence. La taille déclarée de la chaîne transmise peut être examinée avec l'appel High(P).

Par défaut, l'utilisation d'openstrings est désactivée.

$PASCALMAINNAME : définit le nom du point d'entrée

La directive {$PASCALMAINNAME NNN} définit le nom du symbole assembleur du point d'entrée du programme ou de la bibliothèque sur NNN. Cette directive est l'équivalent du commutateur de ligne de commande -XM. Dans des circonstances normales, il ne devrait pas être nécessaire d'utiliser ce commutateur.

$PIC : Générer ou non le code PIC

La directive {$PIC } prend un paramètre booléen et indique au compilateur s'il doit générer un PIC (Position Independent Code) ou non. Cette directive est l'équivalent du commutateur de ligne de commande -Cg.

Cette directive n'est utile que sur les plates-formes Unix : les unités doivent être compilées à l'aide du code PIC si elles sont censées se trouver dans une bibliothèque. Pour les programmes, l'utilisation du code PIC n'est pas nécessaire, mais cela ne fait pas de mal non plus (bien que le code PIC soit plus lent). Ce qui suit :

indique au compilateur de compiler MyUnit en utilisant le code PIC.

$POINTERMATH : Autoriser l'utilisation du pointeur mathématique

Par défaut, l'arithmétique du pointeur est activée dans les modes FPC/OBJFPC et désactivée dans le mode DELPHI. La directive $POINTERMATH ON/OFF peut être utilisée pour basculer le support arithmétique des pointeurs. Les types déclarés alors que $POINTERMATH ON est en vigueur prennent également en charge l'arithmétique de pointeur.

Cette directive booléenne active ou désactive l'utilisation de l'arithmétique de pointeur dans les expressions impliquant des pointeurs. Lorsqu'elle est activée, la différence de 2 pointeurs est une expression entière valide et une valeur entière peut être ajoutée à une valeur de pointeur.

Ce qui suit :

indique au compilateur de générer une erreur chaque fois que le pointeur de math apparaît dans une expression.

$PROFILE : Profilage

Cette directive active ou désactive la génération de code de profilage. C'est l'équivalent de l'option de ligne de commande -gp. La valeur par défaut est OFF. Cette directive n'a de sens que dans un fichier source de programme, pas dans une unité.

$SCREENNAME : Spécifiez le nom de l'écran

Cette directive peut être utilisée pour les cibles Netware Novell afin de spécifier le nom d'écran. Le paramètre est le nom d'écran à utiliser.

Définit le nom d'écran de l'application actuelle sur "Mon bel écran".

$SETPEFLAGS : spécifie les drapeaux de l'exécutable PE

L'exécutable $SETPEFLAGS définit les drapeaux PE sous Windows. Ces drapeaux sont écrits dans le fichier d'en-tête PE binaire. Il attend une constante numérique comme paramètre, cette constante sera écrite dans le bloc d'en-tête.

Dans des circonstances normales, le compilateur déterminera lui-même les valeurs des drapeaux PE à écrire dans le fichier binaire, mais cette directive peut être utilisée pour remplacer le comportement du compilateur.

$SMARTLINK : Utiliser les liens intelligents

Une unité étant compilée dans l'état {$SMARTLINK ON} sera compilée de manière à pouvoir être utilisée pour le SMARTLINK. Cela signifie que l'unité est découpée en morceaux logiques : chaque procédure est placée dans son propre fichier objet, et tous les fichiers objets sont rassemblés dans une grande archive. Lorsque vous utilisez une telle unité, seuls les morceaux de code dont vous avez vraiment besoin ou que vous appelez seront liés dans votre programme, réduisant ainsi considérablement la taille de votre exécutable.

Attention : l'utilisation d'unités SMARTLINK ralentit le processus de compilation, car un fichier objet distinct doit être créé pour chaque procédure. Si vous avez des unités avec de nombreuses fonctions et procédures, cela peut prendre du temps, d'autant plus si vous utilisez un assembleur externe (l'assembleur est appelé pour assembler chaque procédure ou bloc de code de fonction séparément).

La directive SMARTLINK doit être spécifiée avant la partie de déclaration d'unité :

Cette directive est équivalente au commutateur de ligne de commande -CX.

$SYSCALLS : Sélectionne la convention d'appel système sur Amiga/MorphOS

Cette directive définit la convention d'appel système à utiliser sur un système MorphOS ou Amiga. La directive a besoin d'un paramètre, devant être l'un des suivants :

• LEGACY
• SYSV
• SYSVBASE
• BASESYSV
• R12BASE

La directive générera un avertissement si elle est utilisée sur un autre système.

$THREADNAME : définit le nom du processus léger dans Netware

Cette directive peut être définie pour spécifier le nom du processus léger lors de la compilation pour Netware.

$UNITPATH : spécifiez le chemin de l'unité.

Cette option sert à spécifier le chemin de l'unité, où le compilateur recherche les fichiers d'unité. {$UNITPATH XXX} ajoutera XXX au chemin de l'unité. XXX peut contenir un ou plusieurs chemins, séparés par des points-virgules ou des deux-points.

Par exemple :

ajoutera les répertoires ../units et ../i386/units au chemin de l'unité du compilateur : ces répertoires sont relatifs au fichier unité dans lequel la directive apparaît. Le compilateur cherchera le fichier strings.ppu dans ces deux répertoires, et liera le premier fichier trouvé dans le programme. Cette directive est équivalente au commutateur de ligne de commande -Fu.

La prudence est de mise lors de l'utilisation de cette directive : si vous distribuez des fichiers, les emplacements des fichiers peuvent ne pas être les mêmes que sur votre machine ; de plus, la structure du répertoire peut être différente. En général, il serait juste de dire que vous devriez éviter d'utiliser des chemins absolus, mais plutôt des chemins relatifs, comme dans l'exemple ci-dessus. N'utilisez cette directive que si vous êtes certain des emplacements où résident les fichiers. Si vous n'êtes pas sûr, il est préférable d'utiliser des makefiles et des variables makefile.

Notez que ce commutateur ne se propage pas à d'autres unités, c'est-à-dire que sa portée est limitée à l'unité actuelle (ceci est conforme au fait que les chemins sont relatifs à l'unité actuelle.)

La construction de la clause uses dans un 'sub/a.pp' est relative au répertoire de travail actuel du compilateur. En ajoutant une directive à votre programme :

utilise un dans 'sub/a.pp' ; vous vous assurerez que le compilateur trouvera toujours les sources.

$VARPROPSETTER : Activer l'utilisation des paramètres var/out/constref pour les setters de propriétés

Cette directive booléenne est destinée à importer des interfaces COM. Parfois, les interfaces COM ont des setters de propriété acceptant des paramètres n'étant pas par valeur, mais par référence. Ces passeurs sont normalement interdits. Cet indicateur permet l'utilisation de setters de propriétés avec les paramètre var, constref, out. Par défaut, il est désactivé. Notez que cela affecte toutes les propriétés écrivant dans une procédure setter, y compris celles des objets et des enregistrements étendus.

L'exemple suivant ne compile qu'à l'état ON :

Dans l'état OFF, l'erreur suivante sera générée :

$VERSION : Spécifiez la version de la DLL

Sous WINDOWS, cela peut être utilisé pour spécifier un numéro de version pour une bibliothèque. Ce numéro de version sera utilisé lors de l'installation de la bibliothèque, et peut être visualisé dans l'Explorateur Windows en ouvrant la feuille de propriétés de la DLL et en regardant dans l'onglet 'Version'. Le numéro de version contient 1, 2 ou 3 entiers, séparés par un point :

Ou :

Et même :

Cela ne peut pas encore être utilisé pour les exécutables sous Windows, mais peut être activé à l'avenir.

$WEAKPACKAGEUNIT : ignoré

Ce commutateur est analysé pour la compatibilité Delphi mais est sinon ignoré. Le compilateur émettra un avertissement lorsqu'il sera rencontré.

$X ou $EXTENDEDSYNTAX : Syntaxe étendue

La syntaxe étendue vous permet de supprimer le résultat d'une fonction et d'effectuer une arithmétique de pointeur. Cela signifie que vous pouvez utiliser un appel de fonction comme s'il s'agissait d'une procédure. Par défaut, cette fonctionnalité est activée. Vous pouvez le désactiver en utilisant la directive {$X-} ou {$EXTENDEDSYNTAX OFF}.

Ce qui suit, par exemple, ne compilera pas :

La raison pour laquelle cette construction est prise en charge est que vous souhaiterez peut-être appeler une fonction pour certains effets secondaires qu'elle a, mais vous n'avez pas besoin du résultat de la fonction. Dans ce cas, vous n'avez pas besoin d'affecter le résultat de la fonction, ce qui vous évite une variable supplémentaire.

De même, le pointeur mathématique sera désactivé :

entraînera une erreur pour les deux lignes :

Le commutateur de compilateur de ligne de commande -Sa1 a le même effet que la directive {$X+}. Par défaut, la syntaxe étendue est utilisée.

$Y ou $REFERENCEINFO : Insérer les informations du navigateur

Ce commutateur contrôle la génération des informations du navigateur. Il est reconnu pour sa compatibilité avec Turbo Pascal et Delphi uniquement, car la génération d'informations du navigateur n'est pas encore entièrement prise en charge.