Recent Changes - Search:

My Projects

Courses

Writings

Source Code

Social Networks

Live Traffic !

Compilation /

Analyseur lexical Flex

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

<< Syntaxe du langage Simple | Analyseur lexical | Analyseur syntaxique >>

On va passer maintenant au côté pratique. Nous pouvons commencer le développement du compilateur. Pour rappel la première chose que fait un compilateur est l'analyse lexicale. C'est donc là que nous allons commencer. Nous allons utiliser Flex qui générera un analyseur lexical pour le langage Simple.

Je vous donne le code de Flex un peu à la dure. Mais je juge l'avoir suffisamment bien commenté pour le comprendre. On commence par créer un fichier lexique_simple.lex qui contiendra le code suivant :

lexique_simple.lex
  1. /*
  2.  
  3. En Flex, on commence par les eventuelles declarations C que l'on met entre les balises %{ et %}.
  4. Entre ces balises, j'ai inclus la stdlib et la stdio de C. J'ai aussi declare 1 variable de type int.
  5. La variable lineno correspond au numero de ligne.
  6. La variable error est un booleen. Il est a true si une erreur est detectee.
  7. Il existe la variable globale yylineno dans Flex que l'on peut ajouter en option. C'est cense gerer le numero de ligne tout seul mais pour des raisons inexpliquees, elle ne s'incremente pas chez moi.
  8. Je prefere donc gerer le mecanisme de numero de ligne moi-meme.
  9.  
  10. */
  11.  
  12. %{
  13.  
  14. #include <stdlib.h>
  15. #include <stdio.h>
  16. #include <stdbool.h>
  17. void lexeme(void);
  18. unsigned int lineno=1;
  19. bool error=false;
  20.  
  21. %}
  22.  
  23. /*
  24.  
  25. Juste apres on declare les eventuelles variables Flex. Ce sont nos terminaux associes reconnus par des expressions regulieres.
  26.  
  27. */
  28.  
  29. /* [[:digit:]] equivaut a [0-9] */
  30.  
  31. nombre 0|[1-9][[:digit:]]*
  32.  
  33. /* [[:alpha:]] equivaut a [a-zA-Z] (tout les caracteres de l'alphabet majuscules et minuscules) et [[:alnum:]] equivaut a [a-zA-Z0-9] (tout les caracteres alphanumeriques) */
  34.  
  35. variable [[:alpha:]][[:alnum:]]*
  36.  
  37. /*
  38.  
  39. Entre les %% on ecrit toutes les actions a chaque fois que l'analyseur detectera des lexemes (terminaux) de Simple.
  40. On ecrit donc l'ensemble des terminaux de Simple.
  41.  
  42. */
  43.  
  44. %%
  45.  
  46. {nombre} {
  47.         printf("\tNombre trouve a la ligne %d. Il s'agit du nombre %s et comporte %d chiffre(s)\n",lineno,yytext,yyleng);
  48. }
  49.  
  50. "afficher"      {lexeme();}
  51.  
  52. "="             {lexeme();}
  53.  
  54. "+"             {lexeme();}
  55.  
  56. "-"             {lexeme();}
  57.  
  58. "*"             {lexeme();}
  59.  
  60. "/"             {lexeme();}
  61.  
  62. "("             {lexeme();}
  63.  
  64. ")"             {lexeme();}
  65.  
  66. "et"            {lexeme();}
  67.  
  68. "ou"            {lexeme();}
  69.  
  70. "non"           {lexeme();}
  71.  
  72. ";"             {lexeme();printf("\n");}
  73.  
  74. "vrai"          {lexeme();}
  75.  
  76. "faux"          {lexeme();}
  77.  
  78. "\n"            {lineno++;}
  79.  
  80.  /* Si j'avais defini l'action de variable au debut, l'analyseur ne verrait plus les lexemes comme afficher ou supprimer mais comme des variables portant ce nom. L'ordre de definition des regles pour chaque lexemes n'est donc pas sans logique en Flex */
  81.  
  82. {variable} {
  83.         printf("\tVariable trouvee a la ligne %d. Il s'agit de %s et comporte %d lettre(s)\n",lineno,yytext,yyleng);
  84. }
  85.  
  86.  /* L'analyseur ne fait rien pour les espaces et tabulations */
  87.  
  88. " "|"\t" {}
  89.  
  90.  /* Le point est tout le reste qui n'a pas ete defini precedemment. Il est donc a mettre en dernier. */
  91.  
  92. . {
  93.         fprintf(stderr,"\tERREUR : Lexeme inconnu a la ligne %d. Il s'agit de %s et comporte %d lettre(s)\n",lineno,yytext,yyleng);
  94.         error=true;
  95. }
  96.  
  97.  
  98. %%
  99.  
  100. /*
  101.  
  102. J'ecris ici mes fonctions C apres le %%
  103. Ma fonction main appellera la fonction de parsing yylex() qui sera construite a la compilation de la source Flex. C'est une fonction qui parse et detecte les lexemes (non terminaux) que nous avons defini dans notre programme Flex.
  104. Le main n'est pas obligatoire. On peut utiliser la fonction main par defaut de Flex (qui ne fait qu'appeler yylex() seulement), il faut dans ce cas specifier main en option.
  105.  
  106. */
  107.  
  108. int main(){
  109.         printf("Debut de l'analyse lexicale :\n");
  110.         yylex();
  111.         printf("Fin de l'analyse !\n");
  112.         printf("Resultat :\n");
  113.         if(error){
  114.                 printf("\t-- Echec : Certains lexemes ne font pas partie du lexique du langage ! --\n");
  115.         }
  116.         else{
  117.                 printf("\t-- Succes ! --\n");
  118.         }
  119.         return EXIT_SUCCESS;
  120. }
  121.  
  122. /*
  123.  
  124. La variable globale yytext contient le lexeme courant lu par l'analyseur.
  125.  
  126. */
  127.  
  128. void lexeme(){
  129.         printf("\tLexeme '%s' trouve a la ligne %d\n",yytext,lineno);
  130. }
  131.  
  132. /*
  133.  
  134. La fonction yywrap() est appelee des que l'analyseur lexicale detecte le caractere EOF (End Of File). Elle doit retourner 1 pour mettre fin a l'analyse.
  135. Cette fonction n'est pas obligatoire. On peut utiliser la fonction yywrap() par defaut de Flex (qui ne fait que retourner 1 juste), il faut dans ce cas specifier noyywrap en option.
  136.  
  137. */
  138.  
  139. int yywrap(){
  140.         printf("\tFin de fichier detecte !\n");
  141.         return 1;
  142. }
