Stropping (syntaxe) - Stropping (syntax)

Dans la conception de langage informatique , le stropping est une méthode de marquage explicite des séquences de lettres comme ayant une propriété spéciale, telle qu'être un mot - clé , ou un certain type de variable ou d'emplacement de stockage, et habitant ainsi un espace de noms différent des noms ordinaires ("identifiants") , afin d'éviter les affrontements. Le stropping n'est pas utilisé dans la plupart des langues modernes - à la place, les mots-clés sont des mots réservés et ne peuvent pas être utilisés comme identifiants. Le stropping permet à la même séquence de lettres d'être utilisée à la fois comme mot-clé et comme identifiant , et simplifie l' analyse dans ce cas - par exemple en permettant à une variable nommée ifsans entrer en conflit avec le mot - clé if .

Le stropping est principalement associé à l' ALGOL et aux langues apparentées dans les années 1960. Bien qu'il trouve une certaine utilisation moderne , il est facilement confondu avec d'autres techniques similaires qui sont superficiellement similaires.

Histoire

La méthode de stropping et le terme "stropping" sont apparus dans le développement d' ALGOL dans les années 1960, où il était utilisé pour représenter des distinctions typographiques (gras et souligné) trouvées dans le langage de publication qui ne pouvaient pas être directement représentées dans le langage matériel - un la machine à écrire pouvait avoir des caractères gras, mais lors de l'encodage des cartes perforées, il n'y avait pas de caractères gras. Le terme « stropping » est né dans ALGOL 60 , de « apostrophe », car certaines implémentations d'ALGOL 60 utilisaient des apostrophes autour du texte pour indiquer le caractère gras, par exemple 'if'pour représenter le mot - clé if . Le stropping est également important dans ALGOL 68 , où plusieurs méthodes de stropping, connues sous le nom de "régimes de stropping", sont utilisées; les apostrophes originales appariées d'ALGOL 60 n'étaient pas largement utilisées, un point de début ou une majuscule étant plus courant, comme dans .IFou IFet le terme "stropping" a été appliqué à tous.

Syntaxe

Une gamme de syntaxes différentes pour le stropping a été utilisée :

  • Algol 60 n'utilisait couramment que la convention des guillemets simples autour du mot, généralement sous forme d'apostrophes, d'où le nom "stropping" (par exemple 'BEGIN').
  • Algol 68 dans certaines implémentations traite les séquences de lettres préfixées par un guillemet simple, ', comme étant des mots-clés (par exemple, 'BEGIN)

En fait, il arrivait souvent que plusieurs conventions de découpage soient utilisées dans une même langue. Par exemple, dans ALGOL 68 , le choix de la convention de stropping peut être spécifié par une directive du compilateur (dans la terminologie ALGOL, un " pragmat "), à savoir POINT, UPPER, QUOTE ou RES :

  • POINT pour 6 bits (pas assez de caractères pour les minuscules), comme dans .FOR- une convention similaire est utilisée dans FORTRAN 77, où les mots-clés LOGICAL sont raccourcis comme .EQ.etc. (voir ci-dessous)
  • UPPER pour 7 bits, comme dans FOR– avec des minuscules utilisées pour les identifiants ordinaires
  • CITATION comme dans ALGOL 60, comme dans 'for'
  • Mots réservés RES, tels qu'utilisés dans les langues modernes - forest réservé et non disponible pour les identifiants ordinaires

Les différents régimes de règles sont une spécification lexicale pour les caractères tronqués, bien que dans certains cas ceux-ci aient des interprétations simples : dans les régimes d'apostrophe simple et de point, le premier caractère fonctionne comme un caractère d'échappement , tandis que dans le régime d'apostrophes appariées, les apostrophes fonctionnent comme délimiteurs , comme dans les chaînes littérales .

