Créer son propre langage de programmation de A à Z

<< Notion de grammaire et langage formel | Syntaxe du langage Simple | Analyseur lexical >>

Syntaxe (ou grammaire) du langage Simple :

La théorie est passée !! Si vous êtes arrivé là, vous devez avoir compris la notion de langage formel, vous devez savoir qu'une grammaire formelle est constituée de 4 éléments qui sont l'ensemble des terminaux, des non terminaux, des règles grammaticales et l'axiome et vous devez connaître brièvement la syntaxe du métalangage BNF. Je peux vous dévoiler la grammaire du langage Simple sous forme BNF donc.

Alors voilà :

Liste des non terminaux :

code, instruction, affectation, affichage, expression, expression_arithmetique, expression_booleenne, addition, soustraction, multiplication, division, et, ou, non

Liste des terminaux :

'et', 'ou', 'non', 'afficher', ';', '=', '+', '-', '*', '/', '(', ')', variable, nombre, 'vrai', 'faux'

Notons que certains terminaux ont le même nom que des non terminaux. Il faut bien faire attention et ne pas les confondre car ce n'est pas du tout la même chose. La notation BNF évite la confusion en écrivant les non terminaux entre chevrons.

Axiome : code

Règles :

⚠ (:source lang=bnf linenum:) @@ ::= (<instruction> @@) | <none> <:vspace> <instruction> ::= <affectation> | <affichage> <:vspace> <expression> ::= <expression_booleenne> | <expression_arithmetique> <:vspace> <affectation> ::= variable "=" ( <expression_arithmetique> | <expression_booleenne> ) ";" <:vspace> <affichage> ::= "afficher" <expression> ";" <:vspace> <expression_arithmetique> ::= variable | nombre | <addition> | <soustraction> | <multiplication> | <division> | "(" <expression_arithmetique> ")" <:vspace> <expression_booleenne> ::= variable | "vrai" | "faux" | <et> | <ou> | <non> | "(" <expression_booleenne> ")" <:vspace> <addition> ::= <expression_arithmetique> "+" <expression_arithmetique> <:vspace> <soustraction> ::= <expression_arithmetique> "-" <expression_arithmetique> <:vspace> <multiplication> ::= <expression_arithmetique> "*" <expression_arithmetique> <:vspace> <division> ::= <expression_arithmetique> "/" <expression_arithmetique> <:vspace> <et> ::= <expression_booleenne> "et" <expression_booleenne> ;Ne pas confondre <et> qui est le non terminal lie a l'operation du ET logique et "et" qui est le terminal correspondant a l'operateur ET <:vspace> <ou> ::= <expression_booleenne> "ou" <expression_booleenne> <:vspace> <non> ::= "non" <expression_booleenne> (:sourcend:) Je vous ai donné la grammaire du langage Simple. On pourra après l'enrichir en implémentant les blocs d'instructions si/sinon et la boucle tant que. Mais chaque chose en son temps. On évolue un langage au fur et à mesure. Vous êtes maintenant en mesure d'écrire les premières phrases en Simple. Mais vous ne savez pas à quoi elles correspondent. Ils n'existent hélas pas de langage qui donne la signification d'une syntaxe. C'est pourquoi quand on apprend une langue, la notation BNF ne suffit pas. Il faut aussi lier les phrases à leurs sens.

L'axiome est code. Tout part donc du non terminal code. En langage Simple, tout est code, même si on écrit aucune seule ligne de code dans le programme. C'est un programme Simple comme un autre, malgré qu'il soit vide et qu'il ne fera rien, il compilera. Si je donnai l'obligation au développeur d'écrire au moins une instruction pour que ce soit un programme Simple, j'aurai écrit en EBNF :

⚠ (:source lang=bnf:) @@ ::= [ <instruction> @@ ] <none> (:sourcend:) Les crochets en EBNF indiquent que le non terminal code est optionnel. J'ai au moins une instruction car le non terminal code commence forcément par le non terminal instruction.

L'équivalent en BNF classique :

⚠ (:source lang=bnf:) @@ ::= (<instruction> @@) | <none> (:sourcend:) Si on ne met pas l'ensemble vide comme possibilité de code, on ne devra alors jamais s'arrêter d'écrire ! En effet, il boucle récursivement sur lui-même, il faut donc donner au langage la possibilité de fin. Pour bien comprendre le langage, on va se concentrer aux instructions. On a comme instruction affichage et affectation.

L'affectation permet de stocker une donnée dans une variable. La donnée ici est soit un nombre entier, soit un booleen (vrai ou faux).

⚠ (:source:) monEntier = 6 ; monBooleen = faux ; (:sourcend:)

L'affichage permet d'afficher soit une variable ou soit une expression à l'écran.

⚠ (:source:) afficher monEntier ; afficher monBooleen ; afficher 4 ; afficher non ( ( vrai et faux ) ou vrai ) ; afficher 6/3 ; (:sourcend:) On a fait le tour du langage Simple. Je vous l'avez dit, il est pas compliqué. On implémentera plus tard les conditions et les boucles. Il y a plus qu'à développer le compilateur maintenant.