[$[Get Code]]

On compile notre fichier Flex :

flex -o lexique_simple.c lexique_simple.lex
[$[Get Code]]

Flex génère une source C qui contient la fonction yylex(). Ici je lui ai demandé à la compilation que le nom de fichier sorti soit lexique_simple.c. Sinon par défaut le fichier de sortie s'appelle yy.lex.c. On peut aussi le spécifier en option dans le code flex. On compile maintenant le fichier C généré :

gcc -o lexique_simple lexique_simple.c
[$[Get Code]]

On obtient alors un exécutable. C'est notre analyseur lexicale du langage Simple prêt à tourner !

Créons maintenant un fichier programme.simple où on va écrire un programme en Simple. On va volontairement mettre des caractères spéciaux à la dernière ligne. Il devrait nous avertir des erreurs lexicales.

programme.simple
  1. monEntier = 6 ; monBooleen = faux ;
  2.  
  3. afficher monEntier ;
  4. afficher monBooleen ;
  5. afficher 4 ;
  6. afficher non ( ( vrai et faux ) ou vrai ) ;
  7. afficher 6/3 ;
  8.  
  9. @#!%^$
[$[Get Code]]

On donne ce programme à notre analyseur lexicale :

./lexique_simple < programme.simple
[$[Get Code]]

L'analyseur nous renvoit tout les lexèmes qu'il a reconnu un par un. A chaque instruction il fait un saut de ligne.

Debut de l'analyse lexicale :
        Variable trouvee a la ligne 1. Il s'agit de monEntier et comporte 9 lettre(s)
        Lexeme '=' trouve a la ligne 1
        Nombre trouve a la ligne 1. Il s'agit du nombre 6 et comporte 1 chiffre(s)
        Lexeme ';' trouve a la ligne 1

        Variable trouvee a la ligne 1. Il s'agit de monBooleen et comporte 10 lettre(s)
        Lexeme '=' trouve a la ligne 1
        Lexeme 'faux' trouve a la ligne 1
        Lexeme ';' trouve a la ligne 1

        Lexeme 'afficher' trouve a la ligne 3
        Variable trouvee a la ligne 3. Il s'agit de monEntier et comporte 9 lettre(s)
        Lexeme ';' trouve a la ligne 3

        Lexeme 'afficher' trouve a la ligne 4
        Variable trouvee a la ligne 4. Il s'agit de monBooleen et comporte 10 lettre(s)
        Lexeme ';' trouve a la ligne 4

        Lexeme 'afficher' trouve a la ligne 5
        Nombre trouve a la ligne 5. Il s'agit du nombre 4 et comporte 1 chiffre(s)
        Lexeme ';' trouve a la ligne 5

        Lexeme 'afficher' trouve a la ligne 6
        Lexeme 'non' trouve a la ligne 6
        Lexeme '(' trouve a la ligne 6
        Lexeme '(' trouve a la ligne 6
        Lexeme 'vrai' trouve a la ligne 6
        Lexeme 'et' trouve a la ligne 6
        Lexeme 'faux' trouve a la ligne 6
        Lexeme ')' trouve a la ligne 6
        Lexeme 'ou' trouve a la ligne 6
        Lexeme 'vrai' trouve a la ligne 6
        Lexeme ')' trouve a la ligne 6
        Lexeme ';' trouve a la ligne 6

        Lexeme 'afficher' trouve a la ligne 7
        Nombre trouve a la ligne 7. Il s'agit du nombre 6 et comporte 1 chiffre(s)
        Lexeme '/' trouve a la ligne 7
        Nombre trouve a la ligne 7. Il s'agit du nombre 3 et comporte 1 chiffre(s)
        Lexeme ';' trouve a la ligne 7

        ERREUR : Lexeme inconnu a la ligne 9. Il s'agit de @ et comporte 1 lettre(s)
        ERREUR : Lexeme inconnu a la ligne 9. Il s'agit de # et comporte 1 lettre(s)
        ERREUR : Lexeme inconnu a la ligne 9. Il s'agit de ! et comporte 1 lettre(s)
        ERREUR : Lexeme inconnu a la ligne 9. Il s'agit de % et comporte 1 lettre(s)
        ERREUR : Lexeme inconnu a la ligne 9. Il s'agit de ^ et comporte 1 lettre(s)
        ERREUR : Lexeme inconnu a la ligne 9. Il s'agit de $ et comporte 1 lettre(s)
        Fin de fichier detecte !