Autres exemples :

  • Atlas Autocode avait le choix entre trois : les mots-clés pouvaient underlinedutiliser le retour arrière et la frappe sur un clavier Flexowriter , ils pouvaient être introduits par un %percent %symbol, ou ils pouvaient être saisis UPPER CASEsans caractère de délimitation (mode "délimiteurs majuscules", auquel cas toutes les variables devaient être en minuscule).
  • Algol 60 sur les ordinateurs Elliott 803 et Elliott 503 a utilisé le soulignement. Les Flexowriters (produisant du ruban de papier perforé) avaient une touche non-mouvement (souligné _) de sorte que la frappe _b_e_g_i_n produit un début qui était très lisible. La barre verticale | était également une clé de non-mouvement de sorte que taper |= produisait une bonne approximation de ≠.
  • Les programmes ALGOL 68RS sont autorisés à utiliser plusieurs variantes de stropping, même au sein d'un seul processeur de langage.
  • Edinburgh IMP a hérité de la %percent %symbolconvention de préfixe Atlas Autocode, mais pas de ses autres options de découpage

Exemples de différents styles ALGOL 68

Notez la directive pr (abréviation de pragmat ) principale , qui est elle-même abrégée en style POINT ou quote, et pour le commentaire (de " ") - voir ALGOL 68: pr & co: Pragmats and Comments pour plus de détails. ¢2¢

Algol68 "strict"
tel que généralement publié 		Citation stropping
(comme wikitext ) 		Pour un compilateur de code de caractères 7 bits
 Pour un compilateur de code de caractères 6 bits
 Algol68 utilisant res stropping
(mot réservé) 
souligner ou
   caractères gras ¢
 mode  xint = int ;
 xint somme sq:=0;
 pour moi pendant que
   somme carré≠70×70
 faire
   somme sq+:=i↑2
 od
 
'pr' quote 'pr'
'mode' 'xint' = 'int';
'xint' sum sq:=0;
'for' i 'while'
  sum sq≠70×70
'do'
  sum sq+:=i↑2
'od'

.PR UPPER .PR
MODE XINT = INT;
XINT sum sq:=0;
FOR i WHILE
  sum sq/=70*70
DO
  sum sq+:=i**2
OD

.PR POINT .PR
.MODE .XINT = .INT;
.XINT SUM SQ:=0;
.FOR I .WHILE
  SUM SQ .NE 70*70
.DO
  SUM SQ .PLUSAB I .UP 2
.OD

.PR RES .PR
mode .xint = int;
.xint sum sq:=0;
for i while
  sum sq≠70×70
do
  sum sq+:=i↑2
od

Autres langues

Pour diverses raisons, Fortran 77 a ces valeurs et opérateurs "logiques": .TRUE., .FALSE., .EQ., .NE., .LT., .LE., .GT., .GE., .EQV., .NEQV., .OR., .AND.,.NOT.

.AND., .OR.et .XOR.sont également utilisés dans les tests combinés IFet les IFFinstructions dans les fichiers batch exécutés sous les processeurs de ligne de commande de JP Software comme 4DOS , 4OS2 et 4NT / Take Command .

Utilisation moderne

La plupart des langages informatiques modernes n'utilisent pas le stropping, à deux exceptions notables :

L'utilisation de nombreuses langues dans l' infrastructure de langage commun (CLI) .NET de Microsoft nécessite un moyen d'utiliser des variables dans une langue différente qui peuvent être des mots-clés dans une langue d'appel. Cela se fait parfois par des préfixes, comme en C#, ou en mettant l'identifiant entre crochets, dans Visual Basic.NET . @

Un deuxième exemple majeur se trouve dans de nombreuses implémentations du langage de requête structuré . Dans ces langues, les mots réservés peuvent être utilisés comme noms de colonnes, de tableaux ou de variables en les délimitant lexicalement. La norme spécifie d'entourer les mots réservés de guillemets doubles, mais en pratique, le mécanisme exact varie selon l'implémentation ; MySQL , par exemple, permet d'utiliser des mots réservés dans d'autres contextes en les entourant de backticks, et Microsoft SQL Server utilise des crochets.

Le stropping peut également être utilisé dans le langage de programmation Nim . Dans Nim, un mot réservé peut être utilisé comme identifiant en l'entourant de backticks.

