Directive (programmation) - Directive (programming)

En programmation informatique , une directive ou pragma (de «pragmatique») est une construction de langage qui spécifie comment un compilateur (ou un autre traducteur ) doit traiter son entrée. Les directives ne font pas partie de la grammaire d'un langage de programmation et peuvent varier d'un compilateur à l'autre. Ils peuvent être traités par un préprocesseur pour spécifier le comportement compilateur, ou la fonction comme une forme d' in-band paramétrisation.

Dans certains cas, les directives spécifient un comportement global, tandis que dans d'autres cas, elles n'affectent qu'une section locale, comme un bloc de code de programmation. Dans certains cas, comme certains programmes C, les directives sont des conseils de compilation facultatifs et peuvent être ignorées, mais elles sont normalement prescriptives et doivent être suivies. Cependant, une directive n'effectue aucune action dans le langage lui-même, mais seulement une modification du comportement du compilateur.

Ce terme pourrait être utilisé pour désigner des balises et des commandes tierces propriétaires (ou un balisage) incorporées dans du code qui entraînent un traitement exécutable supplémentaire qui étend les constructions de compilateur, d'assembleur et de langage existantes dans l'environnement de développement. Le terme «directive» est également appliqué de diverses manières similaires au terme commande .

Le préprocesseur C

Article principal: préprocesseur C

En C et C ++ , le langage prend en charge un simple préprocesseur de macro . Les lignes source qui doivent être gérées par le préprocesseur, telles que et sont appelées directives de préprocesseur . #define#include

Une autre construction C, la #pragma directive, est utilisée pour indiquer au compilateur d'utiliser des fonctionnalités pragmatiques ou dépendantes de l'implémentation. Deux utilisateurs notables de cette directive sont OpenMP et OpenACC .

Constructions syntaxiques similaires aux directives de préprocesseur de C, comme C # « s #if , sont généralement appelées « directives », bien que dans ces cas , il peut ne pas être une réelle phase de pré - traitement en cause.