Fin de l'analyse !
Resultat :
        -- Echec : Certains lexemes ne font pas partie du lexique du langage ! --
[$[Get Code]]

Les derniers caractères spéciaux n'ont pas été reconnu. Il ne font pas partie de l'ensemble des terminaux de Simple. Le programme ne passe pas à l'analyse lexicale (la première étape de la compilation).

Créons maintenant un second fichier contenant des instructions sans aucun sens et ne répondant pas à la syntaxe de Simple :

programme_faux.simple
  1. 68 afficher;
  2. france japon usa = 85;
  3. ecrire 78 et 49
  4. japon = 118 et afficher japon;
  5. vrai+faux=19;
[$[Get Code]]

Passons ce fichier à notre analyseur lexical.

./lexique_simple < programme_faux.simple
[$[Get Code]]

Le résultat de l'analyse est le suivant :

Debut de l'analyse lexicale :
        Nombre trouve a la ligne 1. Il s'agit du nombre 68 et comporte 2 chiffre(s)
        Lexeme 'afficher' trouve a la ligne 1
        Lexeme ';' trouve a la ligne 1

        Variable trouvee a la ligne 2. Il s'agit de france et comporte 6 lettre(s)
        Variable trouvee a la ligne 2. Il s'agit de japon et comporte 5 lettre(s)
        Variable trouvee a la ligne 2. Il s'agit de usa et comporte 3 lettre(s)
        Lexeme '=' trouve a la ligne 2
        Nombre trouve a la ligne 2. Il s'agit du nombre 85 et comporte 2 chiffre(s)
        Lexeme ';' trouve a la ligne 2

        Variable trouvee a la ligne 3. Il s'agit de ecrire et comporte 6 lettre(s)
        Nombre trouve a la ligne 3. Il s'agit du nombre 78 et comporte 2 chiffre(s)
        Lexeme 'et' trouve a la ligne 3
        Nombre trouve a la ligne 3. Il s'agit du nombre 49 et comporte 2 chiffre(s)
        Variable trouvee a la ligne 4. Il s'agit de japon et comporte 5 lettre(s)
        Lexeme '=' trouve a la ligne 4
        Nombre trouve a la ligne 4. Il s'agit du nombre 118 et comporte 3 chiffre(s)
        Lexeme 'et' trouve a la ligne 4
        Lexeme 'afficher' trouve a la ligne 4
        Variable trouvee a la ligne 4. Il s'agit de japon et comporte 5 lettre(s)
        Lexeme ';' trouve a la ligne 4

        Lexeme 'vrai' trouve a la ligne 5
        Lexeme '+' trouve a la ligne 5
        Lexeme 'faux' trouve a la ligne 5
        Lexeme '=' trouve a la ligne 5
        Nombre trouve a la ligne 5. Il s'agit du nombre 19 et comporte 2 chiffre(s)
        Lexeme ';' trouve a la ligne 5

        Fin de fichier detecte !
Fin de l'analyse !
Resultat :
        -- Succes ! --
[$[Get Code]]

L'analyseur a sans surprise reconnu tout les mots. Le fichier passe bien à l'analyse lexicale. Cependant on voit bien que la syntaxe n'est pas du tout bonne, elle ne respecte clairement pas la grammaire de Simple défini au chapitre précédent. L'analyse lexicale ne suffit donc pas pour faire de la compilation. Il est essentiel de faire une analyse syntaxique. C'est ce que nous allons tout de suite voir au chapitre suivant.

<< Syntaxe du langage Simple | Analyseur lexical | Analyseur syntaxique >>

Thomas - (CC BY-NC-SA 3.0 FR)

Page last modified on July 09, 2017, at 07:33 PM EST

This page has been requested 11050 times (Today : 7) - Total number of requests : 262892

Edit - History - Statistics - Print - Recent Changes - Search

Clin d'oeil aux victimes des attentats survenus dans la soirée du 13 novembre 2015. La nouvelle version du site a été installée quelques heures avant.