Il existe d'autres exemples plus mineurs. Par exemple, Web IDL utilise un trait _de soulignement de début pour supprimer les identificateurs qui entreraient autrement en collision avec des mots réservés : la valeur de l'identificateur supprime ce trait de soulignement de début, ce qui en fait un stropping plutôt qu'une convention de nommage.

Déblocage par le compilateur

Informations complémentaires : interface du compilateur

Dans une interface de compilateur , le découplage s'est produit à l'origine lors d'une phase de reconstruction de ligne initiale , qui a également éliminé les espaces blancs. Cela a ensuite été suivi d' une analyse sans scanner (pas de tokenisation) ; c'était la norme dans les années 1960, notamment pour ALGOL. Dans l'usage moderne, le dégrafage se fait généralement dans le cadre d' une analyse lexicale . Ceci est clair si l'on distingue le lexer en deux phases de scanner et d'évaluateur : le scanner catégorise la séquence tronquée dans la bonne catégorie, puis l'évaluateur décompresse lors du calcul de la valeur. Par exemple, dans une langue où un trait de soulignement initial est utilisé pour supprimer les identifiants afin d'éviter les collisions avec des mots réservés, la séquence _ifserait catégorisée en tant qu'identifiant (et non en tant que mot réservé if) par le scanner, puis l'évaluateur lui donnerait la valeur if, donnant (Identifier, if)comme type et valeur de jeton.

Techniques similaires

Un certain nombre de techniques similaires existent, généralement préfixant ou suffixant un identifiant pour indiquer un traitement différent, mais la sémantique est variée. À strictement parler, le stropping consiste en différentes représentations du même nom (valeur) dans différents espaces de noms et se produit au stade de la tokenisation. Par exemple, dans ALGOL 60 avec un stropping d'apostrophe correspondant, 'if'est symbolisé en tant que (Mot-clé, si), tandis qu'il ifest marqué en tant que (Identifiant, si) - même valeur dans différentes classes de jetons.

L'utilisation de majuscules pour les mots-clés reste utilisée comme convention pour écrire des grammaires pour le lexisme et l'analyse syntaxique - en tokeniser le mot réservé en iftant que classe de jeton IF, puis en représentant une clause if-then-else par la phrase IF Expression THEN Statement ELSE Statementoù les termes en majuscules sont des mots-clés et les termes en majuscules sont symboles non terminaux dans une règle de production (les symboles terminaux sont indiqués par des termes en minuscules, tels que identifierou integer, pour un littéral entier ).

Conventions de nommage

Article principal: convention de nommage (programmation)

Plus vaguement, on peut utiliser des conventions de nommage pour éviter les conflits, en préfixant ou en suffixant généralement avec un trait de soulignement, comme dans if_ou _then. Un trait de soulignement de début est souvent utilisé pour indiquer les membres privés dans la programmation orientée objet.

Ces noms peuvent être interprétés par le compilateur et avoir un certain effet, bien que cela se fasse généralement lors de la phase d'analyse sémantique, et non lors de la phase de tokenisation. Par exemple, en Python, un seul trait de soulignement de début est un indicateur privé faible et affecte les identificateurs importés lors de l'importation de module, tandis qu'un double trait de soulignement de début (et pas plus d'un trait de soulignement de fin) sur un attribut de classe appelle name mangling .

Mots réservés

Article détaillé : Mot réservé

Alors que les langues modernes utilisent généralement des mots réservés plutôt que des mots-clés pour distinguer les mots-clés des identificateurs - par exemple, en rendant ifréservé - elles réservent aussi fréquemment une classe syntaxique d'identificateurs en tant que mots-clés, produisant des représentations qui peuvent être interprétées comme un régime de stropping, mais qui ont plutôt la sémantique de mots réservés.