Toutes les commandes du préprocesseur commencent par un symbole de hachage (#).

Histoire

Les directives datent d' ALGOL 68 , où elles sont dites pragmatiques (de «pragmatique»), et désignées pragmat ou pr ; dans les langues plus récentes, notamment C, cela a été abrégé en "pragma" (pas de 't').

Une utilisation courante des pragmatiques dans ALGOL 68 consiste à spécifier un régime de stropping , c'est-à-dire "comment les mots-clés sont indiqués". Diverses directives de ce type suivent, spécifiant les régimes POINT, UPPER, RES (réservé) ou quote. Notez l'utilisation du stropping pour le mot-clé pragmat lui-même (abrégé pr ), soit dans les régimes POINT, soit entre guillemets: 

.PR POINT .PR
.PR UPPER .PR
.PR RES .PR
'pr' quote 'pr'

Aujourd'hui, les directives sont mieux connues dans le langage C, du début des années 1970, et se sont poursuivies à travers la norme actuelle C99 , où elles sont soit des instructions au préprocesseur C , soit, sous la forme de #pragma directives au compilateur lui-même. Ils sont également utilisés dans une certaine mesure dans des langues plus modernes; voir ci-dessous.

Autres langues

  • Dans Ada , les directives du compilateur sont appelées pragmas (abréviation de "pragmatic information").
  • En Common Lisp , les directives sont appelées déclarations et sont spécifiées à l'aide de la declare construction (également proclaim ou declaim ). À une exception près, les déclarations sont facultatives et n'affectent pas la sémantique du programme. La seule exception est special , qui doit être spécifiée le cas échéant.
  • Dans Turbo Pascal , les directives sont appelées commentaires significatifs , car dans la grammaire du langage , elles suivent la même syntaxe que les commentaires . Dans Turbo Pascal, un commentaire significatif est un commentaire dont le premier caractère est un signe dollar et dont le second caractère est une lettre; par exemple, l'équivalent de la #include "file" directive de C est le commentaire significatif {$I "file"} .
  • En Perl , le mot - clé " use ", qui importe des modules, peut également être utilisé pour spécifier des directives, telles que use strict; ou use utf8; .
  • Les pragmas Haskell sont spécifiés en utilisant une syntaxe de commentaire spécialisée, par exemple {-# INLINE foo #-} .
  • Python a deux directives - from __future__ import feature (définies dans PEP 236 - Retour à la __future__ ), qui modifie les fonctionnalités du langage (et utilise la syntaxe d'importation de module existante, comme en Perl), et la coding directive (dans un commentaire) pour spécifier l'encodage d'un fichier de code source (défini dans PEP 263 - Définition des codages de code source Python ). Une déclaration de directive plus générale a été proposée et rejetée dans la PEP 244 - La déclaration «directive» ; tous datent de 2001.
  • ECMAScript adopte également la use syntaxe des directives, à la différence que les pragmas sont déclarés comme des chaînes littérales (par exemple "use strict"; , ou "use asm"; ), plutôt qu'un appel de fonction.
  • Dans Visual Basic , le mot clé " Option " est utilisé pour les directives:
    • Option Explicit On|Off - Quand on interdit la déclaration implicite des variables lors de la première utilisation nécessitant une déclaration explicite au préalable.
    • Option Compare Binary - Résultats des comparaisons de chaînes basées sur un ordre de tri dérivé des représentations binaires internes des caractères - par exemple pour la page de codes anglaise / européenne (ANSI 1252) A <B <E <Z <a <b <e <z <À < Ê <Ø <à <ê <ø. Affecte les opérateurs intrinsèques (par exemple =, <>, <,>), le bloc Select Case et les fonctions de chaîne de la bibliothèque d'exécution VB (par exemple InStr).
    • Option Compare Text - Résultats dans des comparaisons de chaînes basées sur un ordre de tri de texte insensible à la casse déterminé par les paramètres régionaux de votre système - par exemple pour la page de codes anglais / européen (ANSI 1252) (A = a) <(À = à) <(B = b) < (E = e) <(Ê = ê) <(Z = z) <(Ø = ø). Affecte les opérateurs intrinsèques (par exemple =, <>, <,>), le bloc Select Case et les fonctions de chaîne de la bibliothèque d'exécution VB (par exemple InStr).
    • Option Strict On|Off - Lorsque activé interdit:
      • programmation sans type - où les déclarations qui n'ont pas de type explicite sont implicitement typées comme Object.
      • liaison tardive (c'est-à-dire envoi dynamique aux objets CLR, DLR et COM) sur des valeurs typées statiquement comme Object.
      • les conversions de rétrécissement implicites - exigeant que toutes les conversions en types plus étroits (par exemple de Long en Integer, Object en String, Control en TextBox) soient explicites dans le code en utilisant des opérateurs de conversion (par exemple CInt, DirectCast, CType).
    • Option Infer On|Off - Lorsque cette option est activée, le compilateur peut déduire le type de variables locales à partir de leurs initialiseurs.
  • Dans Ruby , les directives d'interprétation sont appelées pragmas et sont spécifiées par des commentaires en haut de fichier qui suivent une key: value notation. Par exemple, coding: UTF-8 indique que le fichier est codé via le codage de caractères UTF-8 .
  • En C # , les directives du compilateur sont appelées directives de prétraitement. Il existe un certain nombre de directives de compilateur différentes, y compris #pragma, qui est spécifiquement utilisée pour contrôler les avertissements du compilateur et les sommes de contrôle du débogueur.
  • Le SGBD SQLite comprend une directive PRAGMA qui est utilisée pour introduire des commandes qui ne sont pas compatibles avec d'autres SGBD.

Langue d'assemblage

  • En langage assembleur , les directives, également appelées pseudo-opérations ou "pseudo-opérations", spécifient généralement des informations telles que la machine cible, marquent les séparations entre les sections de code, invoquent des macros, définissent des zones de mémoire réservées, etc. Les assembleurs utilisent une syntaxe spécifique pour différencier les pseudo-opérations des mnémoniques d'instructions, comme faire précéder la pseudo-opération d'un point, tel que le pseudo-op .END , qui pourrait demander à l'assembleur d'arrêter d'assembler le code.

PL / SQL

Voir également

Les références

Liens externes