Pourquoi un langage de programmation a-t-il besoin de mots-clés?

Par exemple (en C):

int break = 1; int for = 2; 

Pourquoi le compilateur aura-t-il du mal à en déduire cette break et pourquoi les variables sont-elles ici?


Donc, nous avons besoin de mots-clés car

  • nous voulons que les programmes soient lisibles
  • nous ne voulons pas trop compliquer le travail des compilateurs déjà complexes d’aujourd’hui
  • mais surtout, un langage est beaucoup plus puissant si certains mots clés sont réservés à des actions spéciales. Ensuite, le langage peut penser être utile à un niveau supérieur plutôt que de mourir en essayant de mettre en œuvre une boucle for d’une manière non ambiguë.

    Alors que fera l’ordinateur lorsqu’il rencontre une déclaration du type:

     while(1) { ... if (condition) break; } 

    Est-ce que ça devrait casser? Ou devrait-il le traiter comme 1; ?

    Le langage deviendrait ambigu dans certains cas, ou il faudrait créer un parsingur syntaxique très intelligent pouvant déduire une syntaxe subtile, ce qui représente un travail supplémentaire inutile.

    Ce n’est pas nécessaire – Fortran n’a pas réservé de mots, donc des choses comme:

     if if .eq. then then if = else else then = if endif 

    sont complètement légales. Cela rend non seulement le langage difficile à parsingr pour le compilateur , mais également presque impossible pour une personne de lire ou de repérer des erreurs. Par exemple, considérons le Fortran classique (par exemple, jusqu’à Fortran 77 – je ne l’ai pas utilisé récemment, mais espère au moins qu’ils ont corrigé quelques problèmes de ce type dans des normes plus récentes). Une boucle Fortran DO ressemble à ceci:

     DO 10 I = 1,10 

    Sans qu’ils soient côte à côte, vous pouvez probablement voir comment vous rateriez la différence:

     DO 10 I = 1.10 

    Malheureusement, cette dernière n’est pas du tout une boucle DO: c’est une simple affectation de la valeur 1.10 à une variable nommée DO 10 I (oui, elle permet également des espaces dans un nom). Etant donné que Fortran prend également en charge les variables implicites (non déclarées), ceci est (ou était) parfaitement légal, et certains compilateurs l’accepteraient même sans avertissement!

    Ils ne le font pas. PL / 1 n’a pas de mots clés; chaque “mot-clé” (BEGIN, DO, …) peut également être utilisé avec un nom de variable. Mais autoriser cela signifie que vous pouvez écrire du code très obscur: SI FAIRE> COMMENCER ALORS IMPRIMER: = CALL-GOTO; Le fait de réserver les “mots-clés de déclaration”, car la langue utilisée ne constitue généralement pas une perte, si cet ensemble de noms est modeste (comme dans toutes les langues que j’ai jamais vues, à l’exception de PL / 1 :-).

    APL n’a pas non plus de mots clés. Mais il possède un ensemble de quelque 200 symboles iconiques étonnants dans lesquels écrire des opérateurs compliqués. (l’opérateur “domino” [ne demandez pas!] est une boîte carrée avec un signe de division de la calculasortingce au milieu) Dans ce cas, les concepteurs de langauge ont simplement utilisé des icons au lieu de mots-clés. La conséquence est que APL a la réputation d’être un langage “en écriture seule”.

    En bout de ligne: ce n’est pas une exigence, mais cela a tendance à rendre les programmes beaucoup plus lisibles si les mots-clés sont des identifiants réservés appartenant à un petit ensemble connu des programmeurs. (Certaines langues ont insisté pour que les “mots-clés” commencent par un caractère de ponctuation spécial tel que “.” Afin de permettre l’utilisation de tous les identifiants possibles, mais cela ne vaut pas la peine de taper du texte ou de l’encombrer sur la page; éloignez-vous des “identificateurs” qui correspondent aux mots clés lorsque l’ensemble de mots clés est petit).

    Comme il est étiqueté C, le langage C original était tel que par défaut, toute variable était définie comme type int .

    Cela signifie que foo; déclarerait une variable de type int .

    Disons que vous faites une break; . Comment le compilateur sait-il si vous souhaitez déclarer une variable nommée break ou utiliser le mot clé break ?

    plusieurs raisons:

    • Les mots-clés peuvent sembler sans ambiguïté dans vos exemples. Mais ce n’est pas le seul endroit où vous utiliseriez la variable “break” ou la variable “for”.

    • écrire l’parsingur serait beaucoup plus difficile et sujet aux erreurs pour peu de gain.

    • L’utilisation d’un mot-clé comme nom de fonction ou de procédure dans une bibliothèque peut avoir des effets secondaires indésirables, éventuellement liés à la sécurité.

    Comme d’autres l’ont dit, cela facilite l’parsing du code source par le compilateur. Mais je voudrais en dire un peu plus: cela peut également rendre votre code source plus lisible; Considérons cet exemple:

    si (si> 0) alors alors = 10 fin si

    Le second “if” et le second “then” sont des variables, alors que d’autres ne le sont pas. Je pense que ce genre de code n’est pas lisible. 🙂

    Si nous parlons de C ++, la grammaire est déjà très compliquée. Autoriser l’utilisation de mots-clés comme noms de variables, par exemple, compliquera encore les choses.

    Le compilateur aurait des problèmes si vous écrivez quelque chose comme ceci:

     while(*s++); return(5); 

    Est-ce une boucle ou un appel à une fonction nommée while ? Voulez-vous renvoyer la valeur 5 à partir de la fonction actuelle ou voulez-vous appeler une fonction nommée return ?

    Cela simplifie souvent les choses si les constructions avec une signification spéciale ont simplement des noms spéciaux qui peuvent être utilisés pour s’y référer de manière non ambiguë.

    Parce que nous voulons garder le peu de santé mentale que nous avons:

     void myfunction(bool) { .. }; funcp while = &myfunction; while(true); 

    Je suppose que cela semble très bizarre, voire impossible, d’écrire l’parsingur. Par exemple

     int break = 1; while (true) { // code to change break if (!break) break; // not very readable code. } 

    Selon la définition du langage, un compilateur peut avoir besoin de mots-clés ou non. Lorsqu’il ne sait pas quoi faire, il peut essayer d’appliquer des règles de priorité ou tout simplement échouer.
    Un exemple:

     void return(int i){printf("%d",i);} public int foo(int a) { if(a > 2)return (a+1)*2; return a + 3; } 

    Que se passe-t-il si a est supérieur à 2?

    • La spécification du langage peut nécessiter l’échec du compilateur
    • La spécification de langue peut nécessiter que le compilateur utilise la fonction de retour
    • La spécification de langue peut exiger que le compilateur retourne

    Vous pouvez définir une langue qui n’utilise pas de mots-clés. Vous pouvez même définir un langage qui vous permette de remplacer tous les symboles (car ce ne sont que des mots-clés très courts).
    Le problème n’est pas le compilateur, si votre spécification est complète et sans erreur, cela fonctionnera. Le problème est PEBCAD, les programmes utilisant cette fonctionnalité du langage seront difficiles à lire car vous devez suivre les définitions de symboles.

    FWIW, Tcl n’a pas de mots réservés. Vous pouvez avoir des variables et des fonctions nommées “if”, “break”, etc. L’interprétation d’un jeton dépend totalement du contexte. Le même jeton peut représenter une commande dans un contexte, une variable dans un autre ou une chaîne littérale dans un autre.

    Dans de nombreux cas, le compilateur pourrait interpréter les mots-clés comme des identifiants normaux, comme dans votre exemple:

     int break = 1; int for = 2; 

    En fait, je viens d’écrire un compilateur pour un langage de jeu simple, qui ressemble à un assemblage, mais qui avertit l’utilisateur dans de tels cas.

    Mais parfois, la syntaxe est définie de manière à ce que les mots-clés et les identifiants soient ambigus:

     int break; while(...) { break; // <-- treat this as expression or statement? } 

    Et la raison la plus évidente est que les éditeurs insistent sur les mots-clés pour que le code soit plus lisible par les humains. Autoriser les mots clés à être traités comme des identificateurs rendrait la mise en surbrillance du code plus difficile et conduirait également à une mauvaise lisibilité de votre code.