Directives de compilateur (F#)
Cette rubrique décrit les directives de processeur et de compilateur.
Directives de préprocesseur
Une directive de préprocesseur a pour préfixe # et figure seule sur une ligne. Elle est interprétée par le préprocesseur, qui s'exécute avant le compilateur.
Le tableau suivant répertorie les directives de préprocesseur qui sont disponibles en F#.
Directive |
Description |
|---|---|
#if symbole |
Prend en charge la compilation conditionnelle. Le code dans la section après la directive #if est inclus si le symbole est défini. |
#else |
Prend en charge la compilation conditionnelle. Marque une section de code à inclure si le symbole utilisé avec la directive #if précédente n'est pas défini. |
#endif |
Prend en charge la compilation conditionnelle. Marque la fin d'une section conditionnelle de code. |
#[ligne] int, #[ligne] intstring, #[ligne] intverbatim-string |
Indique la ligne de code source d'origine et le nom du fichier à des fins de débogage. Cette fonctionnalité est fournie pour les outils qui génèrent du code source F#. |
Directives de compilation conditionnelle
Le code désactivé par l'une de ces directives apparaît estompé dans l'éditeur de code Visual Studio.
Notes
Le comportement des directives de compilation conditionnelle n'est pas le même que dans d'autres langages. Par exemple, vous ne pouvez pas utiliser des expressions booléennes qui impliquent des symboles, et true et false n'ont aucune signification spéciale. Les symboles que vous utilisez dans la directive #if doivent être définis par la ligne de commande ou dans les paramètres du projet ; la directive de préprocesseur #define n'existe pas.
Le code suivant illustre l'utilisation des directives #if, #else et #endif. Dans cet exemple, le code contient deux versions de la définition de function1. Lorsque VERSION1 est défini à l'aide de l'option de compilateur dd233171(v=vs.100).md, le code entre les directives #if et #else est activé. Sinon, le code entre #else et #endif est activé.
#if VERSION1
let function1 x y =
printfn "x: %d y: %d" x y
x + 2 * y
#else
let function1 x y =
printfn "x: %d y: %d" x y
x - 2*y
#endif
let result = function1 10 20
En F#, la directive de préprocesseur #define n'existe pas. Vous devez utiliser l'option de compilateur ou les paramètres du projet pour définir les symboles utilisés par la directive #if.
Les directives de compilation conditionnelles peuvent être imbriquées. La mise en retrait n'a pas d'importance dans les directives de préprocesseur.
Directives line
Au moment de la génération, le compilateur signale les erreurs dans le code F# en référençant chaque numéro de ligne sur lequel une erreur se produit. Ces numéros de ligne commencent à 1 pour la première ligne dans un fichier. Toutefois, si vous générez du code source F# à partir d'un autre outil, les numéros de ligne dans le code généré ne présentent en général pas d'intérêt, car les erreurs dans le code F# généré proviennent très probablement d'une autre source. La directive #line offre aux auteurs d'outils qui génèrent du code source F# la possibilité de passer des informations sur les numéros de ligne d'origine et les fichiers sources au code F# généré.
Lorsque vous utilisez la directive #line, les noms de fichiers doivent être entre guillemets. À moins que le jeton textuel (@) ne figure devant la chaîne, vous devez placer les barres obliques inverses dans une séquence d'échappement, en utilisant deux barres obliques inverses au lieu d'une, pour pouvoir les utiliser dans le chemin d'accès. Les jetons de ligne suivants sont valides : Dans ces exemples, supposons que le fichier d'origine Script1 entraîne un fichier de code F# généré automatiquement lorsqu'il est exécuté par l'intermédiaire d'un outil, et que le code à l'emplacement de ces directives soit généré à partir de quelques jetons à la ligne 25 dans le fichier Script1.
# 25
#line 25
#line 25 "C:\\Projects\\MyProject\\MyProject\\Script1"
#line 25 @"C:\Projects\MyProject\MyProject\Script1"
# 25 \@\"C:\Projects\MyProject\MyProject\Script1\"
Ces jetons indiquent que le code F# généré à cet emplacement est dérivé de certaines constructions à la ligne 25 ou à proximité de celle-ci dans Script1.
Directives de compilateur
Les directives de compilateur ressemblent aux directives de préprocesseur, en ce sens qu'elles sont précédées du préfixe #. Toutefois, c'est le compilateur qui les interprète et qui agit sur celles-ci, et non le préprocesseur.
Le tableau suivant répertorie la directive de compilateur disponible en F#.
Directive |
Description |
|---|---|
#light ["on"|"off"] |
Active ou désactive la syntaxe simplifiée, à des fins de compatibilité avec d'autres versions de ML. Par défaut, la syntaxe simplifiée est activée. La syntaxe détaillée est toujours activée. Par conséquent, vous pouvez utiliser à la fois la syntaxe simplifiée et la syntaxe détaillée. La directive #light à elle seule est équivalente à #light "on". Si vous spécifiez #light "off", vous devez utiliser la syntaxe détaillée pour toutes les constructions de langage. La syntaxe pour F# dans la documentation est présentée en partant du principe que vous utilisez la syntaxe simplifiée. Pour plus d'informations, consultez Syntaxe détaillée (F#). |
Pour les directives de l'interpréteur (fsi.exe), consultez Référence de F# Interactive (fsi.exe).