C'est le plus notable en C, où les identifiants qui commencent par un trait de soulignement sont réservés, bien que les détails précis des identifiants réservés à quelle portée sont impliqués, et que les doubles traits de soulignement soient réservés pour toute utilisation ; de même en C++ tout identificateur qui contient un double trait de soulignement est réservé à toute utilisation, tandis qu'un identificateur qui commence par un trait de soulignement est réservé dans l'espace global. Ainsi on peut ajouter un nouveau mot-clé en fooutilisant le mot réservé __foo. Bien que cela soit superficiellement similaire au stropping, la sémantique est différente. En tant que mot réservé, la chaîne __fooreprésente l'identifiant __foodans l'espace de noms d'identifiant commun. Dans le stropping (en préfixant les mots-clés par __), la chaîne __fooreprésente le mot-clé foodans un espace de nom de mot-clé séparé. Ainsi, en utilisant des mots réservés, les jetons pour __fooet foosont (identifiant, __foo) et (identifiant, foo) - des valeurs différentes dans la même catégorie - tandis qu'en écrasant les jetons pour __fooet foosont (mot-clé, foo) et (identifiant, foo) - même valeurs dans différentes catégories. Ceux-ci résolvent le même problème de conflits d'espaces de noms d'une manière qui est la même pour un programmeur, mais qui diffère en termes de grammaire formelle et d'implémentation.

Nom mutilant

Article principal: nom mutilant

La modification des noms résout également les conflits de noms en renommant les identifiants, mais le fait beaucoup plus tard lors de la compilation, lors de l'analyse sémantique, et non lors de la tokenisation. Cela consiste à créer des noms qui incluent des informations sur la portée et le type, principalement à l'usage des éditeurs de liens, à la fois pour éviter les conflits et pour inclure les informations sémantiques nécessaires dans le nom lui-même. Dans ces cas, les identifiants d'origine peuvent être identiques, mais le contexte est différent, comme dans les fonctions foo(int x)versus foo(char x), dans les deux cas ayant le même identifiant foo, mais une signature différente. Ces noms peuvent être transformés en foo_iet foo_c, par exemple, pour inclure les informations de type.

Sceaux

Article détaillé : Sigil (programmation informatique)

Un phénomène syntaxiquement similaire mais sémantiquement différent sont les sigils , qui indiquent plutôt les propriétés des variables. Celles-ci sont courantes dans Perl , Ruby et divers autres langages pour identifier les caractéristiques des variables/constantes : Perl pour désigner le type de variable, Ruby pour distinguer les variables des constantes et pour indiquer la portée. Notez que cela affecte la sémantique de la variable, pas la syntaxe de savoir s'il s'agit d'un identifiant ou d'un mot-clé.

Parallèles dans le langage humain

Le stropping est utilisé dans les langages de programmation informatique pour faciliter le travail du compilateur (ou plus strictement, de l' analyseur syntaxique ), c'est-à-dire dans les limites des capacités des ordinateurs relativement petits et lents disponibles au début de l'informatique au 20e siècle. Cependant, des techniques similaires ont été couramment utilisées pour faciliter la compréhension de la lecture pour les gens aussi. Quelques exemples sont:

  • Mettre les mots importants en gras , comme la toute première mention du stropping en tête de cette page, car définir le stropping est le but même de la page.
  • Formater les nouveaux mots en italique lorsqu'ils sont introduits pour la première fois dans le texte. Ceci est couramment utilisé dans la science-fiction et la fantaisie lors de l'introduction de plantes, d'aliments, de créatures inventées; dans les récits de voyage et les écrits historiques pour décrire des mots étrangers inconnus ; etc. Utiliser également une police spéciale, éventuellement associée à la langue en question, par exemple utiliser une police gothique pour les mots allemands .
  • Utiliser une langue différente, généralement le latin ou le grec pour signifier des termes techniques. Ceci est similaire à l'utilisation de mots réservés, mais il est généralement combiné avec du texte en italique pour faciliter la lisibilité. Par exemple:
  • En japonais écrit , en plus des caractères Kanji , les deux alphabets distincts (plus strictement, les syllabaires ) Hiragana et Katakana , tous deux représentant le même ensemble de sons, sont utilisés pour distinguer les mots japonais épelés phonétiquement des mots étrangers importés, respectivement ; Katakana est également utilisé pour l'emphase, tout comme l' italique en anglais.

Voir également

Remarques

Les références

Lectures complémentaires